Which OpenClaw features cost money and which ones are completely free

You set up OpenClaw, started using it, and now you are watching API costs creep up without a clear picture of what is actually being charged and what runs for free. This article maps every OpenClaw feature to its cost. Some OpenClaw free features run at zero cost regardless of usage. Others make API calls every time they fire. Knowing which is which lets you use the platform without surprises on your bill.

Reading time: 10 minutes. No API calls required to read this.

Features that are always free

These features make no API calls. They run entirely on the server and cost nothing regardless of how often you use them.

The gateway is the web server that runs OpenClaw and routes messages between your channels and your agent. Running the gateway, restarting it, checking its status, reading its logs, and changing its config all cost nothing. The gateway is infrastructure, not an API consumer.

Receiving messages from Discord, Telegram, Signal, and other configured channels is free. OpenClaw listens for incoming messages via webhooks or polling. No API call is made when a message arrives. The cost starts when OpenClaw sends that message to the language model for processing.

Reading files, writing files, listing directory contents, and git operations in your workspace are all free. These are local disk operations. The read, write, and edit tools do not make API calls when they access your filesystem.

The cron scheduler itself is free. Setting up a cron job, editing its schedule, disabling it, or checking its status costs nothing. What costs money is the payload the cron job executes: if the cron job runs an agent turn (a systemEvent or agentTurn payload), that turn calls the language model. The scheduling engine that fires it does not.

If you have Ollama installed and configured, every request routed to an Ollama model is completely free. Ollama runs locally on your machine. There are no tokens, no usage limits, no API keys, and no billing. The only cost is electricity and compute time on your hardware. This is the most important free feature in OpenClaw: it means you can run heartbeats, cron jobs, drafts, summaries, and status checks for zero dollars if you route them to a local model.

Show me all models configured in my openclaw.json. For each model, tell me whether it is a local Ollama model or a paid API provider. Then show me which tasks are currently routed to each model: primary conversation, fallback chain, heartbeat, cron jobs, and memory extraction.

Storing conversation history, reading past sessions, and archiving session files are all free. OpenClaw stores session data as local files (JSONL format). Reading those files does not make API calls. The LCM (Lossless Context Management) database is a local SQLite file. Queries against it are local operations.

Running openclaw status, checking the dashboard, listing plugins, reading config, and all CLI operations are free. These are local commands that interact with the gateway process. They do not call any external API.

Installing skills, loading SKILL.md files, and executing skill logic that does not call a model are free. Skills are files on disk. Loading them costs nothing. If a skill makes an API call (web search, image generation, transcription), that specific API call has its own cost, separate from OpenClaw.

Reading your openclaw.json config, checking the gateway health endpoint, and querying the OpenClaw status are all local operations. They touch no external API. The same is true for listing installed plugins, checking plugin versions, and reading plugin config. These are filesystem and process operations. Use them freely without any billing concern.

Git commits, pushes, pulls, and diffs in your workspace are local or network file operations. They do not go through any language model. If you have automated git commits in your workflow (committing workspace files at the end of each session), those commits cost nothing regardless of frequency. The only exception would be if you configured an agent turn to write a commit message, which would call the model to generate the message text.

Pairing a mobile node (Android or iOS), receiving notifications, and checking node status are all free. The node infrastructure is a network connection between your device and the gateway. No language model is involved in pairing, node status checks, or push notification delivery. A model is called only when the node sends a message that the agent processes.

Opening a browser, taking a screenshot, and navigating to a URL are local browser control operations. They do not call a language model. The cost starts when you send a screenshot to the model for analysis, or when the agent uses a model to decide the next action in an automation sequence. Pure browser navigation without model involvement is free.

Features that always cost money

These features make API calls every time they run. They cannot be made free without disabling them or routing them to a local Ollama model.

Each time you send a message and the agent responds, OpenClaw sends the full conversation context (system prompt plus message history) to the configured language model. You pay for every token sent and received. Longer system prompts, longer conversation history, and more complex responses all increase the token cost per turn.

The system prompt is included with every turn. If your AGENTS.md, SOUL.md, and injected memories total 8,000 tokens, that is 8,000 tokens of overhead on every single message you send, before the message itself is counted.

Estimate the total token count of my current system prompt including all injected workspace files and memories. Then tell me the approximate cost per conversation turn at current pricing for my primary model, assuming a 500-token user message and a 1,000-token response.

When the agent uses a tool (runs a command, reads a file, searches the web), it sends an additional request to the model to process the tool result and decide what to do next. Each tool call in a turn adds at least one extra model request. A turn with three tool calls is a minimum of four model requests total: the initial response, plus one per tool result.

