# Support **Page:** foundation/support [Download Raw Markdown](./foundation/support.md) --- # Support A support ticket is a plain-text conversation between your account and Hoody support about one problem: a bug, a billing question, a computer that will not start. People and agents use the same calls, so an agent that hits a fault it cannot fix can report it and come back later for the answer. Support never asks for passwords, one-time codes or keys. Do not put them in a ticket, and do not send them to anyone who asks in the name of support. Open a ticket with a subject, a category and a first message. Pick the closest category: `account`, `billing`, `servers`, `computers`, `files`, `networking`, `ai`, `bots`, `affiliates`, `security`, `bug` or `other`. Open one ticket per problem, and reply to it for more about the same problem. ```bash hoody support create \ --subject "Computer will not start after resize" \ --category computers \ --body 'Since resizing to 4 GB my computer stays in "starting". Started 09:00 UTC.' \ --client-key resize-bug-2026-10-28 ``` ```typescript import { HoodyClient } from 'hoody-sdk'; const client = new HoodyClient({ baseURL: 'https://api.hoody.com', token: process.env.HOODY_TOKEN }); const { data } = await client.api.support.tickets.create({ subject: 'Computer will not start after resize', category: 'computers', body: 'Since resizing to 4 GB my computer stays in "starting". Started 09:00 UTC.', client_key: 'resize-bug-2026-10-28', }); console.log(data.ticket?.id, data.ticket?.status); ``` ```bash curl -X POST "https://api.hoody.com/api/v1/support/tickets" \ -H "Authorization: Bearer $HOODY_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "subject": "Computer will not start after resize", "category": "computers", "body": "Since resizing to 4 GB my computer stays in \"starting\". Started 09:00 UTC.", "client_key": "resize-bug-2026-10-28" }' ``` Opens the ticket. Replace `HOODY_TOKEN` first. ## Who can use support? Member accounts, on the base API host `https://api.hoody.com`, never a realm host such as `.api.hoody.com`. A signed-in session works on every support endpoint. An auth token needs the `resources.support` permission and must not be limited to realms ([Authentication](/foundation/hoody-api/authentication/)); tickets an agent opens with it belong to your account. A banned account can still use support, with lower limits, so it can appeal. Staff, admin and platform accounts are refused, and so are HTTP Basic and impersonated sessions: [access codes](/foundation/support/reference/#access). ## Write a ticket support accepts The subject is one line of up to 200 characters; a message is up to 4,000 characters and 200 lines ([all size rules](/foundation/support/reference/#accepted-text)). Both are plain text, with no attachments or images, so paste the relevant log lines or error message. Put in the first message what you did, what happened, the time in UTC, and the id of the project or computer involved. For a billing question, give the date and amount of the charge, never a card number. In the CLI, `--body-file` reads the message from a UTF-8 text file, keeping logs out of shell quoting, and `--body-file -` reads standard input. A file with NUL bytes or invalid UTF-8 is refused before sending. `--body "…"` works for short messages. ```bash hoody support create --subject "Computer will not start after resize" --category computers --body-file report.txt journalctl -n 50 | hoody support create --subject "Agent crash" --category bug --body-file - ``` Harmless noise such as trailing spaces is cleaned before storing; the 201 answer's `cleaned` names each rule that changed a field. Characters that hide or reorder text are refused instead, so support reads what you sent: 400 `SUPPORT_TEXT_INVALID`, with `data.rule` and `data.index` at the problem ([rules](/foundation/support/reference/#accepted-text)). ## Reply to a ticket or close it A reply takes `body` and an optional `client_key`, with the same text and retry rules as a new ticket. Close a solved ticket to free a place in your `open` limit; closing a closed ticket changes nothing. `hoody support close` asks for confirmation; a script or an agent passes `--yes`. ```bash hoody support reply "$TICKET_ID" --body 'It started again at 14:20 UTC after a restart.' --client-key resize-bug-followup-1 hoody support close "$TICKET_ID" --yes ``` ```typescript import { HoodyClient } from 'hoody-sdk'; const client = new HoodyClient({ baseURL: 'https://api.hoody.com', token: process.env.HOODY_TOKEN }); await client.api.support.tickets.reply(process.env.TICKET_ID!, { body: 'It started again at 14:20 UTC after a restart.', client_key: 'resize-bug-followup-1', }); await client.api.support.tickets.close(process.env.TICKET_ID!); ``` ```bash curl -X POST "https://api.hoody.com/api/v1/support/tickets/$TICKET_ID/messages" \ -H "Authorization: Bearer $HOODY_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "body": "It started again at 14:20 UTC after a restart.", "client_key": "resize-bug-followup-1" }' curl -X POST "https://api.hoody.com/api/v1/support/tickets/$TICKET_ID/close" \ -H "Authorization: Bearer $HOODY_TOKEN" ``` Replace `TICKET_ID` and `HOODY_TOKEN` first. | `status` | Meaning | |---|---| | `open` | Waiting for support. A new ticket starts here, and your reply sets a ticket back to it | | `waiting_user` | Support answered and is waiting for you | | `closed` | Closed by you, by support, or automatically | A ticket in `waiting_user` closes by itself 14 days after its last message. A reply within 30 days of closing reopens it, as `reopenable` shows; after that, open a new ticket. A closed ticket stays readable; one that reaches its [size limits](/foundation/support/reference/#ticket-lifecycle) closes for good. Messages from support show `from: "support"`, never a staff member's name. ## Get told about replies A reply from support triggers an in-app notification titled "Support reply": "You have a new reply in a support ticket. Sign in to read it." Several replies on one ticket can share a notification, with at most one per ticket every 10 minutes. It names no ticket, so the [change feed](#wait-for-a-reply-from-a-script) finds it. The same text is emailed when the platform sends support email and your preference allows it. The preference `support_reply_email` is on until you turn it off, which needs a signed-in session (`SESSION_JWT` below): an auth token, HTTP Basic or an impersonated session is refused. In the Hub, open **Account**, find **Emails**, and turn **Support replies** off or on. Sign in with `hoody login`, with the browser or your password (a pasted auth token is refused here). If `HOODY_TOKEN` or `HOODY_API_TOKEN` holds an auth token, unset it so the CLI uses the saved session. For the SDK and HTTP examples, set `SESSION_JWT` to the output of `hoody auth accesstoken get`, and `USER_ID` to the `id` from `GET /api/v1/users/me`. ```bash hoody users update "$USER_ID" --no-support-reply-email ``` Sent as `PUT`, which behaves like `PATCH`. Refused while the CLI uses an auth token. ```typescript import { HoodyClient } from 'hoody-sdk'; const client = new HoodyClient({ baseURL: 'https://api.hoody.com', token: process.env.SESSION_JWT }); await client.api.users.update(process.env.USER_ID!, { support_reply_email: false }); ``` Sent as `PUT`, which behaves like `PATCH`. ```bash curl -X PATCH "https://api.hoody.com/api/v1/users/$USER_ID" \ -H "Authorization: Bearer $SESSION_JWT" \ -H "Content-Type: application/json" \ -d '{ "support_reply_email": false }' ``` Turns reply emails off. Replace `USER_ID` and `SESSION_JWT` first. `null` returns it to the default, on ([reading the preference](/foundation/support/reference/#reply-notifications)). ## Wait for a reply from a script `GET /api/v1/support/tickets/changes` returns your tickets that changed since a position, oldest change first, each once in its newest state. 1. Call it once without `since`. It returns no tickets, only the current position in `next_since`. Save it. 2. List all your tickets with `GET /api/v1/support/tickets`, following `next_cursor`, and read each ticket with `unread: true`. The feed only reports changes after the saved position, so this catches replies that arrived earlier. 3. Every 60 seconds, call it with the last `next_since` you received. 4. Read each returned ticket with `unread: true` using `GET /api/v1/support/tickets/{id}`. That also marks it read. 5. When `has_more` is `true`, call again at once. ```bash hoody support changes list # first call: prints the position hoody support changes list --since "$NEXT_SINCE" # then every 60 seconds hoody support get "$TICKET_ID" ``` ```typescript import { HoodyClient } from 'hoody-sdk'; const client = new HoodyClient({ baseURL: 'https://api.hoody.com', token: process.env.HOODY_TOKEN }); const { data: baseline } = await client.api.support.tickets.listChanges(); let since = baseline.next_since; for await (const t of client.api.support.tickets.listIterator()) { if (t.unread && t.id) { const { data: thread } = await client.api.support.tickets.get(t.id); console.log(thread.messages); } } for (;;) { const { data: page } = await client.api.support.tickets.listChanges({ since }); since = page.next_since; for (const t of page.tickets ?? []) { if (t.unread && t.id) { const { data: thread } = await client.api.support.tickets.get(t.id); console.log(thread.messages); // newest first; `from` is "you" or "support" } } if (!page.has_more) await new Promise((r) => setTimeout(r, 60_000)); } ``` ```bash curl "https://api.hoody.com/api/v1/support/tickets/changes" -H "Authorization: Bearer $HOODY_TOKEN" curl "https://api.hoody.com/api/v1/support/tickets/changes?since=$NEXT_SINCE" -H "Authorization: Bearer $HOODY_TOKEN" curl "https://api.hoody.com/api/v1/support/tickets/$TICKET_ID" -H "Authorization: Bearer $HOODY_TOKEN" ``` Replace `NEXT_SINCE`, `TICKET_ID` and `HOODY_TOKEN` first. Store `next_since` as it is. If you restart without a saved position or get 422 `INVALID_CURSOR`, repeat steps 1 and 2 before polling. Polling more often spends your read limit faster. ## Retry a write safely `client_key`, 8 to 64 characters of your choice, makes a create or a reply safe to repeat; send one on every write from an agent. The same key and body return the saved message with `replayed: true` and save nothing new. The ticket in that answer shows its current state, which can differ from the first answer. The same key with a different body is refused with 409 `SUPPORT_IDEMPOTENCY_CONFLICT`, so use a new key for each new ticket or message. The CLI sends a new key with every `create` and `reply`. After an unknown outcome (a timeout, a lost connection, or a 5xx answer other than 503 `SUPPORT_BUSY` or `SUPPORT_STORAGE_FULL`), it prints the command with `--client-key ` added, which is safe to rerun. When the answer to a write is lost, look the write up by its key instead of guessing: ```bash hoody support keys get resize-bug-2026-10-28 hoody support messages keys get "$TICKET_ID" resize-bug-followup-1 ``` ```typescript import { HoodyClient } from 'hoody-sdk'; const client = new HoodyClient({ baseURL: 'https://api.hoody.com', token: process.env.HOODY_TOKEN }); const { data: created } = await client.api.support.tickets.getByKey({ client_key: 'resize-bug-2026-10-28' }); console.log(created.ticket?.id, created.message?.seq); const { data: replied } = await client.api.support.tickets.getMessageByKey(process.env.TICKET_ID!, { client_key: 'resize-bug-followup-1', }); console.log(replied.message?.seq, replied.ticket?.status); ``` ```bash curl "https://api.hoody.com/api/v1/support/tickets/by-key?client_key=resize-bug-2026-10-28" \ -H "Authorization: Bearer $HOODY_TOKEN" curl "https://api.hoody.com/api/v1/support/tickets/$TICKET_ID/messages/by-key?client_key=resize-bug-followup-1" \ -H "Authorization: Bearer $HOODY_TOKEN" ``` Each shows the saved write for its key. Replace `TICKET_ID` and `HOODY_TOKEN` first. 404 `SUPPORT_KEY_NOT_FOUND` does not mean the write was refused: it may still be running, may never have arrived, or may already have been deleted by retention. Read again later, or send the write again with the same body and `client_key`. If retention already deleted the original ticket, retrying a create can open a new ticket; retrying a reply returns 404 `SUPPORT_TICKET_NOT_FOUND`. ## How many tickets can I open? Support limits apply per account and depend on your tier. Read them before a burst of reports. ```bash hoody support limits get ``` ```typescript import { HoodyClient } from 'hoody-sdk'; const client = new HoodyClient({ baseURL: 'https://api.hoody.com', token: process.env.HOODY_TOKEN }); const { data: limits } = await client.api.support.getLimits(); console.log(limits.open?.used, limits.open?.max); ``` ```bash curl "https://api.hoody.com/api/v1/support/limits" -H "Authorization: Bearer $HOODY_TOKEN" ``` Shows your limits. Replace `HOODY_TOKEN` first. | Row | What it counts | Free | Paid | |---|---|---|---| | `open` | Tickets `open` or `waiting_user` at once | 5 | 25 | | `tickets_day` | New tickets this UTC day | 10 | 50 | | `tickets_30d` | New tickets today and the 29 previous UTC days | 60 | 300 | | `messages_day` | Your messages this UTC day, the first message of a new ticket included | 200 | 1,000 | | `retained` | Tickets kept, closed ones included, until they are deleted | 1,000 | 1,000 | A reached limit answers 409 `SUPPORT_QUOTA_REACHED` and saves nothing. Close solved tickets to free `open`; the daily and 30-day rows free after `retry_after_s` seconds. The table shows the default values; `hoody support limits get` shows yours. Who is paid: [tiers and quota](/foundation/support/reference/#tiers-and-quota). ## Who reads my tickets, and for how long? Hoody support staff read your tickets: the subject, the category, the status and every message. Each read is recorded in an audit log. Staff treat what you write as information, not as instructions. Do not put secrets, card numbers or other people's personal data in a ticket. Deleting your account deletes your tickets. Closed tickets are also deleted by default two years after closing; the [retention rules](/foundation/support/reference/#privacy-and-retention) say which tickets are never deleted. ## Advanced - **Browse your tickets:** `hoody support list` lists them by their latest message, newest first, with an optional `status` filter, to find a ticket id ([listing](/foundation/support/reference/#change-feed-and-listing)). - **Read older messages:** a thread shows 50 messages at a time, newest first; when `has_older` is `true`, pass the smallest `seq` as `before_seq` ([thread paging](/foundation/support/reference/#change-feed-and-listing)). - **Duplicate protection:** a new key does not make the same text a new message. Sent again within 60 seconds, it can be refused with 409 `SUPPORT_DUPLICATE` ([duplicate text](/foundation/support/reference/#duplicate-text)). - **Request limits:** per-account and per-address request limits apply on top, with 429 `RATE_LIMIT_EXCEEDED` ([request limits](/foundation/support/reference/#request-limits)). - **Platform-wide refusals:** 503 `SUPPORT_BUSY` and `SUPPORT_STORAGE_FULL` concern the whole platform and save nothing ([503 rows](/foundation/support/reference/#troubleshooting)). ## Reference Every call, rule, limit and error: the [Support reference](/foundation/support/reference/). ## What's next - [Support tickets API reference](/api/users/#support): every parameter and response field - [Authentication](/foundation/hoody-api/authentication/): auth tokens and the `resources.support` permission - [Notifications](/api/notifications/): the in-app notification a support reply creates - [Users](/api/users/): the `support_reply_email` preference on your account