Nanocoder pricing: the free CLI, the model bill, and the cost footer

Nanocoder is free: the CLI is MIT-licensed, has no account, no tier and no license key, so "Nanocoder pricing" in practice means the model bill behind it — tokens at whatever provider you configure, or hardware and electricity for a local model. The number in your terminal is not that bill. Nanocoder prices every response from a third-party database that has no entry for your gateway, and this page reproduces exactly what that does to the figure.

One disambiguation first, because the search results mix several things. This page is about Nano-Collective/nanocoder, published as @nanocollective/nanocoder and documented at docs.nanocollective.org/nanocoder. Note the trailing r. A separate project called nanocode — a coding agent for NanoGPT — plus NanoGPT itself, which sells tokens and publishes a real price list at both nano-gpt.com and nanogpt.net, and a Polish software house trading as Nanocoder all rank for these queries. None of their prices belongs on this page.

What Nanocoder charges, and what actually bills you

Installation is free on every documented path and asks for no account: npm install -g @nanocollective/nanocoder, or Homebrew, or Nix. The npm registry gives 1.30.0 as latest, published August 26, 2026, with engines.node >= 22 and "license": "MIT" (registry read September 21, 2026 — no newer release had shipped by then).

The project is funded by donations and sponsorship rather than by users, and one disclosure belongs here because it shapes advice you will read elsewhere: Atlas Cloud is a listed sponsor in Nanocoder's own README, which also links its "coding plan promotion" for "more budget-friendly API access". That recommendation sits inside a document the sponsor helps fund, and it is not evidence that the plan is cheapest. Those coding plans are monthly subscriptions with a weekly points allowance, and points are consumed as input tokens times an input multiplier plus output tokens times an output multiplier, with the multipliers set per model — so what one costs per million tokens depends on which model you run, and it is not a single number you can put next to a rate card.

The cost figure in your terminal is not your bill

Version 1.30.0 added a footer under every assistant message reading, for example, Tokens: 4.2k | ~$0.01. It is the most useful-looking number on the screen and the easiest one to misread, because Nanocoder never asks your provider what it charges.

Here is the mechanism, read in the released source at tag v1.30.0. Pricing comes from models.dev/api.json. The lookup takes your model id and, in its own comment, searches "through all providers, picking the match with highest context limit" — so the provider you configured is never consulted, only the id string. When that file was fetched on September 21, 2026 it listed 223 providers and no entry for Kunavo. A Kunavo-served id therefore resolves to whichever unrelated entry happens to carry the same string and declares the largest context window.

Replaying that exact algorithm against that file, for one assumed session of 200,000 input tokens and 15,000 output tokens, gives the gap below. The catalog estimate is Kunavo catalog arithmetic; the last column is what Nanocoder's footer would total for the same tokens.

Two different failures, both from one lookup. Where the winning entry publishes a higher rate, the footer overstates. Where it publishes zeroes, or no cost block at all, the footer shows nothing — and an absent cost reads as free. That last step is deliberate in the shipped code: a missing cost block is coerced to a zero rate rather than to "unknown", and the formatter in the published package returns nothing for a cost of zero or less so that "free/local models should show no cost segment rather than '$0.00'". The logic is correct for a local model and wrong for a paid one whose id collides with a zero-priced directory entry.

Two more distortions on top. models.dev publishes long-context price tiers for some entries; the released client copies only the flat input and output rates out of each entry and never reads the tiers, so a turn past a tier threshold is understated. And version 1.30.0's own changelog states that the estimate "prices all input tokens at the standard rate — cache read/write discounts are not factored in, so costs can be overstated for providers with prompt caching". See prompt caching for what those discounts look like when a route supports them.

The rates in that table are a snapshot: models.dev is edited continuously, and the entry that wins the highest-context tie-break can change without anything on your machine changing. The reproduction is short — fetch api.json, find every provider carrying your exact model id, keep the one with the largest limit.context, and read its cost block. Your provider's own ledger is the authoritative number; see billing details.

What is shipped, and what is only on the development branch

This distinction decides whether several of the fixes people cite actually exist on your machine. Both /latest/ and /v1.30.0/ on the documentation site served v1.30.0 content when checked on September 21, 2026; the repository's docs/ folder on main is ahead of both.

