AnythingLLM pricing and API costs: the software, the tokens, and the two bills nobody publishes

AnythingLLM's software is free — the Desktop app is a $0 download and the self-hosted Docker edition is free under the project repository's MIT licence — so "AnythingLLM pricing" in practice means two bills nobody publishes: an optional hosting or licence subscription, and the model API tokens you bring yourself. The only official price list, anythingllm.com/cloud, prices hosting and says so in its own bullet: "Just bring an LLM API Key". Note that anythingllm.com/pricing is not a real page — it redirects to that same cloud page.

This guide separates the three layers: what AnythingLLM charges, what runs up the token bill, and which provider route wins for which workload. Every figure is sourced and dated, and the arithmetic is labelled as arithmetic.

Two different things are called "the AnythingLLM API"

Settle this before comparing prices, because the two have nothing to do with each other.

In AnythingLLM's own documentation, the API is the local developer and management API your instance serves at /api/docs — create workspaces, upload documents, chat with a workspace — authenticated by a key you generate inside your own instance. It has no price, because it is your server talking to itself.

The API a buyer searching "best API for AnythingLLM" almost always means is the upstream model endpoint that goes in the Base URL field of the chat provider. That one has a per-token price, and it is the only part of an AnythingLLM deployment that scales with use. Everything below is about the second one.

What AnythingLLM itself charges

Cloud prices read from anythingllm.com/cloud on September 19, 2026. Desktop Pro's numbers need a caveat: they come from the checkout screenshot AnythingLLM embeds in its own documentation, because the live Mintplex Labs checkout sits behind a bot challenge that was not bypassed. That image carries its own caveat — the price "does not reflect any promotions, eligible free trials, or coupons applied at checkout". Treat $15/$20/$180 as AnythingLLM's published figure and confirm the number in checkout before you buy.

Two traps around the word "Pro". Cloud Pro at $99 is not Desktop Pro. They are separate products, and several third-party summaries quote the hosting price as the desktop licence. And Desktop Pro is narrower than its name suggests: AnythingLLM's Pro overview states that "AnythingLLM Desktop will and forever will be free to use for 99% of our features" and that Pro "simply removes those daily limits" on Magic features. It gates no chat, no RAG, no agents and no model access. The free daily allowance for each Magic feature is described only as "generous" — no number is published, so none is quoted here. Separately, Magic Tab and Magic Beacon are macOS and Windows only; the Beacon page puts Linux as "Not currently supported".

One more disambiguation: unrelated publishers resell AnythingLLM VM images on the Microsoft and AWS marketplaces with their own hourly rates. Those listings are not published by Mintplex Labs and their prices are not AnythingLLM pricing. This page did not read their numbers — the marketplace pages returned 403 — so none appear here.

What none of those prices include

Not one AnythingLLM plan includes model tokens, and the Cloud plans are explicit about it. The Cloud limitations page states that "AnythingLLM hosted cloud does not ship with a built-in LLM you can use like in our desktop instance" — so a Cloud subscriber has to bring an external endpoint, which makes the $50 or $99 a floor rather than a total. The same page warns that the built-in embedder "will not block you from trying to embed a 5,000pg PDF, but it will crash your instance", and that custom agents are unsupported on hosted Cloud.

Desktop Pro is the same story in miniature. Its Magic Tab documentation says suggestion generation is "done on device using your configured LLM provider and model", so a Pro subscription buys no inference — it buys the removal of a daily cap on features that then spend your own token budget.

The genuine zero-token path exists and is Desktop-only: the built-in provider runs a local model using Ollama's MIT-licensed engine, marked "DESKTOP ONLY!" in the docs. If a local model answers your documents well enough, that half of the bill is $0 forever.

Where the token bill actually comes from

An AnythingLLM bill has two independent halves, billed by two separate providers you configure separately.

Intake is one-off: every document is split into chunks and embedded once. Chat is recurring: every turn resends a system prompt, the replayed history, the retrieved chunks and the question. The recurring half is the one that matters, and the shipped defaults are what size it.

Chunk size and overlap come from the text splitting documentation, which also gives the ~4 characters per token conversion used above, names LangChain's RecursiveCharacterTextSplitter as the only strategy, and warns that changes apply only to documents embedded afterwards. The other three are read from the shipped Prisma schema (topN 4, openAiHistory 20, similarityThreshold 0.25), which is authoritative. One conflict to know about: AnythingLLM's RAG page says "4-6 text chunks", but that page self-identifies as legacy documentation superseded in v1.8.5. The schema default is 4, and it is user-adjustable.