When a session reaches the configured compaction threshold, OpenClaw summarizes the conversation history using the language model. This is a paid operation. A typical compaction on a long session can cost 10 to 30 cents depending on context length and the model used for compaction. If your sessions are long and compaction fires frequently, this is a meaningful cost to monitor.

Show me my current compaction settings: at what context percentage does compaction fire, and which model is used for compaction? Estimate how often compaction fires in a typical session based on my average session length and message count. What is the approximate cost per compaction event at current model pricing?

If the memory plugin (memory-lancedb or similar) is configured with automatic extraction, it calls the language model after a set number of turns to extract and store key facts from the conversation. Each extraction call processes the recent conversation history and sends it to the model. With extractMinMessages: 1, this fires after every single turn, effectively doubling your per-turn API cost.

If you use a cloud embedding provider (OpenAI text-embedding models, Jina, or similar) for memory storage, generating embeddings costs money. Each memory stored generates an embedding API call. If you use Ollama’s local embedding models (nomic-embed-text is free with Ollama), embeddings cost nothing. This is one of the easiest costs to eliminate by switching to a local embedding model.

When the agent uses a tool and then needs to act on the result, each step in that chain is a separate model call. A task like “research this topic, summarize the findings, and write a report” involves: a planning call to decide which tools to use, one or more search tool calls with model calls to process results, a synthesis call to combine findings, and a writing call to produce the report. What looks like one task is 5 to 10 model calls. This is why complex research tasks cost significantly more than they appear to at first glance.

For the last 5 complex tasks I ran (tasks with more than 3 tool calls), estimate the total token cost including all intermediate tool call steps. Break it down per task. Compare this to what the cost would have been if I had only paid for the first and last model call.

Sending a message to Discord, Telegram, or any other channel is a free outbound network call. But the model turn that generated the message content costs money. The channel delivery itself is free; the language model processing that produced the content is not. This distinction matters when you are budgeting cron jobs that deliver summaries or briefs: the delivery is free, the generation is not.

Features that cost money only when configured to

These features are free in their default or minimal configuration but cost money if you enable certain options.

The heartbeat system pings the agent on a regular interval to run background tasks. A heartbeat costs nothing if it calls a local Ollama model or if the agent returns HEARTBEAT_OK without processing (when HEARTBEAT.md is empty or has no pending tasks). It costs money if it is routed to a paid API model and the model processes a non-trivial response.

A heartbeat every 5 minutes routed to Claude Sonnet is 288 paid API calls per day, even if every single one returns nothing useful. The same heartbeat routed to ollama/llama3.1:8b costs zero dollars per day.

What is my current heartbeat interval and model? If the heartbeat is routed to a paid API model, estimate the daily and monthly cost assuming the heartbeat fires at the configured interval and returns a minimal response each time.

A cron job itself is free: it is just a scheduled timer. The payload it executes determines the cost. A cron job that runs a systemEvent payload fires an agent turn on the main session, which costs money. A cron job that runs an agentTurn payload in an isolated session also costs money. A cron job that triggers a webhook to a free external service costs nothing.

The model used in the cron payload matters. A daily morning brief running on Claude Sonnet costs 30 to 50 API calls worth of tokens per day. The same brief running on ollama/phi4:latest costs zero.

The pdf and image tools send document or image content to the language model for analysis. The cost depends on the model’s pricing for visual content. Claude Sonnet charges for image tokens at a different rate than text tokens. Sending a large PDF for analysis on a frontier vision model is a meaningfully expensive operation. If you have automation that processes images or PDFs regularly, route it to a cheaper model or batch the processing to reduce per-document overhead.

The Whisper API skill (or any transcription integration) costs money per minute of audio transcribed. This is charged by the transcription provider (OpenAI, for Whisper) separately from the language model cost. If you transcribe audio regularly through OpenClaw, that API cost accumulates independently of your conversation costs.

Skills like deep-research (using Gemini’s grounding API) and Tavily search charge per query at the skill provider’s rates. These costs are separate from both OpenClaw and your primary language model. A deep research query that runs 5 web searches has a search API cost plus a model cost for processing the results. Check the skill’s documentation for its provider’s pricing before using it in automated workflows.

The web_search tool costs money if the search provider charges per query (Brave Search API, Tavily, Perplexity). Some search integrations use free tiers that cover typical usage. Others charge per request. The search itself is separate from the model cost: you pay the search provider for the query, then pay the model provider to process the results.

Tools that call external APIs (image generation, speech-to-text, weather services, custom webhooks) have their own costs separate from OpenClaw and separate from the language model. OpenClaw acts as an orchestrator. If you call the OpenAI image generation API through OpenClaw, you pay OpenAI for the image generation. OpenClaw does not charge anything on top.

