> ## 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**. It's the same surface every Orgo SDK wraps. Drop `curl`, `requests`, or `fetch` against `https://www.orgo.ai/api` and you're done. No SDK required.

<Info>
  Prefer a helper library? Skip to [Use the SDK](#use-the-sdk) after you've
  seen the raw calls. The SDK is a thin wrapper around the exact same
  endpoints.
</Info>

## 1. Get your API key

Create an account at [orgo.ai/start](https://www.orgo.ai/start), then copy
your key from [orgo.ai/workspaces](https://www.orgo.ai/workspaces).

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

Every request takes this as a bearer token:

```
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:

```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": "550e8400-e29b-41d4-a716-446655440000",
      "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>

Response (abridged):

```json theme={null}
{
  "id": "a3bb189e-8bf9-3888-9912-ace4e6543002",
  "name": "agent-1",
  "status": "running",
  "ram": 4,
  "cpu": 1,
  "resolution": "1280x720x24",
  "url": "https://orgo.ai/workspaces/550e8400-e29b-41d4-a716-446655440000/computers/a3bb189e-8bf9-3888-9912-ace4e6543002"
}
```

The computer boots in under 500ms and is ready to accept commands immediately.

## 4. Take a screenshot

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

  ```python Python theme={null}
  import base64
  r = requests.get(
      f"https://www.orgo.ai/api/computers/{computer['id']}/screenshot",
      headers={"Authorization": f"Bearer {os.environ['ORGO_API_KEY']}"},
  )
  data = r.json()
  with open("screenshot.png", "wb") as f:
      f.write(base64.b64decode(data["image"]))
  ```

  ```typescript TypeScript theme={null}
  const r = await fetch(
    `https://www.orgo.ai/api/computers/${computer.id}/screenshot`,
    { headers: { Authorization: `Bearer ${process.env.ORGO_API_KEY}` } },
  );
  const { image } = await r.json();
  // `image` is a base64 PNG
  ```
</CodeGroup>

## 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 Enter
  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": "Enter"}'

  # 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": "Enter"})

  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: "Enter" }) });

  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-4-6",
      "computer_id": "a3bb189e-8bf9-3888-9912-ace4e6543002",
      "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-4-6",
      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-4-6",
    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  (auto-stop also does this after idle timeout)
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"
```

Auto-stop is disabled by default. Configure it per-computer with `auto_stop_minutes`. See [Auto-stop](/guides/auto-stop).

***

## Use the SDK

If you'd rather not wire HTTP calls by hand, the official SDKs wrap this
exact surface. They give you typed helpers, connection pooling for VNC,
and one-line `computer.prompt("do X")` for the AI agent loop.

<CodeGroup>
  ```bash Python theme={null}
  pip install orgo
  ```

  ```bash TypeScript theme={null}
  npm install orgo
  ```
</CodeGroup>

<CodeGroup>
  ```python Python theme={null}
  from orgo import Computer

  computer = Computer(workspace="quickstart")

  # Each of these is a direct wrapper over a single HTTP call.
  computer.left_click(100, 200)
  computer.type("Hello, world!")
  computer.key("Enter")
  output = computer.bash("ls -la")

  # One-liner for the AI agent loop
  computer.prompt("Open Chrome and search for AI news")

  computer.destroy()
  ```

  ```typescript TypeScript theme={null}
  import { Computer } from "orgo";

  const computer = await Computer.create({ workspace: "quickstart" });

  await computer.leftClick(100, 200);
  await computer.type("Hello, world!");
  await computer.key("Enter");
  const output = await computer.bash("ls -la");

  await computer.prompt("Open Chrome and search for AI news");

  await computer.destroy();
  ```
</CodeGroup>

Both SDKs read `ORGO_API_KEY` from the environment and default to the
same base URL you'd call directly.

***

## 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 VM into your own app via VNC.
  </Card>
</CardGroup>