Aider pricing: the free CLI, the API bill, and the cheapest route

Aider, the open-source terminal coding assistant, costs $0. It is Apache-2.0 software, and aider.chat advertises no plans, no tiers, no seats and no hosted service, so "Aider pricing" in practice means the model API bill you run through it. The number worth budgeting is tokens per session at your provider's rate — and the setting most likely to inflate it is Aider's own default for a model id it does not recognize, which is a two-line fix covered below.

One disambiguation first, because the search results mix them. A different company, in accounting software, also trades as Aider and publishes a monthly minimum for period-close automation. Those prices belong to that product. This page is only about the CLI at aider.chat, distributed as the aider-chat package from the Aider-AI/aider repository.

What Aider charges, and what actually bills you

Aider's FAQ states plainly that the company behind it publishes the tool as open source under Apache 2.0, and no price, plan or subscription text appears on the homepage, the FAQ, the install page or the LLM connection pages (all checked September 18, 2026). The bill sits entirely on the other side of the endpoint.

Check the release cadence before you standardize a team on it. The repository is not archived and carries 49,040 stars — aider.chat's own homepage badge still reads 44K, so read the API rather than the page. The last commit to main is dated May 22, 2026, and there are 1,378 open issues and 500 open pull requests (GitHub API, September 18, 2026). The two official views of "latest release" also disagree: PyPI serves 0.86.2, uploaded February 12, 2026, while GitHub Releases stops at v0.86.0 from August 9, 2025. Trust PyPI for what pip install gives you, and confirm in your own environment. Work merged since then sits on main as 0.86.3.dev (aider/__init__.py) and is in no installable release.

One more inconsistency to settle in your own environment before you install: Aider's install page advertises Python 3.8–3.13 for its bootstrap installer and 3.9–3.12 for pip and pipx, while the 0.86.2 package metadata on PyPI declares >=3.10,<3.13. The package metadata is what pip actually enforces, so check your interpreter against that rather than the prose.

The setting that moves your Aider API cost most

Aider's own homepage still says it works best with Claude 3.7 Sonnet, DeepSeek R1 and V3, and OpenAI o1, o3-mini and GPT-4o, and its LLM page names a similar mid-2025 set. That advice is dated, and following it literally in 2026 is not the recommendation here — but the dates matter for a reason beyond model choice.

This is the part the price tables miss. Aider chooses its edit format, repo map and caching behavior by matching the model id against a built-in table, and the id that reaches that table is the prefixed string you type after --model. Its published defaults for anything it does not match are edit_format: whole, use_repo_map: false, cache_control: false and weak_model_name: null, per the advanced model settings page.

In the released 0.86.2 source that lookup runs in two steps, and the distinction decides whether any of this applies to you. First Aider compares the id you passed against a shipped table of 313 entries keyed by fully qualified name — the whole string, prefix included, so gemini/gemini-3-pro-preview and openai/gpt-5.2 are both in there and both match exactly. Only if nothing matches does it fall back to substring rules, which among others catch sonnet-4-5, opus-4-6, haiku-4-5, 3-7-sonnet, 3-5-sonnet, gpt-4, gpt-4.1, an exact gpt-5 last segment, the o1 and o3-mini ids, DeepSeek V3 and R1, Llama-3 70B and a handful of Qwen ids.

The catch for a custom endpoint is the prefix. Reaching one means passing the id as openai/<id>, and the 40 openai/-prefixed rows in that table are all OpenAI's own model names. So openai/claude-sonnet-4-6 matches no row in the table and no substring rule either, and the command Kunavo's own setup page prints — aider --model openai/claude-sonnet-4-6 — runs whole-file edits with the repo map off. Whole-file means the model re-emits every edited file in full on each turn, and output tokens are the expensive side of the bill. Check your own id against both steps rather than assuming either outcome: a Gemini 3 id, for instance, has exact entries under Aider's gemini/ and openrouter/ prefixes and none under openai/.

Two lines fix it. Aider reads this file from your home directory, the git root or the current directory, keyed by the same fully qualified name you pass to --model.

# The name must match the string you pass to --model, prefix included.
- name: openai/claude-sonnet-4-6
  edit_format: diff
  use_repo_map: true

A one-off run can use --edit-format diff instead. There is also a quirk worth knowing: because that second-step match is a substring, openai/claude-haiku-4-5 does match on haiku-4-5 and gets the diff format and repo map automatically, while the Sonnet 4.6 id does not. That is an accident of naming, not a property of the provider, and it can change in any Aider release — re-check rather than rely on it.

There is a second, quieter effect. Aider bills three model roles: the main model, an editor model used by --architect mode, and a weak model used for commit messages and chat-history summarization (see the options reference). When the id is unrecognized, the released source sets both the weak model and the editor model to the main model itself. All three roles then bill at your most expensive rate. Aider's own modes documentation already warns that architect mode "uses two LLM requests, which can take longer and increase costs"; with an unrecognized id, both of those requests are the expensive one. Aider documents --weak-model, and the released source builds that model through the same constructor as the main one, so the same openai/ prefix applies and a cheap id can be named there explicitly.

Finally, an unrecognized id also silences the cost readout. In the released source, if the model has no input_cost_per_token entry, Aider prints token counts and returns before the cost line — it shows nothing, not $0.00 — and the warnings page confirms it will "assume the model is free". Restore it with a metadata file:

{
  "openai/claude-sonnet-4-6": {
    "input_cost_per_token": 0.0000012000,
    "output_cost_per_token": 0.0000060000,
    "litellm_provider": "openai",
    "mode": "chat"
  }
}

