> ## Documentation Index
> Fetch the complete documentation index at: https://docs.orgo.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Ask support

> Ask Orgo’s support agent how to do something, and get an answer with full URLs and copyable commands.

The support agent in Orgo’s help panel, for programs. A coding agent setting Orgo up for someone can ask it what to do next instead of guessing.

```bash theme={null}
curl -X POST https://www.orgo.ai/api/v1/support/ask \
  -H "Authorization: Bearer $ORGO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "question": "How do I resize my computer?" }'
```

The answer is markdown in `answer`. Its links are full URLs, also listed in `links`, and its code is in fenced blocks with their language.

## Follow up

Nothing is stored. To go on, send back the `messages` from the answer with your next `question`:

```json theme={null}
{
  "messages": [
    { "role": "user", "content": "How do I resize my computer?" },
    { "role": "assistant", "content": "…" }
  ],
  "question": "It says RAM_IN_USE. What now?"
}
```

## With a key, and without

| | With an account-wide API key | With a workspace key | Without a key |
| - | - | - | - |
| Answers from the docs and pricing | Yes | Yes | Yes |
| Reads the account’s plan, billing status and computers | Yes | Only that workspace’s computers, never the plan or billing | No |
| Hands the conversation to Orgo’s team | Yes, they reply to the account’s email | No | No, it points to [contact@orgo.ai](mailto:contact@orgo.ai) |

It never reads API keys, secrets, files or what is on a screen, and it changes nothing. When it hands a conversation to the team, `handoff` is `{ "status": "sent", "email": "…" }`.

## Who pays

Without a key, Orgo pays. With a key, each day starts with free support tokens. Once they are used, answers come out of the account’s credits. The answer carries `allowance`:

```json theme={null}
{
  "free_daily": 150000,
  "free_left": 0,
  "paying": true,
  "blocked": false,
  "resets_at": "2026-10-23T00:00:00.000Z"
}
```

`paying` is `true` once today’s free tokens are used, and `blocked` once the credits can’t take another question. The free tokens come back at `resets_at`, the next midnight UTC. Without a key, `allowance` is `null`.

## Errors

Every error body is `{ "error": "…", "code": "…" }`.

