Proxy Aliases reference
Section titled “Proxy Aliases reference”Lookup tables for proxy aliases. Every route, field and response is also in the Proxy Aliases API.
Request fields
Section titled “Request fields”| Field | Rule |
|---|---|
computer_id | Required on create. The computer the alias routes to; you must own it. Fixed after create: to repoint, delete the alias and create a new one for the new computer |
alias | 3 to 61 characters, see naming rules. Omit it, or send null or false, for a generated, unique 48-character hexadecimal name such as a3f9b2c1d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3 |
program | Required on create. See programs |
port | 1 to 65535, for http and https: the port your server listens on inside the computer |
index | The instance of a built-in program, default 1. For http and https it is read as the port |
target_path | Landing path of a root request, with any query written in it. Up to 2048 characters; a missing leading / is added. Spaces, percent escapes, non-ASCII characters, # fragments, and . or .. path segments are rejected with 400. See path routing |
allow_path_override | Default true. See path routing |
expires_at | See expiration |
enabled | Default true on create. Set it with PATCH /api/v1/proxy/aliases/{id}/state (enable, disable) or in an update |
An update changes program, port, index, target_path, allow_path_override, expires_at, alias and enabled, and only the fields you send. The target computer cannot be changed.
Generated URL or alias
Section titled “Generated URL or alias”| Generated URL | Alias | |
|---|---|---|
| Form | {projectId}-{computerId}-{service}-{instance}.{server}.computers.hoody.com | {alias}.{server}.computers.hoody.com, where {server} is where the computer runs |
| Created | Automatically, for every program the computer runs, one per service | By you, one program each |
| Guessing | Unguessable: the two IDs are 48 characters, so sharing the URL is what grants access | Guessable if the pattern is known, and open to enumeration |
| Typing and branding | Cannot be typed, remembered or printed on a business card | Short, typeable, brandable; a CNAME target for your domain |
| Access | The computer’s proxy permissions | The same permissions, applied the same way |
| Suits | Development, collaboration and internal tools | Public APIs and web services, with permissions |
Creating an alias leaves the generated URL working. A generated URL shared before permissions are set lets anyone holding it reach the service; see open by default.
Programs
Section titled “Programs”program is required because one computer runs several services and the alias names the one it routes to. It must be a built-in Hoody program or a transport protocol (http, https); any other value is rejected.
The Agent program cannot be reached through a proxy alias, even though the create request accepts program: "agent". Use its generated computer URL instead. The create request also accepts program: "ssh", but such an alias never routes either. Connect over SSH with the computer’s SSH hostname or the shared endpoint ssh.{server}.computers.hoody.com. See which hostname to use.
program | Routes to | Instance or port |
|---|---|---|
http, https | A web server or API you run inside the computer, such as Node.js, Python or Go | A target port, the port your server listens on (3000, 8080, 5000), is required: send port (recommended), a program such as http-3000, or index. Without one the create is refused with 400 PORT_REQUIRED. port wins over a port in program, which wins over index |
exec | Hoody Exec scripts as APIs, see script routing | index, default 1 |
terminal | The terminal interface | index, default 1, so {"computer_id": "…", "program": "terminal"} is valid |
display | The desktop environment | index, default 1 |
code | The code editor interface | index, default 1 |
Switching an alias from a built-in program to http or https needs a port in the same update. Two http aliases on ports 3000 and 8080, such as frontend and backend, reach two servers in one computer.
Naming rules
Section titled “Naming rules”| Rule | Detail |
|---|---|
| Length | 3 to 61 characters |
| Characters | Lowercase a-z, digits 0-9 and hyphens; pattern ^[a-z0-9]([a-z0-9-]*[a-z0-9])?$ |
| Start and end | A letter or digit |
| Reserved exactly | computers and containers |
| Reserved services | egress, workspaces, workspace and os, as the whole label or followed by a hyphen. os, os-admin and workspace-2 are refused; egressmyapp and ostrich are fine, because the match is on a label boundary |
| Computer URL shapes | Refused: anything starting with the {projectId}-{computerId} form (two 24-hex-character labels), or that shape after an egress-, workspaces- or proxy- prefix |
| Router names | api, admin, system, internal: created, never routed, see below |
Valid: my-api, staging-frontend, app-v2, prod. Invalid: -myapp (starts with a hyphen), my_api (underscore), MY-APP (uppercase).
Names the router refuses
Section titled “Names the router refuses”api, admin, system and internal are reserved by the reverse proxy on the same label-boundary rule: the bare word, and anything starting api-, admin-, system- or internal-, never routes. apiary and administer are distinct labels and route normally.
The create call does not enforce this. "alias": "api-v1" returns 201 with a url that never routes, with no error or warning. If a customer domain already points at api-v1.node-us.computers.hoody.com or admin-dashboard.node-us.computers.hoody.com, DNS resolves and the request dies at the proxy: rename the alias to a form that does not lead with a reserved word, such as v1-api or ops-dashboard, and repoint the CNAME. The customer domain itself can be anything.
Uniqueness and limits
Section titled “Uniqueness and limits”A name is unique across a physical server and all its subservers, across every account, and within your account across all servers. Another account can use the same name on a different physical server. Your own duplicate returns 409 ALIAS_IN_USE with data.scope "account"; a conflict on the physical server or any of its subservers returns "server".
To find a free name, add your company or an identifier (acme-api, my-app-prod, my-app-eu), or let Hoody generate one. Long, specific names (acme-prod-api-v2-us-2025) are harder to guess than api or app, but only proxy permissions stop a guess from granting access.
Each server has an alias limit. Disabled and expired aliases still count, but aliases of deleted computers, computers whose server access has expired, or computers whose owner no longer holds the server do not. Each subserver has its own count, separate from its parent and other subservers. Pricing lists the current limits.
| Server | Aliases |
|---|---|
| Free server | 3 |
| Paid subserver | The plan’s limit: 50 on Plus, 250 on Pro |
| Rented server | 5000 by default |
A create over the limit creates nothing and returns 422. The error has no code of its own: recognise it by data.field = proxy_alias_limit.
{ "statusCode": 422, "error": "Validation Error", "message": "Alias limit reached: this server has reached its limit of 3 aliases. Delete one, or upgrade for more.", "data": { "field": "proxy_alias_limit", "current_count": 3, "limit": 3, "server_type": "slice", "upgrade": { "kind": "buy_paid_subserver" } }}data.upgrade | What to do |
|---|---|
{"kind": "buy_paid_subserver"}, on a free server | Buy a paid subserver and create the alias for a computer there |
{"kind": "upgrade_subscription", "subscription_id": "..."}, on a paid subserver whose plan can grow | Upgrade that subscription |
| Absent | Delete an alias on that server (DELETE /api/v1/proxy/aliases/{id}), or create the alias for a computer on another server |
Path routing
Section titled “Path routing”target_path supplies the destination of a root request (/), including any query written in it; it is never a prefix for other paths. allow_path_override applies the same way to the alias hostname and to a custom domain pointed at it.
Do not put terminal_id, display, browser_port, id, workspaces_id, or a parameter already set by the selected service in target_path. For both open and pinned aliases, a request served from such a target returns 404 ALIAS_TARGET_QUERY_FORCED_KEY. Select the instance with index.
With true, the default, every path is forwarded as sent. A root request lands on target_path, with its query followed by the visitor’s own parameters:
# allow_path_override: true, target_path "/api/v1"https://my-api.node-us.computers.hoody.com/ → /api/v1 (target_path)https://my-api.node-us.computers.hoody.com/api/v1/users → /api/v1/users (forwarded as sent)https://my-api.node-us.computers.hoody.com/admin → /admin (forwarded as sent)With false, the alias serves only the root or target_path itself. A request the proxy permissions refuse gets their answer. One they admit:
- a request to
/, or totarget_path, lands ontarget_path, and one trailing slash is accepted; - any other path, sub-paths and assets included, gets
404with the codeALIAS_PATH_PINNEDand the message “This alias serves only its root and its target path”; - a query parameter written in
target_pathkeeps its value, and a visitor’s parameter of the same name is dropped; - a visitor’s instance selector, such as
terminal_id,displayorid, does not replace the one the proxy sets; - the method, request body, other query parameters, WebSocket upgrade and
Rangeheader pass, so a pinned alias can front one endpoint that takes aPOSTwith a JSON body.
# allow_path_override: false, target_path "/api/v1/status?format=json"https://status.node-us.computers.hoody.com/ → /api/v1/status?format=jsonhttps://status.node-us.computers.hoody.com/?format=xml → /api/v1/status?format=json (target_path's value wins)https://status.node-us.computers.hoody.com/?verbose=1 → /api/v1/status?format=json&verbose=1https://status.node-us.computers.hoody.com/api/v1/status → /api/v1/status?format=json (target_path itself)https://status.node-us.computers.hoody.com/api/v1/status/ → /api/v1/status?format=json (one trailing slash)https://status.node-us.computers.hoody.com/api/v1/status/x → 404 ALIAS_PATH_PINNED (sub-path)https://status.node-us.computers.hoody.com/users → 404 ALIAS_PATH_PINNEDAn interactive kit (terminal, code, browser, files), an app that loads CSS, JS or images, and an API with several routes need true. Neither field controls who can open the alias: anyone with the link can, unless proxy permissions say otherwise. Permissions authenticate per program and port, with no path selector.
Host header
Section titled “Host header”A web app on an http service (http-<port>, or plain http or https) reached through an alias receives the host the visitor typed in Host: the alias hostname, or a custom domain pointed at it. An app that checks Host against an allow-list must list the alias and every custom domain, or it refuses the request: allowedHosts in the Vite or webpack dev server, ALLOWED_HOSTS in Django, an nginx server_name, a Caddy site address.
Hoody’s own kits receive their computer URL in Host. X-Forwarded-Host always carries the host the visitor typed. See Which Host header does my app receive?.
Expiration
Section titled “Expiration”| Value | Create (POST) | Update (PATCH) |
|---|---|---|
ISO 8601 string, such as "2027-07-12T00:00:00.000Z" | Yes | Yes |
Unix timestamp in seconds or milliseconds, such as 1815350400 | No | Yes |
null, no expiration | Yes | Yes |
Prefer ISO 8601 everywhere. Non-null expiration dates must be strictly in the future; a past or current date returns 400. On update, numeric 0 also clears expiration; prefer null to express no expiration. After expires_at passes, the alias stops routing and answers 404 to every request. The configuration is kept: clear expires_at and set enabled: true to restore routing. Expired aliases still count toward the alias limit, and expired=true lists them.
Uses: a demo environment that ends with a customer trial, an event-specific URL, a beta URL that expires when you move to production.
When changes apply
Section titled “When changes apply”| Change | When it reaches the alias URL |
|---|---|
| Update, disable, enable | Usually within about 30 seconds, sometimes longer. Until then the alias keeps its previous behavior |
| Rename | As an update; the old name may keep serving until then |
| Delete | Usually within about 30 seconds. Your account can reuse the name then: recreating it earlier can return 409, so retry after a short wait. Other accounts must wait out a 90-day hold (lifecycle) |
A disabled alias answers 404 and keeps its configuration, so you can take an API offline for maintenance and bring it back.
Lifecycle
Section titled “Lifecycle”| Event | Effect on aliases |
|---|---|
| Delete the computer | Its aliases are deleted too, and their URLs stop resolving shortly after. You do not need to delete them first. The names are held for your account for 90 days, possibly on every server; to reuse one, create a new alias with that name for the new computer |
| Delete an alias | Permanent. For 90 days after release, another account cannot claim the name on the same physical server or any of its subservers; a name released when its computer is deleted may be held on every server. You can reuse your released name once deletion finishes, provided no other conflict applies. Another account may claim the name after the hold, so remove obsolete CNAME records and do not rely on long-lived cookies or credentials on an alias address |
| Computer stopped | You can still create aliases for it. Requests fail until you start the computer, so you can set up production URLs before deployment |
| Snapshot and restore | Aliases belong to the account, not to the computer. Restore a snapshot of computer A into computer B and an alias such as my-app still points to A; to route to B, delete it and create one for B’s ID |
| Custom domains | GET /api/v1/proxy/aliases/{id} shows the alias, not which domains CNAME to it: that is in your DNS provider. Keep your own record of CNAME mappings (a spreadsheet, a wiki, infrastructure as code) |
| Several aliases, one service | Allowed: several names with the same computer_id and program, for versions (v1-api and v2-api) or several brand domains |
Script routing on hoody-exec
Section titled “Script routing on hoody-exec”An alias for program: "exec" gives the whole script tree a short hostname, and the path you request is the route, exactly as on the generated -exec-1 URL. Add target_path to land somewhere other than the script root.
# Scripts in the computerapi/users.tsapi/posts.tswebhooks/stripe.ts
# Access by pathhttps://my-scripts.node-us.computers.hoody.com/api/users → runs api/users.tshttps://my-scripts.node-us.computers.hoody.com/webhooks/stripe → runs webhooks/stripe.tsDo not put a label in front of an alias: https://api.my-scripts.node-us.computers.hoody.com/users is a different hostname, not a shorter spelling of the one above, and nothing routes. A dot is not a legal alias character.
Hoody Exec keeps per-subdomain script trees (scripts/<subdomain>/…) and reads the subdomain from Host. Through an alias, Hoody Exec receives its computer URL ({projectId}-{computerId}-exec-{index}.{server}.computers.hoody.com) in Host, not the alias name, so the subdomain is always default. By default, an alias with "index": 1 searches scripts/default/1/, then scripts/default/, then scripts/1/, then the scripts root. A regular .exclusive file in scripts/default/1/ restricts lookup to that instance folder. See Hoody Exec.
Errors
Section titled “Errors”Every status of every route is on the Proxy Aliases API page.
| Status and message | Cause | What to do |
|---|---|---|
400 Bad Request; data.reserved_alias or data.reserved_prefix names a reserved word, data.field alias a computer URL shape | A reserved name or prefix, or a computer URL shape | Pick a name that follows the naming rules |
400 PORT_REQUIRED | An http or https alias without a port, on create or when switching from a built-in program | Send port, or use http-3000 |
404 ALIAS_PATH_PINNED, “This alias serves only its root and its target path” | A path other than / or target_path under allow_path_override: false | Use true, or link to the root |
404 at the alias URL | The alias is disabled, expired or deleted | enable it, or clear expires_at and set enabled: true |
409 ALIAS_IN_USE, “Alias is already in use.” | data.scope "server": another account holds the name on this server, or a release hold prevents its reuse. "account": your account holds it, on any server, this one included; "account" is reported when both apply | Choose another name or a suffix (my-app-v2, my-app-prod). For "account", delete or rename your alias; list without filters to find it, since it can be on another project or server |
409 right after a delete | The delete has not reached the alias URL yet | Retry after a short wait |
409 Conflict on create, update or delete, message starting computer_finalizing | The alias’s computer is still being set up | Retry shortly |
422 “Alias limit reached: …” | The server holds its limit of aliases | See the alias limit |
{ "statusCode": 409, "error": "ALIAS_IN_USE", "message": "Alias is already in use.", "data": { "field": "alias", "value": "my-app", "scope": "server" }}Troubleshooting
Section titled “Troubleshooting”| Symptom | Cause | What to do |
|---|---|---|
| The alias does not route | Disabled, computer stopped, service not started, or permissions | Check enabled: true with GET /api/v1/proxy/aliases/{id}, then status: "running" with GET /api/v1/computers/{id}, then that the service is started in the computer. Open the generated URL first to rule out permissions |
Created with 201, but the URL never routes | The name equals api, admin, system or internal, or starts with one of those words followed by a hyphen | Rename it; see names the router refuses |
| A custom domain does not reach the alias yet | DNS propagation: CNAME changes take 5 to 60 minutes | Wait, test from several locations, and check with dig api.mycompany.com that it points to the alias |
Pages load but CSS, JS or other routes answer 404 | allow_path_override: false | Set it to true |
| Your app refuses requests through the alias | It checks Host against an allow-list | Add the alias and your domains, see Host header |
Recipes
Section titled “Recipes”Each body goes to POST /api/v1/proxy/aliases: it is the create request the guide shows in CLI, SDK, HTTP and URL form.
Production API alias
Section titled “Production API alias”A permanent alias whose root lands on the API base path, with every other route still reachable:
{ "computer_id": "890abcdef12345678901cdef", "alias": "prod-api", "program": "http", "port": 3000, "target_path": "/api/v1", "allow_path_override": true, "expires_at": null}https://prod-api.node-us.computers.hoody.com/ → the computer's /api/v1https://prod-api.node-us.computers.hoody.com/users → /users (forwarded as sent)Version aliases
Section titled “Version aliases”v1-api on one computer, v2-api and beta-api on another, all "program": "http", "port": 3000:
https://v1-api.node-us.computers.hoody.com → old version (computer_id 890abcdef12345678901cdef)https://v2-api.node-us.computers.hoody.com → new version (computer_id 890abcdef12345678901cdee)https://beta-api.node-us.computers.hoody.com → beta, same computer as v2When ready, delete v1-api and rename v2-api to v1-api, or update client references.
Staging and production on one computer
Section titled “Staging and production on one computer”- Develop on the generated URL.
- Create a staging alias for team testing, such as
staging-myapp(https://staging-myapp.node-us.computers.hoody.com). - Restrict staging to the office with an IP group, the first write below.
- Test on
staging-myapp.node-us.computers.hoody.comwith your team, clients and QA. - Snapshot the computer when ready.
- Create the production alias, such as
myapp(https://myapp.node-us.computers.hoody.com). - Point your domain at it:
api.mycompany.com CNAME myapp.node-us.computers.hoody.com. The result ishttps://api.mycompany.com, with automatic SSL. - Require a JWT for production, the second write below.
- Production is live. If something goes wrong, roll back to the snapshot.
Steps 5 and 9, snapshot and rollback. A restore replaces the computer’s current state with the snapshot. Every field and response is on the Computer Snapshots API.
In the Hub, open Computers, select the computer and open Backups. Choose Take snapshot, enter its name and press Take snapshot. To roll back, choose Restore on that snapshot and confirm with Restore computer.
In the Hub, open Computers, select the computer and open Ports & addresses. Under Aliases, choose Create alias, enter your app’s port in Port and the alias name in Alias, then choose Create alias. Use staging-myapp for step 2 and myapp for step 6.
# Step 5: snapshot the tested computerhoody snapshots create -c "$COMPUTER_ID" --alias 'pre-prod-2025-11-09'
# Step 9 rollback: the snapshot's name is its alias, sanitizedhoody snapshots restore 'pre-prod-2025-11-09' -c "$COMPUTER_ID" -yimport { HoodyClient } from 'hoody-sdk';
const client = new HoodyClient({ baseURL: 'https://api.hoody.com', token: process.env.HOODY_TOKEN });const COMPUTER_ID = process.env.COMPUTER_ID!;
// Step 5: snapshot the tested computerconst snap = await client.api.snapshots.create(COMPUTER_ID, { alias: 'pre-prod-2025-11-09' });
// Step 9 rollback: use data.snapshot.name from the create responseconst snapshotName = snap.data.snapshot?.name;if (!snapshotName) throw new Error('Missing snapshot name');await client.api.snapshots.restore(COMPUTER_ID, snapshotName);# Step 5: snapshot the tested computer, keep data.snapshot.nameRESP=$(curl -sf -X POST "https://api.hoody.com/api/v1/computers/$COMPUTER_ID/snapshots" \ -H "Authorization: Bearer $HOODY_TOKEN" \ -H "Content-Type: application/json" \ -d '{"alias": "pre-prod-2025-11-09"}') || { echo "snapshot failed" >&2; exit 1; }SNAPSHOT_NAME=$(jq -r '.data.snapshot.name' <<<"$RESP")
# Step 9 rollbackcurl -X PUT "https://api.hoody.com/api/v1/computers/$COMPUTER_ID/snapshots/$SNAPSHOT_NAME" \ -H "Authorization: Bearer $HOODY_TOKEN"Replace COMPUTER_ID, and SNAPSHOT_NAME with data.snapshot.name from the first response. The second link restores the computer.
# Step 5: snapshothttps://PROJECT_ID-COMPUTER_ID-curl-1.SERVER.computers.hoody.com/api/v1/curl/request?url=https://api.hoody.com/api/v1/computers/COMPUTER_ID/snapshots&method=POST&bearer_token=HOODY_TOKEN&json={"alias":"pre-prod-2025-11-09"}&response=transparent
# Step 9: roll backhttps://PROJECT_ID-COMPUTER_ID-curl-1.SERVER.computers.hoody.com/api/v1/curl/request?url=https://api.hoody.com/api/v1/computers/COMPUTER_ID/snapshots/SNAPSHOT_NAME&method=PUT&bearer_token=HOODY_TOKEN&response=transparentOne request, one link
cURL runs inside your computer and can wrap any HTTP request into a single GET URL. The call stops being something you need a client for and becomes something you can paste into a browser, send in a chat, bookmark, schedule with cron, or drop into a no-code tool.
Nothing is installed on the machine that opens it. The link does carry whatever credentials the call needs, so treat it as you would treat those credentials. It also appears in the cURL service's request log, not only the target's. Prefer a delegated token with minimal permissions and an expiry: see API tokens.
Slashes, colons and braces pass through as they are. The one character you must
encode is an & inside a value, which happens when the wrapped URL
carries its own query string. Left raw it ends the value early, and the rest is
read as cURL's own parameters, so you get a 200 on a request you did
not make.
How the wrapping works Chaining calls into one link Turning a link into a shortcut
Both aliases share the computer’s one permissions document. These writes (PUT /api/v1/computers/{id}/proxy/permissions) replace the whole document, so each needs the current etag in If-Match (428 without it, 412 when it is stale). The CLI, SDK and URL forms of the same write are in Give one computer its own rules.
Step 3, office only. Replace 203.0.113.0/24 with your office’s public IP range:
CURRENT_ETAG=$(curl -s "https://api.hoody.com/api/v1/computers/$COMPUTER_ID/proxy/permissions" \ -H "Authorization: Bearer $HOODY_TOKEN" | jq -r '.data.etag')
curl -X PUT "https://api.hoody.com/api/v1/computers/$COMPUTER_ID/proxy/permissions" \ -H "Authorization: Bearer $HOODY_TOKEN" \ -H "If-Match: $CURRENT_ETAG" \ -H "Content-Type: application/json" \ -d '{ "project": "'"$PROJECT_ID"'", "computer": "'"$COMPUTER_ID"'", "groups": { "office": { "type": "ip", "range": "203.0.113.0/24" } }, "permissions": { "office": { "http": [3000] } }, "default": "deny" }'Step 8, JWT for production:
CURRENT_ETAG=$(curl -s "https://api.hoody.com/api/v1/computers/$COMPUTER_ID/proxy/permissions" \ -H "Authorization: Bearer $HOODY_TOKEN" | jq -r '.data.etag')
curl -X PUT "https://api.hoody.com/api/v1/computers/$COMPUTER_ID/proxy/permissions" \ -H "Authorization: Bearer $HOODY_TOKEN" \ -H "If-Match: $CURRENT_ETAG" \ -H "Content-Type: application/json" \ -d '{ "project": "'"$PROJECT_ID"'", "computer": "'"$COMPUTER_ID"'", "groups": { "customers": { "type": "jwt", "secret": "a-long-random-signing-key-with-32-plus-chars", "algorithm": "HS256", "sources": ["header:Authorization"] } }, "permissions": { "customers": { "http": [3000] } }, "default": "deny" }'Replace the secret with your own random signing key of at least 32 characters, and keep it private.
Development: https://67e89abc123def456789abcd-890abcdef12345678901cdef-exec-1.node-us.computers.hoody.com (generated URL)Staging: https://staging-myapp.node-us.computers.hoody.comProduction: https://api.mycompany.com (JWT auth, custom domain)After step 8, the full-replacement write has removed the office group and installed the customers JWT group: both HTTP aliases require a JWT, and the exec URL is denied by the default policy. When staging and production need different policies, use separate computers or different program or port rules.
Update many aliases
Section titled “Update many aliases”List, then update each id. This gives every alias of one project a new landing path:
LIST=$(hoody proxy aliases list --project-id '67e89abc123def456789abcd' -o json) || exit 1for ID in $(jq -r '.aliases[].id' <<<"$LIST"); do hoody proxy aliases update "$ID" --target-path /v2 || echo "update failed: $ID" >&2doneimport { HoodyClient } from 'hoody-sdk';
const client = new HoodyClient({ baseURL: 'https://api.hoody.com', token: process.env.HOODY_TOKEN });
for await (const alias of client.api.proxy.aliases.listIterator({ project_id: '67e89abc123def456789abcd' })) { await client.api.proxy.aliases.update(alias.id, { target_path: '/v2' });}LIST=$(curl -sf "https://api.hoody.com/api/v1/proxy/aliases?project_id=67e89abc123def456789abcd" \ -H "Authorization: Bearer $HOODY_TOKEN") || { echo "list failed" >&2; exit 1; }for ID in $(jq -r '.data.aliases[].id' <<<"$LIST"); do curl -sf -X PATCH "https://api.hoody.com/api/v1/proxy/aliases/$ID" \ -H "Authorization: Bearer $HOODY_TOKEN" \ -H "Content-Type: application/json" \ -d '{"target_path": "/v2"}' > /dev/null || echo "update failed: $ID" >&2done// Every alias of one project gets a new landing pathconst projectAliases = await fetch( 'https://api.hoody.com/api/v1/proxy/aliases?project_id=67e89abc123def456789abcd', { headers: { 'Authorization': `Bearer ${process.env.HOODY_TOKEN}` } }).then(r => r.json());
for (const alias of projectAliases.data.aliases) { await fetch(`https://api.hoody.com/api/v1/proxy/aliases/${alias.id}`, { method: 'PATCH', headers: { 'Authorization': `Bearer ${process.env.HOODY_TOKEN}`, 'Content-Type': 'application/json' }, body: JSON.stringify({ target_path: '/v2' }) });}API, CLI and SDK calls
Section titled “API, CLI and SDK calls”| Task | HTTP | CLI | SDK |
|---|---|---|---|
| Create | POST /api/v1/proxy/aliases | hoody proxy aliases create | client.api.proxy.aliases.create |
List, filtered by project_id, computer_id, realm_id, enabled or expired | GET /api/v1/proxy/aliases | hoody proxy aliases list, with --project-id, --computer-id, --realm, --enabled or --expired true; --watch redraws it | list |
Details, with project, computer and server_name | GET /api/v1/proxy/aliases/{id} | hoody proxy aliases get | get |
| Change fields | PATCH /api/v1/proxy/aliases/{id} | hoody proxy aliases update | update |
| Enable or disable | PATCH /api/v1/proxy/aliases/{id}/state | hoody proxy aliases enable, disable | enable, disable |
| Delete | DELETE /api/v1/proxy/aliases/{id} | hoody proxy aliases delete (asks first; -y skips) | delete |
Related: proxy permissions control who can open an alias, and computer operations cover the computer lifecycle.