canonical: https://jentic.com/apis/orgo.ai/orgo

# Orgo API

The Orgo API provisions cloud computers for AI agents: virtual desktops running Linux, Windows, macOS, Android, or iOS that an agent can drive. It creates computers in a workspace with a chosen RAM, vCPU, disk, GPU, and resolution or from a template, runs apps on them as managed services with logs and restarts, and serves their ports at public URLs or custom domains. Computers can deploy GitHub repositories with builds, rollbacks, and environment variables. An OpenAI-compatible chat completions endpoint sends a conversation to a model that operates a named computer by clicking, typing, and running commands, and the account side covers API keys, capacity, credits, and invoices.

## For AI agents

Provision Linux, Windows, macOS, Android, or iOS cloud computers, run and expose apps on them, deploy GitHub repos, and drive a computer with an OpenAI-compatible computer-use chat endpoint.

## Scope

Does not train or host AI models, store source code, or run serverless functions. Use for provisioning and operating cloud computers for AI agents only.

## Capabilities

- Provision a cloud computer in a workspace with os, ram, cpu, disk_size_gb, gpu, and resolution, or from a template_ref
- Drive a running computer through POST `/api/v1/chat/completions`, an OpenAI-shaped endpoint where the model clicks, types, and runs commands
- Run apps on a computer as services with a command, port, env, and restart policy, then read their logs or restart them
- Serve a computer's port at a public URL on orgo.dev or at a custom domain verified by DNS TXT record
- Import a GitHub repository onto a computer and deploy it, with build logs, cancel, and rollback to an earlier release
- Publish, validate, and build computer templates, or list curated global templates to deploy from
- Create, send, and void invoices paid by card through a Stripe payment page

## Use cases

### Computer-use agent sandbox through Jentic

An AI agent that needs a real desktop to complete a task, such as using a web app with no API, can get one from Orgo. Through Jentic the agent searches for 'create a cloud computer', receives the Orgo createComputer operation with its input schema, and calls POST `/api/computers` with a workspace_id and name. It then sends the task to POST `/api/v1/chat/completions` with the computer_id and messages, and the model operates the computer until it answers.

Example prompt: Call POST `/api/computers` with workspace_id from GET `/api/workspaces`, name 'research-box', and os 'linux', then call POST `/api/v1/chat/completions` with that computer_id and a user message 'Open example.com and copy the pricing table'

### Preview environments from GitHub

A developer wants each branch running somewhere reachable without managing a server. POST `/api/computers/{id}/deploy-projects` imports a GitHub repository by installation_id and repo_id, or a public repo_url, with framework detection for node, python, dockerfile, compose, or static. POST `/api/computers/{id}/deploy-projects/{projectId}/deployments` deploys the newest commit, GET `/api/computers/{id}/deployments/{deploymentId}/logs` streams the build log, and POST `/api/computers/{id}/deployments/{deploymentId}/rollback` restores an earlier release.

Example prompt: Call POST `/api/computers/{id}/deploy-projects` with repo_url 'https://github.com/owner/name', branch 'main', and port 3000, then read GET `/api/computers/{id}/deployments/{deploymentId}/logs` until the build finishes

### Running and exposing apps on a computer

A long-running service such as a bot or dashboard needs to stay up and be reachable. POST `/api/computers/{id}/services` adds an app with name, command, port, restart, and env or secret_env, GET `/api/computers/{id}/services/{serviceId}/logs` returns its recent output, and POST `/api/computers/{id}/public-urls` serves its port at a public orgo.dev URL. POST `/api/computers/{id}/domains` adds a custom domain, checked with the verify operation.

Example prompt: Call POST `/api/computers/{id}/services` with name 'dash', command 'npm start', and port 3000, then POST `/api/computers/{id}/public-urls` with port 3000 and label 'team-dash'

### Agent-run invoicing

An agent doing paid work for a client can bill for it. POST `/api/v1/invoices` creates and finalises an invoice with an amount in cents or line_items and a customer email or phone, and requires an Idempotency-Key header. It returns a Stripe payment page url; POST `/api/v1/invoices/{id}/send` emails it, GET `/api/v1/invoices/{id}` reads its status, and POST `/api/v1/invoices/{id}/void` cancels it if unpaid.

