> ## 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.

# Quickstart

> Launch a computer and control it over HTTP in under 5 minutes

This guide uses the **raw HTTP API**, the same surface the [CLI](/guides/cli) wraps. Point `curl`, `requests`, or `fetch` at `https://www.orgo.ai/api` and you're done.

<Info>
  Prefer the terminal? The [Orgo CLI](/guides/cli) wraps this same API with
  `orgo` commands and a live `orgo ssh` shell.
</Info>

## Watch the getting started tutorial

Watch the walkthrough to create your account and launch your first computer.

<iframe src="https://www.youtube.com/embed/CMn502tB8rI" title="Getting Started with Orgo - Cloud Computers for AI Agents" style={{ width: '100%', aspectRatio: '16 / 9', border: 0, borderRadius: '12px' }} allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerPolicy="strict-origin-when-cross-origin" loading="lazy" allowFullScreen />

[Watch Getting started with Orgo on YouTube](https://www.youtube.com/watch?v=CMn502tB8rI).

<Accordion title="Video transcript">
  Hi, I'm Spencer, and this video is a quick introduction to getting set up with
  Orgo from the web dashboard.

  If you go to orgo.ai, you can explore the website and learn more. What I'm going
  to do is click the Start building button, which brings us to the dashboard.

  I logged in ahead of time, so I'm brought to a screen like this. To orient
  ourselves: on the top right there's a search bar, which lets you search your
  account resources and run quick actions in the app. There's also a profile
  dropdown, which gives you billing and account settings, and lets you sign out or
  switch accounts.

  On the top left there's a workspace selector. It lets you group and organize
  your computers and isolate access. There are also tabs for Home and Templates,
  and at the bottom left there's a New computer button and a link to the developer
  documentation.

  To get started, I'm going to click the Launch computer button to see what a
  computer looks like and some of the things you can do. As soon as I click it, our
  new remote virtual computer on Orgo pops up. If you click the three dots, there
  are a few common actions: settings, restart, duplicate, stop, and delete.

  If I click into the computer, you get a more complete view of it. There's Files,
  and you can click over to Terminal to run any terminal commands. By default,
  Orgo launches a Linux Ubuntu computer, but we also have other operating systems.
  You can launch Linux, Mac, or Windows computers on Orgo.

  Then there's the computer itself. One of the primary things you can do from the
  website is fully use and interact with this computer from the browser. If you
  click Open in new tab, the arrow at the top right, you can use the computer in
  full screen. Same with the terminal. For example, if you're setting up Hermes
  Agent, you can do it from a full screen terminal view, which makes it a lot
  easier.

  At the top right there's also the invite area. You can send a link to get
  someone into your workspace to use this computer. They need an Orgo account, but
  they don't need a paid subscription. If you pay for the computer, they only need
  a free account to access it. There's also some context, MCP, and CLI information
  here, as well as a mode to toggle the screen view.

  I'll show you a few more things before we wrap up. Click Home to go back to the
  view of your whole workspace. If I click Search, it shows you things you can do,
  and you can click New computer as a quick action to create more computers.

  You can also create a workspace. I'll call this one my new workspace. Workspaces
  separate out your computers. You can swap back and forth between them, and when
  you create a workspace, you can invite people and give them access to everything
  within it. You might do this if you're working on multiple coding projects, or
  you have multiple clients and want to separate access. One customer per
  workspace is a common way to set this up.

  There's also a Templates menu. You can build your own templates for these
  computers, or use a few that we provide out of the box. For example, this Hermes
  Agent template is a computer that comes bundled with all the software packages
  and the Hermes Agent installation. You get a full computer that boots in a few
  seconds with Hermes Agent and everything you need to run it already installed.
  All you do past that point is connect your API keys for the AI models inside the
  computer.

  Before we conclude: if you click the three dots on a computer, you get a lot
  more settings. You can show the latency to see your real-time connection, get
  audio, change the resolution, see which operating system you're running, get a
  full set of system metrics, change the hardware, view backups, and get SSH
  access.

  Hardware is something that makes Orgo really nice. You can live change the CPU,
  memory, storage, bandwidth, or other settings on the computer. For example, you
  might start a computer, get set up, and later decide you need more resources.
  You can scale up the hardware later on.

  That's a quick overview of the dashboard, and I hope it helps you get started.
  We'll create more videos that go through different parts of the platform.

  One other thing I forgot: we also have developer documentation. Everything you
  do from the dashboard, such as creating and managing computers, you can also do
  through the API. If you're building Orgo into your applications and want the
  full API to manage the lifecycle of these computers, you can do all of it
  through code instead of a user interface. That's all listed out in the docs.
  We'll create more videos covering the developer setup and the CLI.

  This was a quick video introducing you to the Orgo web dashboard.
</Accordion>

## 1. Get your API key

Create an account at [orgo.ai/start](https://www.orgo.ai/start), then create
a key in [Settings → Credentials](https://www.orgo.ai/settings/credentials).

<Note>
  Signing up, creating workspaces, and creating API keys are free. Creating a
  computer in your own workspace requires a paid plan. See
  [pricing](https://www.orgo.ai/pricing).
</Note>

```bash theme={null}
export ORGO_API_KEY=sk_live_...
```

Every request takes this as a bearer token:

```http theme={null}
Authorization: Bearer $ORGO_API_KEY
```

## 2. Create a workspace

Workspaces group related computers.

<CodeGroup>
  ```bash cURL theme={null}
  curl -X POST https://www.orgo.ai/api/workspaces \
    -H "Authorization: Bearer $ORGO_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{"name": "quickstart"}'
  ```

  ```python Python theme={null}
  import os, requests

  r = requests.post(
      "https://www.orgo.ai/api/workspaces",
      headers={"Authorization": f"Bearer {os.environ['ORGO_API_KEY']}"},
      json={"name": "quickstart"},
  )
  workspace = r.json()
  print(workspace["id"])
  ```

  ```typescript TypeScript theme={null}
  const r = await fetch("https://www.orgo.ai/api/workspaces", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.ORGO_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ name: "quickstart" }),
  });
  const workspace = await r.json();
  console.log(workspace.id);
  ```
</CodeGroup>

Response (abridged):

```json theme={null}
{
  "id": "550e8400-e29b-41d4-a716-446655440000",
  "name": "quickstart",
  "status": "active",
  "created_at": "2026-04-22T10:00:00Z"
}
```

Save the `id`. You'll pass it as `workspace_id` when creating a computer.

## 3. Create a computer

<CodeGroup>
  ```bash cURL theme={null}
  curl -X POST https://www.orgo.ai/api/computers \
    -H "Authorization: Bearer $ORGO_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "workspace_id": "'"$WORKSPACE_ID"'",
      "name": "agent-1",
      "ram": 4,
      "cpu": 1
    }'
  ```

  ```python Python theme={null}
  r = requests.post(
      "https://www.orgo.ai/api/computers",
      headers={"Authorization": f"Bearer {os.environ['ORGO_API_KEY']}"},
      json={
          "workspace_id": workspace["id"],
          "name": "agent-1",
          "ram": 4,
          "cpu": 1,
      },
  )
  computer = r.json()
  print(computer["id"], computer["status"])
  ```

  ```typescript TypeScript theme={null}
  const r = await fetch("https://www.orgo.ai/api/computers", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.ORGO_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      workspace_id: workspace.id,
      name: "agent-1",
      ram: 4,
      cpu: 1,
    }),
  });
  const computer = await r.json();
  console.log(computer.id, computer.status);
  ```
</CodeGroup>

Set `$WORKSPACE_ID` to the `id` from step 2.

Response (abridged):

```json theme={null}
{
  "id": "a3bb189e-8bf9-3888-9912-ace4e6543002",
  "name": "agent-1",
  "workspace_id": "550e8400-e29b-41d4-a716-446655440000",
  "os": "linux",
  "cpu": 1,
  "ram": 4,
  "resolution": "1280x720x24",
  "status": "running",
  "instance_id": "a3881618"
}
```

The request returns once the computer is running, so it accepts commands right away. Save the `id` as `$COMPUTER_ID` for the cURL examples below.

## 4. Take a screenshot

<CodeGroup>
  ```bash cURL theme={null}
  curl "https://www.orgo.ai/api/computers/$COMPUTER_ID/screenshot?response_format=binary&format=png" \
    -H "Authorization: Bearer $ORGO_API_KEY" \
    -o screenshot.png
  ```

  ```python Python theme={null}
  # response_format=binary returns the image bytes directly.
  r = requests.get(
      f"https://www.orgo.ai/api/computers/{computer['id']}/screenshot",
      headers={"Authorization": f"Bearer {os.environ['ORGO_API_KEY']}"},
      params={"response_format": "binary", "format": "png"},
  )
  with open("screenshot.png", "wb") as f:
      f.write(r.content)
  ```

  ```typescript TypeScript theme={null}
  // response_format=binary returns the image bytes directly.
  const r = await fetch(
    `https://www.orgo.ai/api/computers/${computer.id}/screenshot?response_format=binary&format=png`,
    { headers: { Authorization: `Bearer ${process.env.ORGO_API_KEY}` } },
  );
  const png = Buffer.from(await r.arrayBuffer());
  ```
</CodeGroup>

Without `response_format`, the response is JSON whose `image` is a stored path that needs the same bearer token to download. See [Screenshot](/api-reference/computers/screenshot).

## 5. Click, type, and run shell commands

<CodeGroup>
  ```bash cURL theme={null}
  # Click at (100, 200)
  curl -X POST https://www.orgo.ai/api/computers/$COMPUTER_ID/click \
    -H "Authorization: Bearer $ORGO_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{"x": 100, "y": 200}'

  # Type text
  curl -X POST https://www.orgo.ai/api/computers/$COMPUTER_ID/type \
    -H "Authorization: Bearer $ORGO_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{"text": "Hello, world!"}'

  # Press Return (keys use X keysym names)
  curl -X POST https://www.orgo.ai/api/computers/$COMPUTER_ID/key \
    -H "Authorization: Bearer $ORGO_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{"key": "Return"}'

  # Run a shell command
  curl -X POST https://www.orgo.ai/api/computers/$COMPUTER_ID/bash \
    -H "Authorization: Bearer $ORGO_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{"command": "ls -la"}'
  ```

  ```python Python theme={null}
  cid = computer["id"]
  base = f"https://www.orgo.ai/api/computers/{cid}"
  hdr = {"Authorization": f"Bearer {os.environ['ORGO_API_KEY']}"}

  requests.post(f"{base}/click", headers=hdr, json={"x": 100, "y": 200})
  requests.post(f"{base}/type",  headers=hdr, json={"text": "Hello, world!"})
  requests.post(f"{base}/key",   headers=hdr, json={"key": "Return"})

  r = requests.post(f"{base}/bash", headers=hdr, json={"command": "ls -la"})
  print(r.json()["output"])
  ```

  ```typescript TypeScript theme={null}
  const cid = computer.id;
  const base = `https://www.orgo.ai/api/computers/${cid}`;
  const hdr = {
    Authorization: `Bearer ${process.env.ORGO_API_KEY}`,
    "Content-Type": "application/json",
  };

  await fetch(`${base}/click`, { method: "POST", headers: hdr, body: JSON.stringify({ x: 100, y: 200 }) });
  await fetch(`${base}/type`,  { method: "POST", headers: hdr, body: JSON.stringify({ text: "Hello, world!" }) });
  await fetch(`${base}/key`,   { method: "POST", headers: hdr, body: JSON.stringify({ key: "Return" }) });

  const bash = await fetch(`${base}/bash`, {
    method: "POST",
    headers: hdr,
    body: JSON.stringify({ command: "ls -la" }),
  }).then((x) => x.json());
  console.log(bash.output);
  ```
</CodeGroup>

Full list of actions: [Mouse](/api-reference/computers/click) · [Keyboard](/api-reference/computers/type) · [Scroll](/api-reference/computers/scroll) · [Bash](/api-reference/computers/bash) · [Python exec](/api-reference/computers/exec) · [Wait](/api-reference/computers/wait) · [Drag](/api-reference/computers/drag).

## 6. Let an AI drive it

Orgo exposes an OpenAI-compatible endpoint at `/api/v1/chat/completions`.
Point any OpenAI SDK at `https://www.orgo.ai/api/v1`, pass
`computer_id`, and the model will screenshot, click, and type on its own
until your instruction is done.

<CodeGroup>
  ```bash cURL theme={null}
  curl https://www.orgo.ai/api/v1/chat/completions \
    -H "Authorization: Bearer $ORGO_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "model": "claude-sonnet-5",
      "computer_id": "'"$COMPUTER_ID"'",
      "messages": [
        {"role": "user", "content": "Open Chrome and search for AI news"}
      ]
    }'
  ```

  ```python Python theme={null}
  from openai import OpenAI

  client = OpenAI(
      base_url="https://www.orgo.ai/api/v1",
      api_key=os.environ["ORGO_API_KEY"],
  )

  response = client.chat.completions.create(
      model="claude-sonnet-5",
      messages=[{"role": "user", "content": "Open Chrome and search for AI news"}],
      extra_body={"computer_id": computer["id"]},
  )
  print(response.choices[0].message.content)
  ```

  ```typescript TypeScript theme={null}
  import OpenAI from "openai";

  const client = new OpenAI({
    baseURL: "https://www.orgo.ai/api/v1",
    apiKey: process.env.ORGO_API_KEY,
  });

  const response = await client.chat.completions.create({
    model: "claude-sonnet-5",
    messages: [{ role: "user", content: "Open Chrome and search for AI news" }],
    computer_id: computer.id,
  } as any);

  console.log(response.choices[0].message.content);
  ```
</CodeGroup>

Stream the agent's progress token-by-token with `"stream": true`. See [Create chat completion](/api-reference/chat/completions) for the full spec, including thread continuation, custom Anthropic key, and error handling.

## 7. Lifecycle

```bash theme={null}
# Stop
curl -X POST https://www.orgo.ai/api/computers/$COMPUTER_ID/stop \
  -H "Authorization: Bearer $ORGO_API_KEY"

# Start a stopped computer
curl -X POST https://www.orgo.ai/api/computers/$COMPUTER_ID/start \
  -H "Authorization: Bearer $ORGO_API_KEY"

# Restart (reboot)
curl -X POST https://www.orgo.ai/api/computers/$COMPUTER_ID/restart \
  -H "Authorization: Bearer $ORGO_API_KEY"

# Delete permanently
curl -X DELETE https://www.orgo.ai/api/computers/$COMPUTER_ID \
  -H "Authorization: Bearer $ORGO_API_KEY"
```

Stopped computers cold-boot from their saved disk on the next `start`.

<Warning>
  In-memory state is not preserved across a stop. A computer that is stopped and
  started again can land on a different host with a new address and ports.
</Warning>

***

## Use the CLI

Prefer a terminal workflow? The [Orgo CLI](/guides/cli) wraps this same API. From your shell you can create and manage computers, run `bash` and `exec`, open a live shell with `orgo ssh`, and drive agent runs.

```bash theme={null}
npm install -g orgo
```

See the [CLI guide](/guides/cli) for the full command set.

***

## Next steps

<CardGroup cols={2}>
  <Card title="API Reference" icon="code" href="/api-reference/introduction">
    Every endpoint, every field.
  </Card>

  <Card title="Use any model" icon="robot" href="/guides/models">
    Claude, GPT, Gemini, Hermes. Any OpenAI-compatible model.
  </Card>

  <Card title="Embed computers" icon="browser" href="/guides/embed-vms">
    Drop a live computer into your own app via VNC.
  </Card>
</CardGroup>


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