OpenHands self-hosted cost: API, sandboxes and cloud plans

A self-hosted OpenHands costs $0 for the software and nothing for a licence — it is MIT-licensed and the repository is active, not archived — so the real self-hosted cost is three separate bills: model tokens, the machine running the sandbox, and an optional search key. OpenHands publishes no price for any of the three. What it does publish, unusually for a coding agent, is its own benchmark repository recording dollars and seconds per task, and that is the anchor this page uses instead of guessing at token counts.

Three disambiguations first, because each one sends a cost question to the wrong page. AI4Bharat ships a different open-source project also called OpenHands — a sign-language-recognition toolkit whose repository banner says it is no longer actively maintained — and nothing from its documentation applies here. This product was OpenDevin until August 2024 and the company was All Hands AI, so any OpenDevin-era config is superseded V0. And while the marketing site is openhands.dev, the running services are still on all-hands.dev: the Cloud app is app.all-hands.dev, and the provider documentation says that if your network has firewall restrictions you should allow the all-hands.dev domain, because the SDK connects to llm-proxy.app.all-hands.dev.

OpenHands pricing: what the company itself charges

Read from openhands.dev/pricing on September 21, 2026. There is no paid individual subscription, and every tier's feature row offers bring-your-own-key: the FAQ there reads "Yes! OpenHands Open Source and OpenHands Cloud plans offer support to bring your own LLM keys." Two anchors that circulate widely off-site are not on any first-party page we could find that day — a paid Growth plan, and $20 in free credits for new Cloud users. Treat both as stale until OpenHands republishes them.

One first-party number pulls against the word Free, and it is the honest floor: the API-keys documentation states "You must purchase at least $10 in OpenHands Cloud credits before generating an OpenHands LLM Key." Both things are true. The client and the tier are free; their own model provider starts at a $10 prepaid purchase. Bringing your own key skips that floor entirely and moves the whole bill to your provider.

The three bills behind "self-hosted"

OpenHands V1 splits into three components that fail and bill independently, per its architecture page: Agent Canvas, the browser client, which that page says explicitly "is not an agent runtime or sandbox"; Agent Server, which runs conversations and tools; and the workspace or sandbox, described only as "Deployment-specific". That split is why one monthly figure never answers this question.

Do not read a single "current version" into any of this either. Four surfaces disagree, and each number belongs to one of them: GitHub releases stand at v1.20.0 (September 17, 2026), PyPI's openhands CLI package at 1.16.0, uploaded May 8, 2026, PyPI's openhands-sdk at 1.49.2, uploaded September 17, 2026, and the local-setup docs pin their own Docker image tags. Pin whichever surface you actually deploy.

The machine line, priced against OpenHands' own sizing

OpenHands is unusually specific here: its VM backend guide says "Ubuntu 24.04 LTS with 2 vCPU and 4 GB RAM is enough for a single user." That class has a published price at two major providers — a DigitalOcean Basic Droplet with 4 GiB memory, 2 vCPU, 80 GiB SSD and 4,000 GiB transfer at $24.00 per month, $0.03571 per hour (DigitalOcean), and an AWS Lightsail Linux bundle with 4 GB memory, 2 vCPUs, 80 GB SSD and 4 TB transfer at $24 per month (Lightsail). These are third-party prices for a machine you choose, not OpenHands prices.

Put that hourly rate next to OpenHands' own published average runtimes and the shape of the bill becomes obvious. The figures below are an estimate: they assume one conversation at a time on one always-on VM, and they ignore image pulls, idle time between turns, storage and transfer.

Tokens outweigh compute on every row, but not by a constant factor: the ratio runs from about 16× on the MiniMax-M3 SWE-bench row to roughly 475× on claude-opus-4-8's, because the cheap model is also the slow one. The machine is not free, though — it is a fixed monthly floor that charges whether or not you run anything, which is the opposite billing shape from tokens. Two consequences worth designing around. First, the VM only earns its keep above a certain volume: at the catalog re-pricing further down, $24 of machine equals about 64 SWE-bench-sized tasks' worth of model spend, so below that the fixed cost dominates. Second, throughput is capped harder than the price suggests — OpenHands' Docker sandbox page warns that host-network mode binds every sandbox to the same fixed host ports, so "Only one sandbox can run at a time; concurrent conversations will collide on those ports." Note also that its user-facing term is now sandbox while the configuration knob is still RUNTIME — the sandboxes overview lists docker (default), process and remote as the legacy values — so search for both words.

