What My OpenClaw Agent Actually Costs Me Per Month
Honest numbers, no marketing fluff. What each model costs, where the hidden spend is, and the things I changed that actually made a difference to my bill.
Last updated: March 4, 2026
The short version: Most casual users spend $3–20/month. Daily drivers land around $40–80. Heavy or always-on setups can run $100–500+. Misconfigured agents have cost people thousands. The biggest factor is which model you use and whether you actively manage it.
1 Where the money actually goes
OpenClaw is free software. You don't pay for OpenClaw itself. What you pay for is the AI model API — every time your agent thinks, responds, reads a file, calls a tool, or runs a heartbeat check, it sends tokens to your provider (Anthropic, OpenAI, Google, or via OpenRouter) and you get charged per token.
The things that consume tokens:
Your conversations — every message you send and every reply the agent generates. Longer conversations cost more because the agent re-reads the entire conversation history on each turn.
Tool calls — when the agent reads files, runs shell commands, searches the web, or calls APIs. Each tool call is a separate set of tokens on top of the conversation.
Heartbeats — every 30 minutes (by default), your agent wakes up and checks for tasks. Even if nothing's happening, it reads the heartbeat prompt, checks its files, and responds. That's tokens. 48 times a day. Every day.
Sub-agents — when your agent spawns background tasks. Each sub-agent is a separate model call with its own context.
Compaction — when conversations get long, OpenClaw compresses the history. This involves reading the full conversation and generating a summary. It's a large, expensive operation.
The hidden cost people miss: heartbeats use your primary model by default. If your primary is Claude Sonnet at $3/$15 per million tokens, those 48 daily heartbeat pings add up — potentially $15–20/month just in heartbeats. More on how to fix this below.
2 What each model actually costs
This is the single biggest factor in your monthly bill. The difference between models isn't 2x or 3x — it can be 50–100x.
| Model | Input $/1M tokens | Output $/1M tokens | Agent Quality |
|---|---|---|---|
| Claude Opus 4.6 | $15.00 | $75.00 | Excellent |
| Claude Sonnet 4.5 | $3.00 | $15.00 | Excellent |
| Claude Haiku 4.5 | $1.00 | $5.00 | Good |
| GPT-5.2 | $2.50 | $10.00 | Good |
| GPT-4o-mini | $0.15 | $0.60 | Decent |
| Gemini 2.5 Flash | $0.15 | $0.60 | Decent |
| Gemini 2.0 Flash Lite | $0.08 | $0.30 | Basic |
| Local (Ollama) | $0 | $0 | Limited |
To put that in perspective: sending the same 30 messages a day through Opus versus Haiku is roughly the difference between $150/month and $12/month. Same agent, same tasks, same setup — just a different model.
3 What real users actually spend
These numbers are compiled from community reports, forum posts, and blog breakdowns. Your mileage will vary — but this gives you a realistic range.
| Usage Type | Description | Typical Range |
|---|---|---|
| Casual / light | A few messages a day, quick lookups, budget models | $3–$20/mo |
| Daily driver | 20–80 messages/day, mid-tier models, multiple channels | $40–$100/mo |
| Power user / small team | Heavy automation, CRM, web scraping, browser tasks | $80–$250/mo |
| Coding agent (24/7) | Always-on, long contexts, lots of tool calls | $100–$500+/mo |
The horror stories are real. One user burned $3,600 in their first month running Sonnet through 180M tokens. A developer left Opus agents running overnight and woke up to $6,000. A Discord server operator hit $214 overnight from a spam wave triggering Opus responses. These aren't average — but they show what happens without spending limits.
4 Your agent cannot track its own costs
This is the thing almost nobody explains clearly: your OpenClaw agent has no idea how much it's spending.
There's no built-in billing API. There's no cumulative token counter your agent can read. There's no budget enforcement system that stops the agent when it hits a limit. Your agent can't calculate what an action will cost before it runs it.
You can write instructions in your manifest file that say "be cost-conscious" or "prefer Haiku for simple tasks" — and that genuinely helps, because the model will try to follow those instructions. But it's guidance, not enforcement. The agent might still use 10,000 tokens on a simple question if the conversation history is long.
What actually works for cost protection
1. Set a hard spending limit on your provider's dashboard. This is the only real safety net. Anthropic, OpenAI, Google, and OpenRouter all let you set monthly or daily caps. If you do nothing else, do this.
2. Check your provider's usage dashboard regularly. At least daily for the first week. Get a feel for your actual burn rate before you start trusting estimates.
3. Use limits.maxDailySpend in your config. This is a recently added OpenClaw config key that pauses your agent when hit. It's basic, but it's something:
4. External tools. Projects like TokPinch and Tokscale track token usage across sessions and give you the visibility OpenClaw doesn't provide natively.
5 Switch models yourself — the agent won't do it for you
This is the second big misconception. Your agent does not automatically switch to a cheaper model for simple tasks. OpenClaw has no built-in intelligence that evaluates task complexity and picks the right model. Two separate feature requests for this were filed on GitHub. Both were closed as "not planned."
Here's what actually happens:
Your primary model handles every single turn. Every message, every heartbeat, every sub-agent (unless you override it). If your primary is Sonnet, then "what's the weather?" costs the same per-token as "review this 500-line codebase."
Fallbacks only kick in when something fails. Rate limits, auth errors, timeouts. Not because a task is simple. The fallback chain is an error recovery system, not a cost optimisation system.
You switch models manually with /model. This is the real cost control tool:
Get in the habit: start your session on Haiku, switch to Sonnet when you need reasoning power, switch back when you're done. It takes two seconds and can cut your bill in half.
Set up aliases to make it easy
Community tip: there are third-party skills like model-router and proxy tools like ClawRouter that add automatic complexity-based routing. They work, but they're external — not built into OpenClaw. Worth exploring if you want hands-free model switching.
6 Fix your heartbeat model — it's probably costing you more than you think
By default, heartbeats use your primary model. If your primary is Sonnet, every 30-minute heartbeat ping burns Sonnet-level tokens. 48 times a day. For checking if there are new emails.
Override it to use a cheap model:
Two changes here that save money: use the cheapest model that can handle heartbeat tasks (Haiku is fine), and restrict active hours so your agent isn't pinging at 3am when you're asleep. This dropped my heartbeat cost from $15–20/month to under $5.
Restricting heartbeats to 14 waking hours instead of 24 cuts heartbeat costs by about 40%.
7 Other config settings that actually reduce costs
maxConcurrent
Limits how many things your agent can do in parallel. Default is ~4. If you're cost-sensitive, consider reducing to 2. Fewer parallel runs = fewer simultaneous model calls = lower peak spend.
Sub-agent model override
Sub-agents inherit your primary model by default. You can assign them a cheaper model — unless your sub-agents are running complex tasks while your main agent handles simpler ones, in which case you'd want the opposite configuration:
Shorter conversations + persistent memory
Every message you send includes the full conversation history. A 50-message conversation means the agent re-reads all 50 messages on turn 51. Your per-message cost increases as the conversation goes on.
Get into this habit: every 5–10 messages, tell your agent to save important information to its persistent memory. Then start a fresh session with /new when you switch tasks. Because you've been saving to memory, the agent will have context from the previous session without you having to explain everything again.
This alone can save $15–25/month depending on how long your conversations tend to run.
Write better instructions
Tell your agent to give concise answers. "Quick answer when a quick answer will do" in your manifest genuinely reduces output tokens. Don't re-read files already in context. Batch related tasks. These habits compound.
My actual monthly breakdown
Here's roughly what I spend running OpenClaw as a daily driver with Anthropic models, ~30 messages a day, heartbeats running during waking hours, and a couple of cron jobs:
| Item | Model | Est. Cost |
|---|---|---|
| Daily conversations | Haiku (primary), Sonnet when needed | $30–$45 |
| Heartbeats (waking hours only) | Haiku | ~$3–$5 |
| Cron jobs (8/day weekdays) | Haiku | ~$1 |
| Embeddings | text-embedding-3-small | ~$0.10 |
| Total | $40–$60/mo |
Before I fixed the heartbeat model, started using /model to switch, and got into the habit of saving to memory and starting fresh sessions — I was spending $140–180/month doing the same work. The agent wasn't doing more useful things at $180. It was just burning premium tokens on routine tasks and re-reading massive conversation histories.
Clawfy's wizard sets all of this up for you
The ClawConfig wizard asks you 6 questions — OS, provider, budget, what you want the agent to do — and generates an optimised openclaw.json with the right primary model, heartbeat model override, fallback chain, and cost-saving habits already configured. It includes a cost estimator so you can see projected ranges before you start.
It also generates a capability manifest (clawfy.md) that gives your agent concise instructions on which models are available, how to suggest switching, and what safety rules to follow.
Try the wizard — free to preview Config generation is free. Full package (config + manifest + setup guide + 14 days support) is $49.The checklist
Before you do anything else:
✅ Set a hard spending limit on your API provider's dashboard
✅ Override your heartbeat model to something cheap (Haiku, Flash)
✅ Restrict heartbeat active hours to when you're actually awake
✅ Use /model haiku for routine tasks, switch up when you need power
✅ Save important info to persistent memory every 5–10 messages
✅ Start fresh sessions with /new when switching tasks
✅ Check your provider's usage dashboard daily for the first week
✅ Set limits.maxDailySpend in your config as a backstop
Remember: your 30 messages a day will be different to someone else's. More complex messages with tool calls and long reasoning chains cost more than simple lookups. Be conscious of what you're asking for and which model is handling it.
Your agent is a tool. A very powerful, very expensive tool if you let it run unsupervised on premium models with no limits. Treat it like any other infrastructure cost: monitor it, configure it, build good habits, and set guardrails.