Each "No" above was checked by grepping the published page rather than inferred, and the Anthropic provider page is the sanity check: zero hits for "Prompt caching" and "cache-aware", while the same HTML contains sdkProvider six times. These are true absences, not a rendering artifact. Work landed on main after the August 26 release adds all of them — so a citation to a file on main describes software you cannot install yet, and a newer release would move several of these rows.

Best model for Nanocoder: a capability question, not a ranking

Nanocoder publishes no recommended model, no leaderboard and no hardware specification. A full read of its documentation on September 21, 2026 turned up no minimum RAM, no VRAM figure and no recommended GPU, and the repository's benchmarks/ directory is a quality report on the built CLI — exit codes, module counts, approximate boot and first-render times, bundle size — rather than anything that scores a model. No task benchmark has been run here either, so this page prints no ranking — a leaderboard assembled from nothing is worse than none.

What the vendor does publish is better suited to a budget page anyway, because it changes what the model can do rather than what it scores. The default auto tool profile, per the v1.30.0 tune documentation, "keeps the full tool surface for cloud models and model ids with no size hint, resolves models up to 15B parameters to minimal, and resolves models up to 4B parameters to nano".

Two practical readings. First, the documentation is explicit that "MCP tools are only exposed in the resolved full profile" — so connecting an MCP server to a small local model does nothing until you switch the profile by hand or move to a larger model. Second, the bundled "Nano (low-end hardware)" preset caps max tokens at 2048, which is a real ceiling on reply length rather than a hint. Nanocoder's own battlemap argues that small and older models remain usable because it ships three tool-calling paths — native function calling, an XML fallback and a JSON fallback, with repair on both fallbacks — but that is the maintainer's claim and it publishes no success rate. For a broader view of model trade-offs see the coding model comparison.

Local versus remote: two different budgets

A local-first user is not a paid-API buyer with a smaller bill, and treating them as one produces bad advice in both directions. Nanocoder's own battlemap states that "if you are running Nanocoder against a local model, the entire loop can run with zero outbound network traffic", and that seven local servers — Ollama, llama.cpp, llama-swap, LM Studio, LocalAI, MLX Server and vLLM — are documented as first-class providers. That is the project's positioning claim, not a measurement made here.

The honest statement about local cost is that nobody has published one. Nanocoder quantifies no hardware requirement, so the capital and electricity are yours to price. Two behaviours make the gap visible rather than hidden: the cost segment is omitted for local and free models, and in headless runs the usage block is "omitted entirely when the provider reports no token telemetry (common with local models), so an absent block means 'unknown', never 'zero'".

One trap on the way in. Ollama's pricing page states that "Running models on your own hardware is always unlimited", and Nanocoder's Ollama provider documentation covers only the local endpoint, with no key required. But that same page also sells hosted plans — Pro at $20 a month with $60 of monthly usage credits, Max at $100 with $300, Team at $500 with $1,000 shared, and a custom Enterprise tier (checked September 21, 2026). So "Ollama is free" is true of the local path and false of the hosted one. Kunavo's Ollama-compatible endpoint documentation covers the shape of that API if you are moving between the two.

One caution on gateway funding fees, because it is the line people miss. OpenRouter's FAQ states that "there is no markup on inference pricing" and that it charges a fee "when you purchase credits" instead, with a further fee on bring-your-own-key usage above a plan-dependent allowance. Those percentages vary by payment method and plan and are filled into that page when it renders, so none is quoted here — read the current figure at your own checkout. OpenRouter alternatives and OpenAI-compatible API cover the comparison more generally.

Budgeting the token side

The catalog column in the table above is the estimate to budget from, and it is illustrative token arithmetic rather than a measured task cost or a bill ceiling. Its assumptions are one session of 200,000 uncached input tokens and 15,000 output tokens at live catalog rates, with no cache reads and no tool charges. Real sessions differ with repository size, how often the agent re-reads files, and how much tool output lands back in context — and the tool profile above changes the per-turn overhead before any of that.

