How to See What Your OpenClaw AI Assistant Actually Costs Per Conversation

Habeeb Rahman — Thu, 26 Mar 2026 21:04:08 +0000

I've been running OpenClaw for a few months — it's become my daily AI assistant across WhatsApp and Telegram, handling emails, research, calendar stuff. It's genuinely great.

But at the end of month one, I opened my Anthropic billing dashboard and saw $43.

I had no idea where it came from. Which conversations? Which agent? The long research session, or just daily chit-chat? No clue.

This is a known issue in the OpenClaw community — there are open feature requests for native token tracking and a CLI usage command that haven't shipped yet. So I went looking for a workaround.

The Problem With API Billing Dashboards

The Anthropic and OpenAI dashboards show your total spend, but they're aggregated (no per-conversation breakdown), delayed (often 24+ hours behind), and only model-level (you can see "Claude Sonnet cost $31" but not which feature or session drove that).

If you're running a personal AI assistant that touches multiple models — Anthropic for complex tasks, a local Ollama model for simple ones — you have zero visibility into what's costing money vs what's free.

The Fix: One Import

burn0 is a tiny Node.js library that solves this. It patches fetch and node:http at the runtime level, so it sees every outbound API call your app makes.

npm install @burn0/burn0

Then at the top of your entry file:

import "@burn0/burn0";

Now every API call to Anthropic, OpenAI, Ollama, or any of 50+ other services gets intercepted, and you see real-time cost breakdowns in your terminal:

burn0 > $0.04 today (12 calls) -- anthropic: $0.031 | openai: $0.009

Why This Works Well With OpenClaw

OpenClaw is Node.js — burn0 slots right in.

It tracks local models too. OpenClaw supports Ollama and other local models. burn0 shows these as $0.00, so you can see the real dollar savings from routing locally vs cloud.

It reads actual token counts, not estimates. Token counts come directly from each API response's metadata — exact numbers, not guesses based on character counts.

Zero changes to OpenClaw. Works at the HTTP layer, no fork needed. When native tracking ships, remove the import.

Privacy-first. Runs entirely locally. Never reads request or response bodies — only metadata. Nothing leaves your machine.

What It Looks Like in Practice

During a typical OpenClaw session:

burn0 > anthropic/claude-sonnet  ->  $0.023  (in: 1847 / out: 312)
burn0 > anthropic/claude-haiku   ->  $0.001  (in: 423 / out: 89)
burn0 > openai/gpt-4o-mini       ->  $0.0004 (in: 156 / out: 44)
burn0 > localhost (ollama)        ->  $0.000  (in: 891 / out: 203)

The Sonnet call cost 23x more than Haiku, and the Ollama call was free. Over a week, this makes it obvious which workflows are worth routing to cheaper models.

Getting Started

npm install @burn0/burn0

Add one line to your entry point and you're done.

GitHub: burn0
Website: burn0.dev
MIT licensed, free forever, no account required

If you're running OpenClaw and curious what it's actually costing you per day, give it a try. Would love to hear what you find.

How I accidentally built a cost tracking tool for LLMs

Habeeb Rahman — Tue, 24 Mar 2026 00:13:09 +0000

Last month I got an API bill that made me physically flinch. $2,847. I had no idea where it came from.

I was building a side project — a fairly standard app with OpenAI for chat, Anthropic for summarization, Stripe for payments, Supabase for the database, and SendGrid for emails. Five services, each with their own dashboard, their own billing page, their own definition of "usage."

I found myself opening five tabs every morning just to check if something had spiked overnight. It was miserable. So I wrote a quick script to intercept outgoing API calls and log the cost next to each one. Just a console.log with a dollar amount. Nothing fancy.

But then something interesting happened. I saw that my onboarding flow was making 14 LLM calls per new user. Fourteen. I'd built a multi-step wizard where each step called GPT-4o separately, when a single call could have handled it. That one fix cut my daily OpenAI spend by 60%.

I started showing the script to friends who were building with LLMs. They all had the same reaction: "Wait, I can see the cost per request?" Turns out nobody was tracking this. Everyone just waited for the monthly bill and hoped for the best.

So I cleaned it up and turned it into burn0.

What it does

You add one line to your entry point:

import 'burn0'

That's it. burn0 auto-detects 50+ services — OpenAI, Anthropic, Stripe, Supabase, Twilio, SendGrid, and more — and tracks costs per request in your terminal. No agents to deploy, no complex setup.

Run burn0 scan to see every API service in your codebase. Run burn0 report to get a cost breakdown with model names, endpoints, and a running total. You can even attribute costs to specific features with burn0 track <feature>.

Beyond the CLI

What started as a terminal tool kept growing. You can create custom API entries for any internal or third-party service burn0 doesn't recognize yet, and monitor your production APIs' costs from a dashboard. It gives you a single pane of glass for your entire stack — LLMs, payment processors, databases, messaging services, everything — so you can finally answer "what does this user session actually cost?" in real time.

What surprised me

The tool I built for myself turned out to solve a problem almost every developer building with APIs has — especially anyone working with LLMs, where a single bad prompt template can burn through hundreds of dollars overnight.

If your API bill has ever surprised you, give it a try:

$ npx @burn0/burn0

Everything runs locally. No data leaves your machine. It's free and open source.

I'd love to hear what you find — especially the "oh no" moments when you see what a feature actually costs.

DEV Community: Habeeb Rahman