Skip to main content
Looking for the raw HTTP API? Check out the API Reference for direct REST endpoints.

​
Installation

1

Install the SDK

pip install orgo openai python-dotenv
2

Get your API key

  1. Create an account at orgo.ai
  2. Get your API key from orgo.ai/workspaces
  3. Create a .env file in your project:
.env
ORGO_API_KEY=sk_live_...
3

Control a computer with AI

from openai import OpenAI
from orgo import Computer

computer = Computer()

client = OpenAI(
    base_url="https://api.orgo.ai/api/v1",
    api_key="sk_live_..."  # Your 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.computer_id},
)

print(response.choices[0].message.content)

​
Organize with Workspaces

from orgo import Computer

# Create computer in a specific workspace
computer = Computer(workspace="production")

# Create multiple computers in the same workspace
agents = []
for i in range(3):
    agent = Computer(workspace="agents")
    agents.append(agent)

​
Manual Control

​
Mouse & Keyboard

# Mouse actions
computer.left_click(100, 200)
computer.right_click(300, 400)
computer.double_click(500, 300)
computer.scroll(direction="down", amount=3)

# Keyboard input
computer.type("Hello world")
computer.key("Enter")
computer.key("ctrl+c")

# Take screenshot
screenshot = computer.screenshot()  # Returns PIL Image
screenshot.save("screenshot.png")

# Or get base64
base64_image = computer.screenshot_base64()

​
Execute Code

# Run bash commands
output = computer.bash("ls -la")
print(output)

# Execute Python code
result = computer.exec("print('Hello from Python')")
print(result)

# Wait between actions
computer.wait(2.0)  # Wait 2 seconds
These methods give you full control to implement your own custom computer-use agent. See the API reference for all available methods.

​
AI Control

Orgo uses the standard OpenAI chat/completions format. The AI agent handles screenshots, clicking, typing, and bash commands automatically.

​
Streaming

from openai import OpenAI
from orgo import Computer

computer = Computer()
client = OpenAI(base_url="https://api.orgo.ai/api/v1", api_key="sk_live_...")

stream = client.chat.completions.create(
    model="claude-sonnet-4.6",
    messages=[{"role": "user", "content": "Create a report on AI trends and save it as report.pdf"}],
    extra_body={"computer_id": computer.computer_id},
    stream=True,
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

​
Multi-turn

Pass thread_id to continue where the AI left off: 
response = client.chat.completions.create(
    model="claude-sonnet-4.6",
    messages=[{"role": "user", "content": "Create a report on AI trends"}],
    extra_body={"computer_id": computer.computer_id},
)
thread_id = response.orgo["thread_id"]

# Continue — AI remembers the report is already open
response2 = client.chat.completions.create(
    model="claude-sonnet-4.6",
    messages=[{"role": "user", "content": "Now add a chart to page 2"}],
    extra_body={"computer_id": computer.computer_id, "thread_id": thread_id},
)

​
Bring your own key

Use your own Anthropic API key — no Orgo credits consumed: 
client = OpenAI(
    base_url="https://api.orgo.ai/api/v1",
    api_key="sk_live_...",
    default_headers={"X-Anthropic-Key": "sk-ant-..."},
)

​
Use Claude Opus for complex tasks

response = client.chat.completions.create(
    model="claude-opus-4.6",  # Most capable model
    messages=[{"role": "user", "content": "Research AI developments and create a summary document"}],
    extra_body={"computer_id": computer.computer_id},
)

​
Complete Example

example.py
from openai import OpenAI
from orgo import Computer

# Create computer with custom specs
computer = Computer(workspace="research", ram=8, cpu=4)

client = OpenAI(
    base_url="https://api.orgo.ai/api/v1",
    api_key="sk_live_..."
)

try:
    # Stream the AI working on a complex task
    stream = client.chat.completions.create(
        model="claude-sonnet-4.6",
        messages=[{"role": "user", "content": "Search for recent AI papers, summarize the top 3, and create a document"}],
        extra_body={"computer_id": computer.computer_id},
        stream=True,
    )

    for chunk in stream:
        if chunk.choices[0].delta.content:
            print(chunk.choices[0].delta.content, end="", flush=True)

    # Take a screenshot of the result
    screenshot = computer.screenshot()
    screenshot.save("result.png")

finally:
    computer.destroy()

​
Templates

Pre-configure computers with installed software: 
from orgo import Template, Computer

# Create a template with pre-installed packages
template = Template("data-science")
template.run("pip install numpy pandas matplotlib jupyter")
template.build()

# Launch computers from the template
computer = Computer(template="data-science")
See the Templates guide for more details on creating and using templates.

​
Computer Specs

computer = Computer(
    workspace="ml-training",
    name="ml-trainer",
    ram=32,
    cpu=8,
    os="linux",
    gpu="a100-80gb"  # Coming soon
)
Defaults: linux, 4GB RAM, Standard CPU, no GPU Valid RAM/CPU pairs:
RAMCPUBest for
4GBStandardStandard workflows (default)
8GB2xHeavy automation
16GB4xDevelopment
32GB4xLarge-scale processing
64GB16xEnterprise workloads

​
Computer Lifecycle

# Check status
status = computer.status()
print(f"Status: {status['status']}")

# Restart computer
computer.restart()

# Connect to existing computer
existing = Computer(computer_id="comp_xyz789")

# Get computer URL
print(f"View at: {computer.url}")

# Delete when done
computer.destroy()
Free-tier computers auto-stop after 15 minutes of inactivity. Paid plans can configure auto-stop or disable it entirely.

​
Environment Variables

ORGO_API_KEY=sk_live_...

# Optional - for bring-your-own-key (X-Anthropic-Key header)
ANTHROPIC_API_KEY=sk-ant-...

​
Tips

dev = Computer(workspace="development")
test = Computer(workspace="testing")
prod = Computer(workspace="production")

try:
    response = client.chat.completions.create(
        model="claude-sonnet-4.6",
        messages=[{"role": "user", "content": "Do task"}],
        extra_body={"computer_id": computer.computer_id},
    )
finally:
    computer.destroy()

screenshot = computer.screenshot()
screenshot.save("debug.png")

stream = client.chat.completions.create(
    model="claude-sonnet-4.6",
    messages=[{"role": "user", "content": "Do task"}],
    extra_body={"computer_id": computer.computer_id},
    stream=True,
)
for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")

​
Next Steps

API Reference

Explore all available endpoints

Use Any Model

Claude, GPT, Gemini, and more