Running the model on that machine too is a different purchase. OpenHands' local-LLM page states its hardware requirement for one specific model — Qwen3.6-35B-A3B, the model that page recommends for coding — as "a recent GPU with at least 24GB of VRAM for quantized variants, or multiple GPUs for full precision and larger context windows, or a Mac with Apple Silicon with at least 64GB of unified memory for quantized variants", plus OLLAMA_CONTEXT_LENGTH set to at least 22,000 on Ollama. A smaller local model may well need less; OpenHands does not publish a floor for local models in general. Either way it is hardware capital, not a $24 droplet.

OpenHands API cost: the only first-party per-task dollars

No OpenHands page publishes tokens per task, per conversation, or an average context size — so any token-count example is an assumption. Its Index results repository publishes dollars and seconds instead, which is stronger. We fetched the 500-row SWE-bench sidecars for four models and recomputed them; the means and resolve rates reproduce the published figures, which is what validates reading cost_per_instance as the mean API cost per benchmark instance.

The distribution matters more than the mean. On claude-opus-4-8 the median instance cost $0.3877 against a mean of $0.7418, and the worst single instance cost $8.35 — about eleven times the mean. Budget from the tail, not the average. Three caveats on the whole table: the repository was last pushed July 8, 2026, so these runs are roughly two and a half months old; each row ran at its own recorded agent version, so rows are not a controlled head-to-head; and these are benchmark instances, not your repository.

Cheapest listed price and lowest cost to finish the task are different claims, and this table separates them. MiniMax-M3 has the lowest per-token rate in the group and the lowest mean instance cost, at roughly a fifth of claude-opus-4-8 — but it resolved 76.4 percent against 83.8 percent, so a share of those cheap attempts bought nothing and has to be re-run or finished by hand. GPT-5.5 is the other direction: twice the mean cost of claude-opus-4-8 for 5.6 fewer points resolved. The rule that survives is unglamorous — shortlist the least expensive model that finishes your work at a review effort you accept, then read the charge your own account recorded for one bounded task.

The ceiling is on the commit0 benchmark, where a single task runs into single-digit dollars — and where the machine column shows how little the runtime spread costs when only one conversation runs at a time.

OpenHands is candid about why: its LLM page says it "requires a powerful model to work" and warns that it "will issue many prompts to the LLM you configure". The control it gives you is a hard stop, not a forecast: Settings > Application has a Maximum Budget Per Conversation in USD, and that page says OpenHands "will stop the conversation once the budget is reached, but you can choose to continue the conversation with a prompt". So it is a per-conversation stop you can override, not a monthly ceiling.

Re-pricing that benchmark at catalog rates

Here is the one place the published figures transfer without a token guess. OpenHands' metadata.json for claude-opus-4-8 records the exact prices its run was costed at — and Kunavo lists that same model id.

Because all four classes land on the same factor today, the published run re-prices by that factor without needing the token counts nobody publishes. The mean SWE-bench instance moves from $0.7418 to $0.3709, the median from $0.3877 to $0.1938, and the worst instance from $8.35 to $4.17. This is a re-pricing of someone else's benchmark, not a measured task cost on your repository — the agent version, the prompt mix and the cache behaviour would all have to match.

For a conversation shape instead of a benchmark, here is plain token arithmetic. Assumption, ours and not OpenHands': one conversation sends 800k input tokens across its turns as context is re-sent, and receives 30k output tokens, with no cache hits counted. Rates are live Kunavo catalog prices.

Illustrative token arithmetic, not a measured task cost and not a bill ceiling — scale it by your own conversations per day before treating it as a budget. Kunavo's catalog amount is a billing floor rather than a cap: when the upstream reports its charge, the bill is the greater of catalog cost and upstream cost times the applicable markup. Minimum top-up is $10 in prepaid credit, which is a funding minimum rather than a subscription or a task fee — see billing details.