| Status | `code` | When |
| - | - | - |
| `400` | `invalid_request` | The body is not a JSON object, or it holds no `question` and no `messages`. |
| `400` | `message_required` | The last message of the conversation is not the user’s, or every message is blank. |
| `401` | `unauthorized` | A key was sent and is not valid. A key past its expiry gets `key_expired`. |
| `402` | `INSUFFICIENT_CREDITS` | Today’s free tokens are used and the account’s credits are too low. The body adds `allowance`. Add credits at [orgo.ai/settings/billing](https://www.orgo.ai/settings/billing#credits). |
| `402` | `ACCOUNT_AI_LIMIT` | The account has reached its monthly AI limit. The body adds `allowance`. |
| `403` | `key_permission` | A restricted key without AI write. |
| `413` | `request_too_large` | The body is larger than about 24 MB: `This question is larger than 24.0 MB.` |
| `429` | `rate_limited` | Too many questions: 30 an hour per account. Without a key, 15 an hour and 40 a day per address, with daily caps per network and for everyone. The body adds `retry_after`, also sent as `Retry-After`. |
| `429` | `one_at_a_time` | The account already has questions being answered. Wait for an answer, then ask again. |
| `502` | `agent_failed` | The agent didn’t answer. Try again, or email [contact@orgo.ai](mailto:contact@orgo.ai). |
| `503` | `unavailable` | The agent is unavailable right now, or its limits or the account’s allowance can’t be read. Try again shortly. |
| `503` | `unauthorized` | Orgo could not check the key because of a fault on its side. The answer carries `Retry-After: 5`. Try again; the key itself is fine. |


## OpenAPI

````yaml POST /v1/support/ask
openapi: 3.1.0
info:
  title: Orgo API
  description: >-
    Launch cloud computers that AI agents can control and interact with. Create
    workspaces, provision computers, and control them programmatically.
  version: 2.0.0
  contact:
    name: Orgo Support
    email: contact@orgo.ai
    url: https://orgo.ai
servers:
  - url: https://www.orgo.ai/api
    description: Production
security:
  - bearerAuth: []
tags:
  - name: Support
    description: >-
      Orgo’s support agent, for programs: ask how to do something in Orgo and
      get an answer with full URLs and copyable commands.
  - name: Account
    description: >-
      Account capacity: how many computers an account may run, and adding or
      giving back more. Residential data: what the account has left for
      residential IPs, and buying more from credits.
  - name: Agent accounts
    description: >-
      Accounts an AI agent makes for itself, and the claim link a person uses to
      take one over.
  - name: Clients
    description: >-
      Run Orgo for your clients from your own app: a workspace and scoped key
      each, billed to you or to them.
  - name: Workspaces
    description: Organize computers into named workspaces
  - name: Computers
    description: Provision and manage virtual computers
  - name: Public URLs
    description: Share an app running on a computer at an https address on orgo.dev.
  - name: Computer Lifecycle
    description: Start, stop, and restart computers
  - name: Computer Actions
    description: Control mouse, keyboard, and execute commands
  - name: Screens
    description: >-
      More than one desktop on a single computer. Each screen is its own X
      server with its own cursor and window manager, so an agent working on one
      cannot disturb another.
  - name: Files
    description: Upload and download files
  - name: Templates
    description: Author, build, and launch reproducible computers from templates
  - name: Chat
    description: Run an agent on a computer through OpenAI-compatible chat completions.
  - name: Workflows
    description: >-
      Routines that run the same way every time: a start, then steps. Make them
      from plain words or lines, check them, run them and follow their runs (in
      preview).
paths:
  /v1/support/ask:
    post:
      tags:
        - Support
      summary: Ask Orgo’s support agent
      description: >-
        Ask Orgo’s support agent a question about using Orgo. It answers from
        Orgo’s docs, pricing and public pages, and the docs of Hermes Agent,
        OpenClaw, Claude Code and Codex, as markdown with full URLs and copyable
        commands. Send `question`, or a conversation as `messages`. To follow
        up, send back the answer’s `messages` with your next `question`. Nothing
        is stored.


        With an account-wide API key it also reads that account’s plan, billing
        status and computers (never keys, secrets, files or screens), and can
        hand the conversation to Orgo’s team, who reply to the account’s email
        (`handoff`). A key for one workspace reads only that workspace’s
        computers, never the plan or billing, and never hands off. Without a key
        it answers from the docs. It changes nothing. With a key, each day
        starts with free support tokens, then answers come out of the account’s
        credits (`allowance`). Limits: 30 questions an hour per account, and 15
        an hour and 40 a day per address without a key.
      operationId: askSupport
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              properties:
                question:
                  type: string
                  maxLength: 4000
                  description: The question. Added after `messages` when both are sent.
                messages:
                  type: array
                  description: >-
                    The conversation so far, oldest first. The last 12 turns are
                    read.
                  items:
                    type: object
                    required:
                      - role
                      - content
                    properties:
                      role:
                        type: string
                        enum:
                          - user
                          - assistant
                      content:
                        type: string
            example:
              question: How do I resize my computer?
      responses:
        '200':
          description: The answer.
          content:
            application/json:
              schema:
                type: object
                required:
                  - answer
                  - links
                  - handoff
                  - messages
                properties:
                  answer:
                    type: string
                    description: >-
                      Markdown. Links are full URLs; code is in fenced blocks
                      with its language.
                  links:
                    type: array
                    description: The pages the answer points to, in order.
                    items:
                      type: object
                      properties:
                        title:
                          type: string
                        url:
                          type: string
                  handoff:
                    type:
                      - object
                      - 'null'
                    description: >-
                      Set when the agent handed the conversation to Orgo’s team,
                      who reply to `email`.
                    properties:
                      status:
                        type: string
                        enum:
                          - sent
                      email:
                        type: string
                  allowance:
                    type:
                      - object
                      - 'null'
                    description: >-
                      Today’s free support tokens, with a key. `null` without
                      one.
                    properties:
                      free_daily:
                        type: integer
                        description: Free tokens a day.
                      free_left:
                        type: integer
                        description: Free tokens left today.
                      paying:
                        type: boolean
                        description: >-
                          Today’s free tokens are used: answers come out of the
                          account’s credits.
                      blocked:
                        type: boolean
                        description: Paying, and the credits can’t take another question.
                      resets_at:
                        type: string
                        description: 'When the free tokens come back: the next midnight UTC.'
                  messages:
                    type: array
                    description: >-
                      The conversation including this answer. Send it back with
                      the next `question`.
                    items:
                      type: object
                      properties:
                        role:
                          type: string
                        content:
                          type: string
              example:
                answer: >-
                  Make a key at [API
                  keys](https://www.orgo.ai/settings/developers), then create a
                  computer:


                  ```bash

                  curl -X POST https://www.orgo.ai/api/computers \
                    -H "Authorization: Bearer $ORGO_API_KEY" \
                    -H "Content-Type: application/json" \
                    -d '{"workspace_id": "YOUR_WORKSPACE_ID"}'
                  ```
                links:
                  - title: API keys
                    url: https://www.orgo.ai/settings/developers
                handoff: null
                messages:
                  - role: user
                    content: How do I create a computer with the API?
                  - role: assistant
                    content: Make a key at …
        '400':
          description: >-
            No question: `invalid_request` (the body is not a JSON object, or
            holds no `question` and no `messages`), or `message_required` (the
            last message is not the user’s, or every message is blank).
        '401':
          description: >-
            A key was sent and is not valid (`unauthorized`), or it expired
            (`key_expired`).
        '402':
          description: >-
            Today’s free support tokens are used and the account’s credits are
            too low (`INSUFFICIENT_CREDITS`), or the account reached its monthly
            AI limit (`ACCOUNT_AI_LIMIT`). The body adds `allowance`.
        '403':
          description: A restricted key without AI write (`key_permission`).
        '413':
          description: The body is larger than about 24 MB (`request_too_large`).
        '429':
          description: >-
            Too many questions (`rate_limited`, with `Retry-After`), or the
            account already has questions being answered (`one_at_a_time`).
        '502':
          description: >-
            The agent didn’t answer (`agent_failed`). Try again, or email
            contact@orgo.ai.
        '503':
          description: >-
            The agent is unavailable, or its limits or the account’s allowance
            can’t be read (`unavailable`). A fault on Orgo’s side while checking
            the key also answers `503`, with `code: "unauthorized"` and
            `Retry-After: 5`. Try again; the key itself is fine.
      security:
        - bearerAuth: []
        - {}
components:
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      description: API key authentication. Get your key at orgo.ai/workspaces

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.