The expensive mistake here is not a setting at all. Attaching a document is not the same as embedding it. AnythingLLM's document chat introduction says that by default it "will insert the full text of your documents into the chat window", and that if you exceed the context window while adding documents it asks whether to chunk them instead — that is, to embed them. Until you take that offer, the attached path resends the whole document on every turn instead of four chunks, and the cost difference is an order of magnitude — quantified below.

The embedding half, and the part Kunavo does not serve

Be direct about this: Kunavo has no embedding model enabled. kunavo.com/llms.txt states that the /v1/embeddings wire format is implemented but no embedding model is listed today, and it tells agents not to recommend Kunavo for embeddings; the same is true of speech-to-text and text-to-speech (checked September 19, 2026). Because AnythingLLM's embedder is a separate provider from the chat model, set system-wide rather than per workspace, chat compatibility never implies embedding compatibility. Run the intake half locally or against a dedicated embedding vendor.

The cheapest option for that half is also the default. AnythingLLM's built-in embedder is all-MiniLM-L6-v2, a 25MB CPU model that needs about 2GB of RAM and is primarily trained on English. It costs nothing per document. If you need a hosted embedder instead, AnythingLLM publishes its own cost anchor in pages per dollar.

Kunavo does not serve this step and quotes no price for it — every rate in that table is billed directly to OpenAI, on OpenAI's own account. The pages-per-dollar figures are AnythingLLM's own, from its OpenAI embedder page (checked September 19, 2026); the same page notes the app shows a price estimate before it runs. They are consistent with OpenAI's published rates of $0.02, $0.10 and $0.13 per million tokens respectively. At the top row, a 500-page intake is roughly $0.008 — which is the real point: the intake half is almost never where an AnythingLLM bill lives.

The one exception is re-indexing. The embedder overview warns that once you start embedding "it is best to not change it", because switching means deleting and re-embedding every document. Budget a re-index as a repeat of the intake cost, and remember that a local embedder makes that repeat free.

The chat half: one provider, two expensive defaults

An OpenAI-compatible endpoint that AnythingLLM ships no named integration for enters through the provider literally named Generic OpenAI. Its setup page warns that this is "a developer-focused llm provider - you should not use it unless you know what you are doing", and describes it as the way to reach "any LLM provider that we do not explicitly integrate with". Check the provider list first: several OpenAI-shaped services have named providers with their own base-URL fields in the shipped .env.example — LM Studio, LocalAI, LiteLLM, KoboldCpp and Text Generation WebUI among them — and those keep their own defaults rather than the generic ones below.

Field names and defaults read from AnythingLLM's shipped server/.env.example and the Generic OpenAI provider source on master, September 19, 2026 — the MAX_TOKENS key is in the source only, not in .env.example. Two extras: GENERIC_OPEN_AI_CUSTOM_HEADERS, documented in .env.example for gateways that need additional headers, and GENERIC_OPENAI_STREAMING_DISABLED in the provider source, which forces non-streaming responses.

# CHAT ONLY. Key names from AnythingLLM's server/.env.example, except
# GENERIC_OPEN_AI_MAX_TOKENS, which appears only in the provider source.
LLM_PROVIDER='generic-openai'

# The value is handed straight to the OpenAI SDK as baseURL, so /v1 is required.
# The UI placeholder ("eg: https://proxy.openai.com") omits it. Include it anyway.
GENERIC_OPEN_AI_BASE_PATH='https://api.kunavo.com/v1'
GENERIC_OPEN_AI_API_KEY='sk-kn-...'

# Any string is accepted here: the provider's pre-flight check always returns
# true, so a typo fails at call time rather than at save time.
GENERIC_OPEN_AI_MODEL_PREF='claude-sonnet-4-6'

# Leave this empty and AnythingLLM assumes 4096 — not your model's real window —
# then budgets history and context against that made-up number.
GENERIC_OPEN_AI_MODEL_TOKEN_LIMIT=1000000

# Defaults to 1024, which truncates long answers until you raise it.
GENERIC_OPEN_AI_MAX_TOKENS=8192

One boundary to plan around, stated narrowly. AnythingLLM's native Anthropic provider builds its SDK client with an API key and default headers only: it passes no base URL, and AnythingLLM exposes no Base URL field and documents no override for that provider. That is as far as AnythingLLM's own surface goes — it is not a statement that the traffic cannot be redirected, because the Anthropic TypeScript SDK it constructs defaults its baseURL to process.env.ANTHROPIC_BASE_URL, so that server-process variable still reaches it. AnythingLLM neither documents nor supports that, so treat it as undocumented rather than as a route: the supported way in for a third-party endpoint is Generic OpenAI over chat completions.