Scale it by your own sessions per day before treating it as a budget. On these assumptions Claude Haiku 4.5 models about 90 sessions per $10 of credit and Claude Opus 5 about 18, which sizes a wallet without telling you which finishes your work. Cheapest listed rate and lowest cost to finish are different claims: a cheaper model that needs three attempts can cost more than one that needs a single pass. AI cost optimization covers that method properly.

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 top-up is $10 in prepaid credit — a funding minimum, not a task fee and not a subscription.

Pointing Nanocoder at a custom endpoint

Any OpenAI-compatible service is added as a custom provider, either interactively through /settings providers or in agents.config.json — the project file first, then a per-OS user config directory, with NANOCODER_CONFIG_DIR skipping both lookups and the NANOCODER_PROVIDERS environment variable taking highest precedence of all.

{
  "nanocoder": {
    "providers": [
      {
        "name": "Kunavo",
        "baseUrl": "https://api.kunavo.com/v1",
        "apiKey": "${KUNAVO_API_KEY}",
        "models": ["claude-sonnet-4-6"],
        "contextWindow": 1000000
      }
    ]
  }
}

Three notes on that block, all from the v1.30.0 provider documentation. sdkProvider is omitted because it defaults to openai-compatible; the other values in that version's sdkProvider options table are google, anthropic and github-copilot, and chatgpt-codex is documented on its own provider page rather than in that table. Keys and other config values support $VAR, ${VAR} and ${VAR:-default} substitution. And requestTimeout defaults to 120,000 ms, with -1 disabling it — which matters far more for a slow local model than for a hosted one.

The context window is the line most likely to cost you money if you leave it out. Nanocoder resolves a model's context limit in a documented six-step order: a /context-max or --context-max session override, then contextWindows[model], then contextWindow, then NANOCODER_CONTEXT_LIMIT, then models.dev metadata, then a built-in Ollama fallback map. Because Kunavo is absent from models.dev, the last two steps cannot help, so one of the first four has to be set by hand — the value above comes from this model's own Kunavo catalog entry. It matters beyond a display meter: auto-compact triggers at a percentage of the resolved context limit, defaulting to 60, so a wrong limit changes how often the agent compresses and re-sends context, and that is token spend.

One more trap before the first run. If you set sdkProvider: "anthropic" against an endpoint serving a model id the underlying SDK does not recognise as a Claude model, it falls back to a 4096-token output ceiling, truncating long replies mid-sentence with no error. That is described under "Output Token Ceiling" in the provider documentation on main, and the ceiling itself comes from @ai-sdk/anthropic, which v1.30.0 already depends on — so the behaviour is on the released version even though the documentation is not. The fix that page names, maxOutputTokens, is also unreleased; on v1.30.0 the escape is to stay on the default openai-compatible path instead.

Kunavo publishes a Nanocoder setup guide, and that is a configuration reference rather than a compatibility test: Nanocoder has not been runtime-tested against Kunavo's endpoint, so streaming, tool calls, authentication and model routing are not confirmed end to end here. Keep a working route available while you try it, run one bounded task, then read the charge your account recorded for it rather than the footer. Create a Kunavo account when you are ready to fund a key.

Comparing clients rather than routes? Nanocoder vs OpenCode sets this agent against the mainstream one, OpenCode pricing covers a client whose maintainer does sell tokens, and the agent API directory records how every client in this space handles a custom base URL.

FAQ

Checked September 21, 2026: the npm registry for the published version, engines and licence; the v1.30.0 documentation pages for providers, commands, tune and battlemap, including grep counts for the absent features; the v1.30.0 changelog and the released source for the cost formula and the models.dev lookup; the shipped package's own cost formatter; models.dev/api.json for the provider list and the rates replayed above; the @ai-sdk/anthropic version v1.30.0 depends on, for the 4096-token ceiling; Ollama's pricing page; Atlas Cloud's coding-plan page; and OpenRouter's FAQ. Search volume for this page's target queries is unmeasured in the research behind it, and the underlying search-results snapshots date from September 17, 2026. Nanocoder was not runtime-tested against Kunavo, no model benchmark was run, and every Kunavo dollar figure here is illustrative token arithmetic from the live catalog rather than a measured task cost.