Example prompt: Call POST `/api/v1/invoices` with an Idempotency-Key UUID, description 'Website audit', amount 50000, and customer email 'client@example.com', then POST `/api/v1/invoices/{id}/send`

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/api/computers` | Provision a cloud computer |
| GET | `/api/computers` | List cloud computers |
| POST | `/api/v1/chat/completions` | Run an agent on a computer |
| POST | `/api/computers/{id}/services` | Add an app to a computer |
| POST | `/api/computers/{id}/public-urls` | Make a public URL for a port |
| POST | `/api/computers/{id}/deploy-projects` | Import a GitHub repository and deploy it |
| POST | `/api/computers/{id}/deployments/{deploymentId}/rollback` | Roll back to an earlier deployment |
| GET | `/api/templates/global` | List curated templates |

## Key resources

- **Computers** — Cloud desktops with OS, size, GPU, resolution, and template options
- **Services, URLs, and domains** — Apps run on a computer, their logs, public URLs, and custom domains
- **Deploys** — GitHub deploy projects, deployments, build logs, variables, cancel, and rollback
- **Templates** — Published, global, and validated computer templates with golden image builds
- **Account and billing** — API keys, workspaces, capacity, credits, invoices, and agent signup

## AI readiness

This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.

- **Score:** 66 / 100
- **Maturity:** AI-Aware
- **Dimensions:**
  - Foundational Compliance: 79 / 100
  - Developer Experience & Jentic Compatibility: 65 / 100
  - AI-Readiness & Agent Experience: 51 / 100
  - Agent Usability: 92 / 100
  - Security: 60 / 100
  - AI Discoverability: 64 / 100
- **View full report:** https://jentic.com/apis/orgo.ai/orgo/scorecard
- **How the score is calculated:** https://docs.jentic.com/reference/api-readiness-framework/overview/
- **More about the dimensions:** https://docs.jentic.com/reference/api-readiness-framework/specification/#dimensional-model-overview

### Score it yourself

Every API in the directory is allowlisted, so you can re-score it with no key required.

- **Score your own API:** https://jentic.com/scorecard.md
- **Scoring CLI agent skill:** https://github.com/jentic/jentic-api-scorecard/blob/main/skills/jentic-api-scorecard/SKILL.md

```sh
npx @jentic/api-scorecard-cli score <openapi-url>
```

## Why Jentic

- **Setup:** Wiring Orgo by hand means sending your key as a bearer token, adding an Idempotency-Key header on creates and invoices, and stitching together computer, service, deploy, and chat-completion calls. Through Jentic you install once, import Orgo from the API Directory, store the key once, and your agent calls it.
- **Permission scoping:** Orgo puts the computer id in the URL path (`/api/computers/{id}/...`), so a rule can pin your agent to one computer and the operations you pick on it. You choose the operations it may call, so account-level ones like POST `/api/keys`, POST `/api/v1/credits`, or invoice creation are not included unless you add them.
- **Credential handling:** Your Orgo API key is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'create a cloud computer' or 'deploy a GitHub repo to a computer', and Jentic returns the matching Orgo operation with its input schema so the agent sends the right fields without browsing the reference docs.

## Related APIs

- **E2B API** — Cloud sandboxes for running AI-generated code
- **Browserbase API** — Hosted headless browsers for agents and automation
- **Anthropic Messages API** — Claude models, including computer-use tool support
- **Render API** — Cloud hosting for web services, workers, and databases

## FAQ

### What authentication does the Orgo API use?

The Orgo API uses HTTP bearer auth per its OpenAPI spec: send an Orgo API key as `Authorization: Bearer <key>`. The spec applies it globally, with a few exceptions: GET `/api/health` and the agent signup at POST `/api/v1/agents` are open, and the support endpoints accept a key optionally. POST `/api/v1/chat/completions` also takes an optional x-anthropic-key header, and POST `/api/v1/credits` takes a Payment-Authorization header for MPP payments. Through Jentic your Orgo key is held by your own Jentic One instance.

### Which operating systems can an Orgo computer run?

POST `/api/computers` takes an os of linux (the default), windows, macos, android, or ios, with ram choices from 4 to 64 GB, a cpu value in vCPU, an optional gpu on Linux, and a resolution such as 1280x720x24. macOS computers have a fixed 10 GB of RAM per the spec.

### How does the Orgo chat completions endpoint work?

POST `/api/v1/chat/completions` follows the OpenAI chat completions format, plus a computer_id for a running computer. The model operates that computer, clicking, typing, and running commands, until it answers, and stream true returns chunks as it works. Because it is OpenAI-shaped, the OpenAI SDKs work against the base URL https://www.orgo.ai/api/v1.

### What are the rate limits for the Orgo API?

The OpenAPI spec does not specify request rate limits; what an account can run is governed by its capacity, which GET `/api/account/capacity` reports. Check the Orgo documentation at https://docs.orgo.ai for current limits.

### How do I give my agent a cloud computer through Jentic?

Search Jentic for 'create a cloud computer', load the createComputer operation, and call POST `/api/computers` with a workspace_id and name. Then search for 'run an agent on a computer' to load POST `/api/v1/chat/completions` and pass the new computer_id. To run it on your own infrastructure, install Jentic One from its GitHub repo.

### Is there an Orgo MCP server?

You don't need an MCP server to give your agent Orgo. Jentic connects it directly from the API Directory: import it, store your API key once, and your agent discovers the computer, deploy, and template operations it needs on demand rather than loading all of them into its context.

### Can I limit what my agent is allowed to do with the Orgo API?

Yes. Write a rule that allows POST `/api/v1/chat/completions` and GET `/api/computers/{id}/services/{serviceId}/logs` for a single computer id. The agent can then operate that one computer and read its app logs, but cannot create computers, mint API keys, buy credits, or send invoices, and every call it makes is logged.