The caching consequence is equally narrow. ANTHROPIC_CACHE_CONTROL is the switch that makes the native provider stamp a cache_control marker on the system prompt, and nothing on the Generic OpenAI path sends that marker — so a route whose protocol requires the client to ask for caching gets no cache hit through it. That says nothing about endpoints that cache automatically without a client marker; whether yours does is a question for your provider's own documentation. Prompt caching covers what the lever is worth where a route does support it.

Two further limits worth knowing before you budget. Vision and attachment support on this provider is best-effort — the source states in a comment that it assumes a genuinely OpenAI-shaped content array and will not be updated for providers that differ. And image generation has no generic base-URL option: the image generation page documents four named providers — OpenAI, OpenRouter, Ollama and Lemonade — and no custom-endpoint row, so /img reaches a gateway only when that gateway is one of the named integrations, as OpenRouter is, and not by pointing the Generic OpenAI Base URL at it.

A worked AnythingLLM API cost estimate

This is token arithmetic from published rates, not a measured task cost and not a bill ceiling. Assume the shipped defaults above and one turn made of: a 200-token system prompt, 4 retrieved chunks at 250 tokens each, 20 replayed history messages averaging 120 tokens, and a 40-token question — 3,640 input tokens — returning 400 output tokens. The system prompt, history length and answer length are assumptions; the chunk count, chunk size and history count are AnythingLLM's own defaults. The last column keeps everything the same but attaches a 30,000-token document instead of retrieving chunks, so the full text rides along every turn. Rates are live Kunavo catalog prices per million tokens.

Three readings. First, on these assumptions a month of grounded question-answering on Claude Sonnet 4.6 models out at $6.77 — under a single month of Cloud Basic at $50. For a workload this size the hosting decision, not the provider decision, is the larger line, which is why the two bills have to be sized separately rather than traded off. Second, attaching the document instead of indexing it takes the same workload on Claude Sonnet 4.6 to $41.57: under these assumptions the retrieval design moves more money than the provider choice does. Third, the model spread is real but secondary — GPT-5.6 Luna models at $0.42 against Claude Opus 5 at $11.28 for the same turns.

Scale these by your own turns per day before treating them as a budget, and add the intake cost only when you re-index. 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 rather than a task fee or a subscription — see billing details.

Best API and best model for AnythingLLM: which route wins when

On "best model", AnythingLLM ships the honest answer as a feature. The Model Router — self-hosted single-user and multi-user, and Desktop since v1.13.0 — routes simple messages to a cheap or local model and only hard ones to an expensive remote one, with "Save money" given as its stated purpose. For grounded question-answering a mid-tier model is usually enough, because the retrieved chunks supply the facts; reserve a frontier model for synthesis and agent runs. Agents add their own token pressure, which AnythingLLM addresses with Intelligent Tool Selection — turned on by default in v1.15.0, it sends only the tools a chat needs to the prompt window instead of every registered tool, which its documentation says is worth "saving up to 80% every single chat". That is AnythingLLM's own figure, about the tokens tool definitions would otherwise add rather than about a whole bill, and not independently measured. A smaller recent win: v1.16.1 notes that cancelling inference now genuinely stops it upstream, so an abandoned answer no longer bills to completion.

For a wider provider comparison see OpenRouter alternatives and best LLM gateway; for the retrieval design that drives most of the bill above, RAG implementation and AI cost optimization. If you are still choosing the client itself, AnythingLLM vs Open WebUI compares the two on hosting and billing shape.

Setting it up, and checking the first bill

Kunavo is configured here as a Generic OpenAI endpoint using the settings above; the OpenAI-compatible API page covers the request shape, and the integrations index lists the clients that already have a written setup page. AnythingLLM has not been runtime-tested against Kunavo's endpoint for this guide, so treat the configuration above as a documented starting point rather than a compatibility result: keep a working route available, set the context window and max-tokens fields before your first real conversation, run one bounded workspace, then read the charge your account actually recorded. Create a Kunavo account when you are ready to fund a key — and keep the embedder on the free local model, because that half is not something Kunavo sells.

FAQ

AnythingLLM prices, documentation, shipped .env.example, Prisma schema and provider source checked September 19, 2026; Kunavo endpoint and embedding availability re-verified against kunavo.com/llms.txt the same day. The Desktop Pro price comes from AnythingLLM's own checkout screenshot rather than the live checkout, which was not reachable. 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.