Best API for OpenHands: which route wins when

One caveat before you pick the "at cost" route on price alone: OpenHands' own two pages describe different catalogues. Its LLM overview recommends claude-opus-4-8 (Index average 71.9), GPT-5.5 (65.9) and Gemini-3.5-Flash (62.6), while the provider price table on the sibling page lists 15 prior-generation ids — the newest per vendor being claude-sonnet-4-5-20250929 and claude-opus-4-1-20250805, gpt-5-codex and gpt-5-2025-08-07, o3, and gemini-3-pro-preview — and contains none of those three. Both were read on September 21, 2026. Whether the table is stale or the catalogue genuinely is that old, we could not establish, so check what the provider actually serves at checkout before budgeting against its footnote that "Prices listed reflect provider rates with no markup".

Four boundaries decide which of those you are actually on, and every one of them is a cost-attribution fork. The critic is gated. OpenHands' critic documentation says the experimental critic feature is "automatically enabled" for OpenHands LLM Provider users and is "free during the public beta phase" for them; it is a second endpoint, so a third-party agent key does not forbid one, it simply means none is configured for you. Its iterative refinement is disabled by default, and when you enable it the Max Iterations setting defaults to 3 per user turn and accepts 1–10 — a real multiplier, on that route only. Provider Connections invert the usual plan gate: the model-configuration page says the reusable key-and-base-URL panel is "available on local agent-server backends" and "hidden when using an OpenHands Cloud backend", so self-hosting gets that feature and Cloud does not. Profiles are capped: the LLM settings page says "You can save up to 10 LLM profiles per account." And a saved profile is validated before it persists — the profiles page says a rejected key or unavailable model blocks the save and shows the backend error, though it also notes older backends that lack the validation endpoint skip the check and save anyway.

Kunavo serves no embedding model, no text-to-speech model and no speech-to-text model, so an endpoint here answers chat completions and nothing else — which matters because OpenHands names LLM_EMBEDDING_MODEL among its env-only extras, and that setting has no counterpart to point at.

On the endpoint itself, the model prefix and the base URL are one decision, and OpenHands documents them by example rather than by rule. Its model-configuration page tells you to enter openai/<served-model-id> for an OpenAI-compatible server and shows a base URL ending in /v1; its LiteLLM proxy page tells you to enter litellm_proxy/<model-name> and shows a bare proxy origin with no path. Neither page states what happens if you pair one prefix with the other's URL shape, so copy the shape from the page that matches your prefix and check the response rather than assuming. Separately, the OpenHands provider page says the openhands/ prefix "tells the SDK to automatically route requests to the OpenHands LLM proxy—no need to manually set a base URL"; that sentence is about the SDK, not about the Agent Canvas settings panel. Full field-by-field configuration lives on the OpenHands integration page; create a Kunavo account when you are ready to fund a key, then run one bounded task and read the charge your account recorded for it.

Kunavo has not runtime-tested OpenHands against its endpoint — no conversation, no streamed turn, no tool round-trip, no pinned client version. Everything above was read from OpenHands' own documentation, repositories and package indexes. Keep a working route available while you try it. Comparing clients rather than providers? OpenHands vs Claude Code covers the workflow and sandboxing split, OpenHands vs OpenCode the terminal alternative, and AI cost optimization the method for measuring any of this on your own repository.

FAQ

Re-checked against their own sources on September 21, 2026: openhands.dev/pricing, the GitHub API record for OpenHands/OpenHands and its three latest releases, PyPI openhands and openhands-sdk, the API-keys and LLM-overview documentation, the OpenHands LLM provider price table, the VM sizing guide, DigitalOcean's droplet pricing, and the Index results repository — including the 500-row SWE-bench sidecars for four models, whose means and resolve rates were recomputed here. The critic gating, Provider Connections, the profile cap and pre-save validation, the ACP carve-out, the sandbox, budget and local-LLM pages, and the Tavily and Lightsail prices were each re-read the same day against the pages named inline. Kunavo token rates read from the live catalog; every dollar example is illustrative arithmetic rather than a measured task cost.