Add max_input_tokens too if you want the context warning to be accurate; Aider's token limits page states that it never enforces token limits and only reports the provider's token-limit errors. Even with metadata supplied, Aider's dollar figure is its own arithmetic over reported tokens — the released code hard-codes one vendor's cache multipliers — so treat it as a running estimate and reconcile against your provider's ledger.

A worked Aider API cost estimate

These are token arithmetic, not measured task costs and not a bill ceiling. Assume one session that sends 200,000 uncached input tokens and receives 12,000 output tokens under diff. For the whole-file column, assume the same session emits 40,000 output tokens because edited files are re-sent in full — that ratio is an assumption for illustration, not a measurement. Rates are live Kunavo catalog prices per million tokens.

Two readings. First, under these assumptions the edit format alone moves Claude Sonnet 4.6 from $0.312 to $0.480 for the same work, which is why the configuration section comes before this one: comparing provider rates before fixing the edit format compares the wrong thing. Second, the commit-message and summarization traffic that collapses onto the main model is not free either: an assumed 30,000 input and 2,000 output tokens of it costs $0.048 on Claude Sonnet 4.6 against $0.016 if you name Claude Haiku 4.5 as the weak model.

Scale these by your own sessions per day before treating them as a budget. Kunavo's catalog amount is a billing floor rather than a cap: when the upstream reports its charge, the bill is the greater of catalog cost and upstream cost times the applicable markup. Cache charges and external tools sit outside this example. The minimum Kunavo top-up is $10 in prepaid credit, which is a funding minimum, not a task fee or a subscription — see billing details.

Cheapest API for Aider: two different questions

Aider publishes the only re-checkable task-cost anchor this tool has: its polyglot benchmark runs the same 225 Exercism exercises across six languages and records a dollar cost per model. Those runs separate "cheapest rate" from "cheapest to finish" better than any price table can.

Read from the leaderboard data file on September 18, 2026. Two caveats that matter more than the ranking. The newest row in that file is dated October 3, 2025, so nothing released since has ever been benchmarked here, and the page footer's later "last updated" stamp reflects the file's edit time rather than a newer run. And the leaderboard states no price list or date for its Cost column, so each figure is what that run cost on its run date, not a quote you can buy today. These models are named as benchmark evidence; DeepSeek in particular is not in Kunavo's catalog, and the cheap-lane equivalents on the table above are Claude Haiku 4.5 and Gemini 3.8 Flash.

The usable rule: o3-pro cost five times gpt-5 (high) and scored lower, so a high rate does not buy completion, and a low rate does not guarantee the lowest total either — a cheap model that needs three attempts can cost more than one that needs one. Shortlist the least expensive model that finishes your work with review effort you accept, then verify against the usage your provider account actually recorded for that task. Aider's /tokens is not that number: its own command reference defines it as a report on the tokens used by the current chat context, so it sizes the next request rather than totalling the requests and retries already billed. For a longer treatment of that method see AI cost optimization.

Best API for Aider: which route wins when

Two practical boundaries for the gateway route. For a gateway Aider has no provider module for, the documented path is the OpenAI-compatible one: OPENAI_API_BASE, OPENAI_API_KEY and a mandatory openai/ prefix on the model id, per the OpenAI-compatible APIs page. That is not the only third-party route Aider documents — OpenRouter has its own page, its own OPENROUTER_API_KEY and an openrouter/ prefix, which is why its ids behave differently from the generic compatible path. OPENAI_API_BASE is also the only base-URL override Aider documents: there is no --anthropic-api-base switch, and the string ANTHROPIC_API_BASE appears nowhere in the 0.86.2 tree. So the documented way to reach a gateway is a chat-completions one. Aider does ship a general --set-env ENV_VAR=value switch for controlling API settings, so read this as the absence of a documented Messages-protocol route rather than as a demonstrated block. And do not budget for prompt-cache savings on this path: Aider's prompt caching page names the specific vendor families it caches for, requires the opt-in --cache-prompts switch, and says cache statistics and costs are unavailable while streaming. Whether cache blocks survive the compatible path to any gateway is not something this page tested. Prompt caching covers what the rates look like when a route does support it.

OpenRouter is the incumbent gateway here and Aider documents it natively on its OpenRouter page, including provider-routing controls; compare it on rate and on funding terms rather than on integration depth. See OpenRouter alternatives and OpenAI-compatible API for that comparison, and cheapest Claude API if Claude is the family you have settled on.

Set it up and check the first bill

Kunavo publishes a setup guide for this client. That is a published configuration reference, not a compatibility test: Aider has not been runtime-tested here against Kunavo's endpoint, and everything above was read from Aider's released source and its own documentation. Keep a working route available while you try it, run one bounded task, then read the charge your account recorded for it. Do not reconcile with /tokens — it reports the size of the current chat context, not what the session has spent — and note that with an id Aider does not recognize it prints no cost line either, which is the second reason the settings file above is worth writing. Start at the Aider integration guide, and create a Kunavo account when you are ready to fund a key.

Comparing clients rather than providers? Cline pricing and OpenCode pricing cover two agents with the same separation between a free client and a metered API bill.

FAQ

Aider repository, package, documentation and leaderboard data checked September 18, 2026; behavior claims read at released tag v0.86.2. Kunavo token rates come from the live catalog, and every dollar example on this page is illustrative token arithmetic rather than a measured task cost.