OpenClaw's Dirty Secret: It Can Burn Hundreds of Dollars a Day

These aren't hypotheticals. These are real people, real bills:

That last one — $18.75 overnight — is my favorite. OpenClaw was paying Claude Opus rates to repeatedly check whether the sun was up. About 25 requests, each sending 120,000 tokens of context, for a question a $0 cron job could answer.

One user set up OpenClaw on a Linux VM, did some basic setup prompts, asked it to schedule simple tasks, and went to bed. By morning: 5.7 million tokens consumed. Their comment: "untenable to use with Claude's API unless you have very deep pockets."

This isn't a bug. It's how the architecture works. Here's what's happening under the hood:

1. It resends your entire conversation history every time

Every time you send a message, OpenClaw packages up all your previous messages (stored in JSONL files) and sends them to the API. Your first message? Cheap. Your 50th message in a session? You're now paying for all 50 messages to be re-processed.

Costs grow exponentially the longer your session runs.

2. The system prompt is massive

Before your actual message, OpenClaw sends a system prompt that's typically 5,000–10,000 tokens. That's resent with every single API call. You're paying for it over and over.

3. The Heartbeat feature is a silent budget killer

This is the one that gets people.

OpenClaw has a "Heartbeat" feature that lets the AI proactively wake up and check on things — your email, your calendar, your smart home. Sounds useful. Here's the problem:

• Every Heartbeat trigger is a full API call
• Each call carries the full session context
• If misconfigured, it triggers every few minutes

One user set it to check email every 5 minutes. By end of day, the Heartbeat alone had burned $50.

4. A chatbot costs money when you talk. An agent costs money all the time.

This is the fundamental thing people miss. ChatGPT costs you nothing when you're not using it. OpenClaw is always running. It's thinking, checking, monitoring, retrying.

Most of the cost comes from thinking, not doing.

5. Retry loops compound everything

When something fails — an API is down, a command errors out — the agent often enters retry loops. Each retry burns more tokens, even if no progress is made. And because of #1 above, each retry includes the full conversation context, including all the previous failed attempts.

Let's break down what OpenClaw actually costs with different models:

API Pricing (per million tokens)

Realistic Monthly Costs

At $500–$5,000/month for a full-time Opus agent, you're in the range of hiring a part-time human assistant. That changes the value proposition pretty dramatically.

The Local Model Alternative

Running fully local means zero API costs. But you need the hardware (8GB+ RAM minimum, GPU recommended), and the models are less capable than Claude or GPT-4o for complex tasks.

If you're going to run OpenClaw, here's how to keep costs manageable:

1. Set spending limits BEFORE you deploy

Both Anthropic and OpenAI let you set monthly spending caps in your dashboard. Do this first. Not after your first bill. Before you even start.

# In the Anthropic console:
# Settings → Billing → Set monthly limit
# I'd suggest starting at $50 and adjusting from there

2. Use smart model routing

Not every task needs your most expensive model. OpenClaw supports model routing — use it:

• Simple tasks (reminders, basic lookups): Haiku 4.5 ($0.80/M input)
• Medium tasks (email summaries, scheduling): Sonnet 4.5 ($3/M input)
• Complex tasks (research, analysis, coding): Opus ($5–15/M input)

This alone can cut costs by 50–80%.

3. Reset sessions regularly

When your session context bloats, reset it. OpenClaw has a /compact command that summarizes your conversation and starts fresh. Use it aggressively.

4. Configure Heartbeat carefully

# In your OpenClaw config:
# Don't do this:
HEARTBEAT_INTERVAL=300  # every 5 minutes = $$$
 
# Do this instead:
HEARTBEAT_INTERVAL=3600  # every hour = much more reasonable

Or disable it entirely and use actual cron jobs for time-based checks. They're free.

5. Use local models for routine tasks

Run Llama or Mixtral locally for the simple stuff. Save the cloud API calls for tasks that actually need them.

6. Monitor daily

Check your API dashboard daily for the first week. Look for:

• Unexpected spikes (retry loops)
• Idle usage (Heartbeat burning tokens while you sleep)
• Context bloat (sessions getting too long)

Cloud providers are now racing to offer OpenClaw-as-a-service:

• DigitalOcean — 1-click deploy on Droplets, starting at ~$12/month for the server
• Alibaba Cloud — Simple Application Server, starting at $4/month for hosting
• MyClaw.ai — Fully managed, plug-and-play deployment

Here's the thing: the hosting cost is the cheap part. A $4–12/month server is nothing compared to the API bills. Hosted versions solve the security and setup problems, but they don't solve the token cost problem.

You still need your own API key. You still pay per token. The bills are the same whether OpenClaw runs on your Raspberry Pi or Alibaba's servers.

I'm going to give you the same honest take I gave in my first Clawdbot post:

For most people, no. Not yet.

But if you're going to do it anyway:

1. Start with Haiku or Sonnet, not Opus
2. Set a $50 spending cap and see how far it gets you
3. Disable Heartbeat until you understand the cost implications
4. Reset sessions after every major task
5. Check your API dashboard daily for the first two weeks
6. Consider local models for anything that doesn't need cloud-level intelligence

The technology is incredible. The architecture makes costs unpredictable. And nobody in the hype cycle is talking about it.

Now you know. Previous posts in this series:

• What is Clawdbot? Do You Need It?
• Clawdbot (OpenClaw): Complete Setup Guide + Security Concerns