OpenHelm API
An API for AI agents that finishes the hard tasks.
One POST /v1/runs call starts an agent in an isolated cloud sandbox with a real stealth browser and code execution. Describe the task, pin a JSON output schema, and get back a structured, evidence-backed result, whether it takes forty seconds or four hours.
One call
Start a run with curl or fetch.
curl https://api.openhelm.ai/v1/runs \
-H "Authorization: Bearer oh_live_..." \
-H "Content-Type: application/json" \
-d '{
"prompt": "Research {{company}} and summarise its latest funding round, investors, and valuation.",
"inputs": { "company": "Anthropic" },
"model": "sonnet",
"output_schema": {
"type": "object",
"properties": {
"round": { "type": "string" },
"investors": { "type": "array", "items": { "type": "string" } },
"valuation": { "type": "string" },
"source_urls": { "type": "array", "items": { "type": "string" } }
}
},
"callback_url": "https://example.com/hooks/openhelm"
}'const res = await fetch('https://api.openhelm.ai/v1/runs', {
method: 'POST',
headers: {
Authorization: `Bearer ${process.env.OPENHELM_API_KEY}`,
'Content-Type': 'application/json',
},
body: JSON.stringify({
prompt: 'Get the pricing tiers listed on stripe.com',
output_schema: {
type: 'object',
properties: { tiers: { type: 'array', items: { type: 'string' } } },
},
}),
});
const { task_id, poll_url, billing } = await res.json(); // 202 AcceptedThe full endpoint list, the result envelope and webhook signing are in the developer docs, and the OpenAPI spec is served from the live API.
Async by design
202 now, the result when it is actually done.
Agent tasks do not fit a request-response timeout. Every run is accepted immediately with a cost estimate on the 202 body, then you poll the task or receive an HMAC-signed webhook when it completes.
HTTP/1.1 202 Accepted
{
"task_id": "run_2x9f4c...",
"status": "queued",
"poll_url": "https://api.openhelm.ai/v1/runs/run_2x9f4c...",
"billing": {
"model": "sonnet",
"credit_usd_rate": 0.05,
"estimated_cost_usd": { "low": 0.05, "high": 0.3 },
"estimated_credits": { "low": 1, "high": 6 }
}
}GET https://api.openhelm.ai/v1/runs/run_2x9f4c... → 200 OK
{
"task_id": "run_2x9f4c...",
"status": "succeeded",
"result": { "tiers": ["..."] },
"confidence": "high",
"evidence": {
"screenshot_url": "https://...",
"checked_at": "2026-07-10T08:12:04Z"
},
"usage": { "duration_ms": 48210, "cost_usd": 0.11 }
}
# Or skip polling: pass callback_url and receive this envelope as an
# HMAC-signed webhook, { "event": "run.completed", "data": { ... } }.What you get
The primitives for agents in production.
One call, a whole agent run
POST /v1/runs with a natural-language prompt and an optional JSON output_schema. The agent plans, browses, executes and extracts, then returns a structured result with evidence.
Built for long-running work
Every run returns 202 with a task_id immediately. Poll GET /v1/runs/{id} or supply a callback_url for an HMAC-signed webhook, so tasks that take minutes or hours never hold a connection open.
A real browser, not just a model
Runs execute in isolated cloud sandboxes with a stealth browser and code execution, so agents can reach the parts of the web an LLM API alone cannot.
Scheduled and recurring jobs
Create jobs as reusable task templates and run them with parameters. Recurring jobs fire your webhook on every run: register once, receive results for as long as the job lives.
Connections for credentials
Provision scoped credentials over POST /v1/connections, or mint hosted connect links for OAuth providers. A run that needs a missing connection fails with failure_reason "auth_required" rather than guessing.
Costs you can see coming
Every accepted run returns a cost estimate on the 202 body, and the billed figure comes back in usage.cost_usd. Per-key monthly caps and an org daily cap bound spend.
Connections
Give agents credentials without handling them yourself.
# Store a scoped API key the agent can use at run time
curl https://api.openhelm.ai/v1/connections \
-H "Authorization: Bearer oh_live_..." \
-H "Content-Type: application/json" \
-d '{ "name": "GitHub", "type": "token",
"secret": "ghp_...", "env_var_name": "GITHUB_TOKEN" }'
# OAuth/browser providers: mint a hosted connect link,
# your user authorises once in the browser
curl https://api.openhelm.ai/v1/connections/links \
-H "Authorization: Bearer oh_live_..." \
-H "Content-Type: application/json" \
-d '{ "provider": "google" }'Secrets are write-only and encrypted; runs resolve them at execution time inside the sandbox. See the Connections API docs and the 30+ supported integrations.
Pricing & security
Credit-based pricing, bounded by caps.
Usage draws from your plan’s monthly credits (1 credit = $0.05 of billed cost). Every accepted run carries an up-front estimate, the billed figure returns in usage.cost_usd, and per-key monthly caps plus an org daily cap keep spend bounded. See pricing & credits and plans.
Auth is a bearer key (oh_live_...) minted and revoked in the app; the MCP front door uses OAuth 2.1 and stores no secrets. Webhooks are HMAC-signed, and all work executes in isolated sandboxes. Prefer tools in ChatGPT, Claude or Cursor instead of REST? The same engine is exposed as remote MCP servers.
Common questions about the API
What makes this an API for AI agents rather than an LLM API?
An LLM API returns text from a model. OpenHelm runs a full agent: each request starts an isolated cloud environment with a stealth browser and code execution, works the task through multiple steps, and returns a structured JSON result with evidence such as screenshots and source citations. You describe the outcome; the agent does the work.
How do I get results for tasks that take a long time?
Every run is asynchronous. POST /v1/runs returns 202 with a task_id and poll_url straight away. Fast tasks resolve in seconds of polling; for anything longer, pass a callback_url and OpenHelm delivers the completed result envelope as an HMAC-signed webhook. Recurring jobs fire the webhook on every run.
How does the agent authenticate with third-party tools?
Through Connections. Store scoped API keys with POST /v1/connections (secrets are write-only and encrypted), register remote MCP servers by URL, or mint a hosted connect link so a human can complete an OAuth sign-in once. Runs resolve whatever connections the task needs at execution time.
How is the API priced?
Usage draws from your OpenHelm plan’s monthly credits, where 1 credit equals $0.05 of billed cost. Each accepted run returns an up-front estimate, the actual cost arrives in usage.cost_usd on completion, and per-key monthly caps plus an org daily cap keep spend bounded. New accounts start with a free trial.
Is the API secure enough for production use?
Keys are bearer tokens (oh_live_...) minted and revoked in the app. Secrets live in encrypted storage and are injected only at run time inside isolated sandboxes. Webhooks are HMAC-signed so you can verify origin, and the MCP layer uses OAuth 2.1 and stores no secrets of its own.
Run your first agent task in the next five minutes.
Sign up, mint a key under Settings → API & Webhooks, and POST /v1/runs. The quickstart walks through the first call, polling, webhooks and connections.