If you use the pro memory plugin with a cloud reranker (Jina reranker-v3, Cohere rerank), each memory recall query runs a reranking API call. With autoRecall: true, this fires on every conversation turn. At Jina’s pricing, 1,000 reranking calls is a small cost, but at high query volumes it accumulates. Switching to a local reranker eliminates this cost entirely.

Background features that silently cost money

These are the features most operators discover only after the bill arrives. They run without user interaction and generate API costs continuously throughout the day.

With autoRecall: true, the memory plugin queries the memory database and injects relevant memories into the system prompt on every turn. If a cloud embedding model is used for the recall query, each turn generates an embedding API call. The injection itself is free (it is just text added to the prompt), but the query that selects which memories to inject costs money if it uses a cloud embedding provider.

With autoCapture: true, the memory plugin runs an extraction pass after every N turns (set by extractMinMessages). The extraction sends recent conversation history to the language model and asks it to identify facts worth storing. At extractMinMessages: 1, this is one additional model call per conversation turn. At extractMinMessages: 10, it fires once every 10 turns, reducing the cost by 90 percent.

Show me my memory plugin configuration. What are the current values for autoRecall, autoCapture, extractMinMessages, and the model used for extraction? If autoCapture is on and extractMinMessages is below 5, estimate the additional cost per day this adds to my API bill at my typical conversation volume.

If you have a cron job that archives session files on a tight interval, the cron overhead is free. However, if the archive cron job also triggers any agent processing (summarizing the session, updating a memory file, sending a status message), those downstream operations cost money. A pure file-copy archive cron with no agent involvement is completely free.

Any cron job that asks the agent to summarize, research, or compose something is a paid operation. A daily morning brief that reads news, summarizes recent activity, and sends a Telegram message runs multiple model turns. Depending on how it is configured, a morning brief cron job on Claude Sonnet costs between $0.05 and $0.50 per day. Over a month, that is $1.50 to $15 in background activity before you have had a single conversation.

Making more features free with local models

The fastest path to reducing OpenClaw costs is moving background tasks from paid API models to local Ollama models. The principle is simple: use the most capable (and expensive) model for the tasks that require it, and use the cheapest (or free) model for everything else.

Tasks that work well on local models:

• Heartbeats. ollama/llama3.1:8b can check HEARTBEAT.md, confirm nothing needs attention, and return HEARTBEAT_OK. Costs zero dollars.
• Status cron jobs. Checking disk usage, confirming services are running, or reading a daily log file is within llama3.1:8b capability.
• Memory extraction. phi4:latest (14B parameter model) handles extraction reliably. You lose nothing in extraction quality while eliminating the extraction API cost entirely.
• Draft generation. Writing a first draft of a document, email, or outline before passing to a frontier model for polish. The frontier model sees a much shorter task (editing the draft) instead of a much longer one (writing from scratch), reducing token cost significantly.
• File indexing and organization. Summarizing directory contents, creating indexes, and categorizing files are well within local model capability.
• Simple Q&A from known context. Answering questions where the answer is already in the workspace files. A local model can find the answer in the file and return it accurately for straightforward lookups.

List every automated task currently running: cron jobs, heartbeats, memory extraction, and session archiving. For each one, tell me whether it is currently using a paid API model and whether the task is simple enough to run on a free local model. For any task that is a good candidate for local execution, show me the exact config change needed to move it. Do not apply any changes yet.

Estimating your OpenClaw API cost before you hit the bill

Most operators underestimate their OpenClaw costs because they think about interactive usage and forget about background automation. The right way to estimate your monthly cost is to add up three categories separately: interactive conversations, background automation, and one-off large tasks.

Estimate your average conversation turns per day. Multiply by your system prompt size plus average message length. That gives you input tokens per turn. Add the average response length for output tokens. Multiply by your provider’s pricing. This is your baseline daily conversation cost.

Example: 20 turns per day, 9,000-token system prompt, 300-token average message, 800-token average response. That is 9,300 input tokens and 800 output tokens per turn, times 20 turns. At DeepSeek Chat pricing (~$0.27 per million input, $1.10 per million output), 20 turns costs roughly $0.07 per day in conversation alone.

This is the part most operators miss. List every automated task and its frequency. A heartbeat every 5 minutes is 288 events per day. Memory extraction on every 5 turns at 20 turns per day is 4 extraction calls per day. A morning brief cron is 1 per day. Each of these has a per-call token cost. Add them up.

