Most OpenClaw pricing guides give you a persona (“light user, $15”) and call it a day. That is useless when you are an engineering manager trying to justify the line item in a budget review. You do not have a “light user.” You have five developers, a sprint cadence, and a finance approver who wants a number per head.
So we priced OpenClaw the way real engineering teams consume it: by workload. A bug fix has a token signature. So does a feature build, a code review, and a refactor. Multiply those by how often your team does them, apply current Claude 4.6 API rates, and you get a monthly total that survives a budget review.
This is the deeper numeric companion to our broader OpenClaw pricing breakdown. That piece explains the cost components. This piece does the arithmetic for a 1-developer, 5-developer, and 20-developer team.
The Short Answer
At typical coding intensity, expect $35–90 per developer per month in combined OpenClaw API and hosting costs with smart model routing, and $150–300 per developer per month if you put everything on Claude Opus 4.6 and ignore prompt caching. That maps to roughly $50–110 for a solo developer, $200–500 for a 5-person team, and $800–1,900 for a 20-person team, fully loaded.
Those numbers come from four workload archetypes priced against Anthropic’s current API pricing, not vibes.
The Four Workloads That Drive OpenClaw Cost
We observe four recurring engineering workloads that cover roughly 90% of what developers ask OpenClaw to do on a given day. Each has a predictable token signature.
| Workload | Typical Frequency | Input Tokens | Output Tokens | Right-Sized Model |
|---|---|---|---|---|
| Daily bug fix | 2–4 per dev per day | ~15,000 | ~3,000 | Sonnet 4.6 |
| Weekly feature build | 1–2 per dev per week | ~80,000 | ~20,000 | Sonnet 4.6 (+ Opus for design) |
| Code review pass | 3–6 per dev per week | ~8,000 | ~2,000 | Haiku 4.5 |
| Large refactor | 1–2 per dev per month | ~200,000 | ~40,000 | Opus 4.6 |
These are practitioner estimates based on real OpenClaw sessions: a bug fix usually means loading 3–5 relevant files into context, a feature involves more exploration and more generated code, code reviews are short and classification-like, and refactors span many files with heavy reasoning. The token counts assume OpenClaw’s standard memory configuration and moderate repo context loading.
A sanity check: Anthropic’s own data for Claude Code shows an enterprise average of ~$13 per developer per active day, with 90% of users staying under $30/day (source). Our workload model lands in the same zip code when you route sensibly, which is what we would expect.
Pricing the Workloads (Current Claude 4.6 Rates)
Here are Anthropic’s April 2026 API rates for the models OpenClaw typically routes to:
| Model | Input ($/MTok) | Output ($/MTok) | Cache Hit ($/MTok) | Use When |
|---|---|---|---|---|
| Claude Haiku 4.5 | $1.00 | $5.00 | $0.10 | Classification, short reviews, routing |
| Claude Sonnet 4.6 | $3.00 | $15.00 | $0.30 | General coding, bug fixes, most features |
| Claude Opus 4.6 | $5.00 | $25.00 | $0.50 | Architecture, hard refactors, tricky design |
Cost per workload on the right-sized model:
| Workload | Input Cost | Output Cost | Total per Task |
|---|---|---|---|
| Daily bug fix (Sonnet) | $0.045 | $0.045 | $0.09 |
| Weekly feature (Sonnet) | $0.240 | $0.300 | $0.54 |
| Code review (Haiku) | $0.008 | $0.010 | $0.02 |
| Large refactor (Opus) | $1.000 | $1.000 | $2.00 |
Now multiply by a reasonable cadence for one developer over one 22-working-day month:
| Workload | Rate/Month | Unit Cost | Monthly Subtotal |
|---|---|---|---|
| Bug fixes | 66 (3/day) | $0.09 | $5.94 |
| Features | 6 (1.5/week) | $0.54 | $3.24 |
| Code reviews | 20 (1/day) | $0.02 | $0.40 |
| Large refactors | 1.5 | $2.00 | $3.00 |
| Workload total | ~$12.60 |
That is the raw cost of useful developer output. It is not the full bill. The rest comes from OpenClaw’s background activity and hosting.
Hidden Line Items: Heartbeat, Memory, and Tooling Overhead
OpenClaw is an agent, not a chat session. Three things run whether your developer is actively prompting or not.
Heartbeat polling. OpenClaw’s 30-minute heartbeat consumes roughly 8K–15K input tokens each cycle to scan memory and check pending tasks. Over a month that is ~48 heartbeats/day × 30 days × 10K tokens ≈ 14.4M input tokens. On Haiku 4.5 that costs about $14.40/month per agent. On Sonnet 4.6 it is $43/month. On Opus 4.6 it is $72/month. This is the single most common cause of surprise bills, and we cover it in the sibling pricing breakdown. Pin your heartbeat model to Haiku unless you have a specific reason not to.
System prompt and memory reload. Each interaction includes a system prompt and relevant memory. Without prompt caching, that can add 20–40% overhead on input tokens. With prompt caching, the repeat portion costs 10% of the base input price — a 90% discount per Anthropic’s published multiplier.
Tool use overhead. Tool calls add 300–350 input tokens per message on top of the content. If OpenClaw makes 3 tool calls during a workload, that is roughly 1,000 extra input tokens. On Sonnet that is $0.003. Negligible individually, meaningful at fleet scale.
We budget 25% overhead on top of the raw workload cost to cover these factors for a team with prompt caching configured. Without caching, budget 60% overhead.
Prompt Caching: The Line Item Finance Will Thank You For
Prompt caching changes the math more than anything else OpenClaw lets you configure. The rules, per Anthropic’s docs:
- Cache write: 1.25x base input price (5-min cache) or 2x (1-hour cache)
- Cache read (hit): 0.1x base input price — a 90% discount
- Break-even: one cache read pays off the 5-minute write
A worked example. Say your OpenClaw agent loads a 50,000-token repo snapshot into context and reuses it 20 times per day per developer across bug fixes and features. On Sonnet 4.6:
| Scenario | Per Cycle | Daily (20 uses) | Monthly (22 days) |
|---|---|---|---|
| No caching | 50K × $3/MTok = $0.15 | $3.00 | $66.00 |
| With caching (1 write, 19 hits) | $0.1875 + 19 × $0.015 = $0.47 | $0.47 | $10.40 |
That is an 85% reduction on that line item alone, from $66 to $10 per developer per month. Multiply by 20 developers and you have saved the team $1,100/month by toggling one configuration. The math is not subtle.
Monthly Totals: 1, 5, and 20 Developers
Now the part that matters for the budget review. These totals assume:
- Sensible model routing (Haiku for reviews, Sonnet for most work, Opus for refactors)
- Prompt caching enabled (25% overhead on raw workload cost)
- Heartbeat pinned to Haiku
- One shared VPS scales across the team (no per-developer hosting multiplier)
- Hosting on Hostinger KVM 2 at $8.99/mo for 1 dev, upgrading to DigitalOcean 8GB at $48/mo for 5 devs, and a dedicated 16GB server at $96/mo for 20 devs
| Line Item | 1 Dev | 5 Devs | 20 Devs |
|---|---|---|---|
| Workload API cost | $12.60 | $63 | $252 |
| 25% overhead | $3.15 | $15.75 | $63 |
| Heartbeat (Haiku) | $14.40 | $14.40 | $28.80 (2 agents) |
| Repo context caching residual | $10.40 | $52 | $208 |
| Hosting | $8.99 | $48 | $96 |
| Routed + cached total | $49.54 | $193.15 | $647.80 |
| Per developer | $49.54 | $38.63 | $32.39 |
Per-developer cost drops as the team grows because hosting and heartbeat amortize across more engineers. This is the argument that wins budget reviews: OpenClaw gets cheaper per head at scale.
Now the same scenarios on the “everything is Opus, no caching” plan that causes the $300+ bills people complain about on Reddit:
| Line Item | 1 Dev | 5 Devs | 20 Devs |
|---|---|---|---|
| Workload on Opus (4x Sonnet baseline) | $50.40 | $252 | $1,008 |
| 60% overhead (no caching) | $30.24 | $151.20 | $604.80 |
| Heartbeat on Opus | $72 | $72 | $144 |
| Repo context (no cache) | $66 | $330 | $1,320 |
| Hosting | $8.99 | $48 | $96 |
| All-Opus, uncached total | $227.63 | $853.20 | $3,172.80 |
| Per developer | $227.63 | $170.64 | $158.64 |
The gap between a well-configured team and a default-everything team is roughly 4–5x. That is the spread a finance approver cares about, and it is entirely under your team’s control.
When to Route, and When Routing Stops Paying Off
Model routing is not automatically cheaper. It adds complexity. The break-even question is: at what workload mix does the routed setup cost less than a single-model Opus setup?
On our workload model, routing to Sonnet + Haiku + occasional Opus costs roughly $12.60 per developer per month in API spend. An all-Opus setup on the same workloads costs roughly $50 per developer per month in API spend (4x the token cost). The routing setup wins by $37.40/month per developer as long as your mix looks like ours.
The routing break-even flips when more than ~70% of your workloads require Opus-level reasoning. For a team doing mostly greenfield architecture work or heavy compiler-style refactoring, the overhead of maintaining a routing config may not be worth the savings. For a team doing typical product development with a healthy mix of small fixes, features, and reviews, routing saves ~75% of API spend every month.
A pragmatic rule: default to Sonnet 4.6, route down to Haiku for classification and short tasks, route up to Opus only for tasks the developer explicitly flags as hard. OpenClaw’s workspace configuration handles this routing logic — see our multi-model configuration guide for the specific settings.
OpenClaw Cloud vs Self-Hosted at Team Scale
OpenClaw Cloud is $59/month per agent (pricing page). It replaces hosting and maintenance, not API costs. You still pay for tokens.
For a 5-developer team sharing one agent setup:
- Self-hosted: $48 hosting + $48 overhead = ~$96/month in infrastructure
- OpenClaw Cloud: $59/month, zero maintenance
Cloud wins for 5-dev teams if you value the ops savings. For 20 devs running multiple agents, the math shifts: two or three Cloud agents cost $120–180/month, whereas a dedicated $96 server handles the load with more control. The teams pricing guide covers the Cloud-for-teams specifics.
Three Cost Controls That Move the Number
- Pin the heartbeat model to Haiku 4.5. Saves $30–60/month per agent versus defaulting to Sonnet or Opus. This is the single highest-ROI configuration change.
- Enable prompt caching on repo context. The 90% cache-read discount takes $50–70/month per developer off the bill if your team loads any shared context repeatedly (which, for coding agents, is almost always).
- Route by workload, not by default. Sonnet for most work, Haiku for reviews and classification, Opus only when a developer flags a task as hard. This alone is a 75% reduction versus an all-Opus default.
Two things that do not move the number enough to care about at typical team scale: hosting provider shopping (the delta between Hostinger and DigitalOcean is $40/month on a team doing $500+ in API spend) and batch processing (useful for offline workloads but OpenClaw is mostly interactive).
Frequently Asked Questions
How much does OpenClaw cost per developer per month?
Between $32 and $60 per developer per month for a team with model routing and prompt caching configured, and that number drops as the team grows because hosting and heartbeat amortize across more developers. Without those controls, expect $150–300 per developer. The software itself is free under MIT license; all costs are API tokens plus a shared VPS.
What is the cheapest way to run OpenClaw for a 5-developer team?
Share one VPS (DigitalOcean 8GB or similar at ~$48/month), pin the heartbeat model to Claude Haiku 4.5, enable prompt caching on your repo context, and route most requests to Sonnet 4.6 with Opus reserved for flagged hard tasks. A 5-developer team configured this way runs around $190–220/month total, or ~$40 per developer.
How much does OpenClaw API usage cost for a 5-developer team?
Around $130–150/month in API spend for a team doing typical product development (bug fixes, feature work, code reviews) with sensible model routing and prompt caching. Without routing and caching, the same team easily hits $500–800/month in API spend. The 4–5x swing is almost entirely driven by two settings: heartbeat model and whether caching is enabled.
Does prompt caching actually reduce OpenClaw costs?
Yes, by a large margin. Anthropic’s published cache-hit multiplier is 0.1x the base input price, a 90% discount on repeated context. For a team that loads a 50K-token repo snapshot 20 times per developer per day, prompt caching cuts that line item from about $66/month per developer to about $10/month per developer. On a 20-developer team that is $1,100/month saved from one configuration toggle.
When should a team route between Haiku, Sonnet, and Opus?
Always, unless more than 70% of your workloads require Opus-level reasoning. For a team doing typical product development, route code reviews and short classification tasks to Haiku 4.5, most coding work to Sonnet 4.6, and flagged-hard tasks (architecture, complex refactors) to Opus 4.6. This saves roughly 75% on API tokens compared to an all-Opus setup.
Is OpenClaw Cloud cheaper than self-hosting for a 5-developer team?
Cloud at $59/month per agent is competitive with a $48/month VPS plus maintenance overhead, so for 5 developers sharing one agent the infrastructure costs are a wash and Cloud wins on operational simplicity. For 20-developer teams running multiple agents, self-hosting on a dedicated server tends to cost less and gives more control. Cloud never reduces API token costs — those depend entirely on usage and model selection.
How do I control OpenClaw costs across a 20-developer engineering team?
Three levers dominate. First, enforce a shared workspace configuration with the heartbeat pinned to Haiku and prompt caching enabled. Second, build a lightweight dashboard against the Anthropic billing API so cost owners see per-developer spend weekly. Third, establish a routing policy — default to Sonnet, reserve Opus for explicitly flagged hard tasks. Teams that skip these end up paying 4–5x more than teams that implement them, for identical output.
What is the biggest hidden cost of OpenClaw at team scale?
Forgotten automations. At 20 developers, you will have heartbeat cycles running against stale memory, cron jobs that outlived their purpose, and test workflows nobody remembers creating. These quietly consume 10–30% of monthly API spend in our observations. Audit active automations quarterly and disable anything without a clear owner. Our reducing OpenClaw costs guide covers the audit playbook.
Key Takeaways
- OpenClaw cost scales with engineering workload, not with headcount alone. Price by workload type (bug fix, feature, review, refactor), then multiply by cadence and headcount.
- At typical intensity with routing and caching, expect $32–60 per developer per month fully loaded. Without those controls, expect $150–300 per developer.
- Per-developer cost drops as the team grows because hosting and heartbeat amortize. A 20-developer team runs around $32/dev/month; a solo developer runs around $50/dev/month.
- Three configuration choices drive 75%+ of the cost variance: heartbeat model, prompt caching, and model routing. All three are free to enable.
- For broader cost component coverage (VPS pricing, Cloud alternatives, hidden fees), see the sibling OpenClaw pricing breakdown.
SFAI Labs