Calculate my estimated monthly API cost. List every event that calls a language model: conversation turns (estimate 20 per day), heartbeats (at configured interval), cron jobs (at configured schedules), and memory extraction (at configured extractMinMessages). For each one, estimate the tokens per call and the daily call count. Multiply by the pricing for my primary model. Give me a total estimated monthly cost broken down by category.

Long research sessions, document processing, and pipeline tasks with many tool calls are much more expensive per session than regular conversations. A single research session with 50 turns and multiple web search results processed can cost as much as a week of normal conversation. Budget for these separately.

A useful rule of thumb: any task where you expect the agent to use more than 5 tool calls is a “large task” for budgeting purposes. Before starting, ask the agent to estimate the approximate number of turns and tool calls the task will require. Multiply by your average per-turn cost. If the estimate is above your comfort threshold, consider breaking the task into smaller chunks, routing it to a cheaper model, or running it during a time when your rate limits have reset and you have full daily quota available.

Before starting this task, estimate the number of tool calls and model turns it will require. Based on my primary model pricing, what is the estimated token cost? Flag it if the estimate is above $0.25 so I can decide whether to proceed or route it to a cheaper model.

The most reliable way to know what you are spending is to check your provider dashboards weekly until you have a stable baseline. Most operators go through three phases:

Phase 1 (first two weeks): Check the provider dashboard daily. You are learning where the cost actually goes. You will find background tasks you forgot about and usage patterns you did not anticipate.

Phase 2 (weeks 3 through 6): After auditing and optimizing background tasks, check weekly. Your costs should be lower and more predictable now.

Phase 3 (ongoing): Set a monthly spend alert in your provider account. Check only when the alert fires or when you add new automation. Your costs are now stable and you have built the intuition for what things cost.

Check my provider dashboard for API usage in the last 7 days. Which model generated the most tokens? What time of day is my peak usage? Is my usage consistent across days or are there spikes? If there are spikes, what was running at those times based on the gateway logs?

Questions people actually ask about this

No. OpenClaw is open source software licensed under MIT. You install it, run it on your own server, and pay nothing to OpenClaw or any OpenClaw entity. Your costs come entirely from the API providers you configure: Anthropic, DeepSeek, Groq, OpenRouter, and so on. If you run exclusively on local Ollama models, your OpenClaw operating cost is zero dollars per month in API fees.

Almost certainly background automation. Heartbeats, cron jobs, and memory extraction run continuously regardless of whether you are actively using the agent. They were configured once and have been billing you silently ever since. A heartbeat every 5 minutes on a paid API model generates 288 API calls per day. If you set it up and forgot about it, it has been billing you since day one. Run the background task audit above to find out what is running and what it costs.

The LCM database and storage are free. Compaction, which uses a language model to summarize context, is not free. Every time compaction fires it calls the model. The compaction model is configurable separately from the primary model. Running compaction on a cheaper or local model reduces but does not eliminate the cost. The LCM database reads and writes are local operations and cost nothing.

It depends on your embedding setup. If you use a cloud embedding model (OpenAI, Jina) to generate query embeddings for recall, each recall query generates an embedding API call. If you use a local Ollama embedding model (nomic-embed-text), recall queries are free. The reranking step, if you have a cloud reranker configured, also costs per query. Local reranking is free.

OpenClaw has no plans. It is open source software. “More free features” means routing more of your workload to local Ollama models. The more tasks you move to Ollama, the lower your API bill. The ceiling is running everything on local models, which costs zero in API fees. The floor in quality is whatever your local hardware can run. Most operators find a 7B or 14B parameter model handles 80 percent of tasks acceptably, reserving the frontier API model for the 20 percent of tasks where quality or tool use reliability actually matters. Most operators find a combination of local models for background tasks and one API provider for interactive conversation to be the right balance.

Yes, if you have a machine capable of running Ollama with reasonably capable models. Route everything (conversation, heartbeats, cron jobs, memory extraction) to Ollama models. You pay nothing in API fees. The quality of responses is lower than frontier models, and tool use reliability is lower on 7B to 14B parameter models compared to Claude or GPT-4 class models, but the agent is functional and the cost is zero. Many operators run local-only for low-stakes tasks and switch to an API model only when they need the extra capability.

As of early 2026, DeepSeek Chat (deepseek/deepseek-chat) offers the best combination of capability and cost for general OpenClaw use. At approximately $0.27 per million input tokens and $1.10 per million output tokens, it is roughly 10 times cheaper than Claude Sonnet for most workloads while maintaining strong tool use and instruction following. DeepSeek Chat is the default recommendation for cost-conscious OpenClaw operators who need a paid API model.

Go deeper