⚡The short answer
Chatbot pricing confuses buyers because the word covers three different products. A scripted bot that walks users through a decision tree is a web form with better manners. An LLM chatbot grounded in your documentation is a retrieval system with a conversation interface. A chatbot that takes actions — looks up orders, processes refunds, books appointments — is an integration project wearing a chat UI. They have nothing in common on the budget line.
The ranges below are the US market ranges we observe for professional builds, including design, engineering, evaluation and deployment. The build cost is only half the picture: LLM API usage is a metered running cost that scales with your traffic, and it is the line item most proposals bury. We cover it with real arithmetic later in this article.
See our AI chatbot development services
| Tier | What it is | Build cost (US market range) | Typical monthly running cost |
|---|---|---|---|
| Grounded support bot | Answers questions from your docs and help centre, web widget, handoff to humans | $15,000–$40,000 | $50–$500 |
| Product assistant | Retrieval over your full knowledge base, multiple channels, guardrails, analytics | $40,000–$120,000 | $200–$2,000 |
| Action-taking agent | Reads and writes in your systems: orders, bookings, refunds, CRM updates | $120,000–$300,000+ | $500–$5,000+ |
🤖Rule-based vs LLM chatbots: two products, two budgets
A rule-based chatbot is a decision tree: if the user says this, show that. Build costs run $5,000 to $20,000, and for a narrow set of high-volume questions — store hours, order status links, password resets — it remains the most reliable and cheapest option. It never hallucinates because it never generates anything. The failure mode is coverage: the moment a user phrases something outside the script, the bot is a wall.
An LLM chatbot generates answers from a language model, which means it handles phrasing you never anticipated and questions you never scripted. That flexibility is what buyers are actually purchasing — and it is also where every new cost comes from. The model can be wrong, can be confidently wrong, and can be wrong in ways that create liability. So the build is not just the model; it is the retrieval system that grounds it, the guardrails that constrain it, and the evaluation suite that tells you whether it is getting better or worse.
The practical rule: if your question set is small, stable and known, rule-based wins on cost and reliability. If users arrive with open-ended language about a large body of content, LLM-based wins — but only if you fund the grounding and guardrails, not just the model call. An ungrounded LLM chatbot is a confident liar with your logo on it.
📚Retrieval grounding: where the build budget actually goes
Retrieval-augmented generation — RAG — is the pattern that makes an LLM chatbot answer from your content instead of from its training data. The system indexes your documentation, help centre, product catalogue and policies; retrieves the relevant passages for each question; and hands them to the model as the factual basis for its answer. This is the difference between a chatbot that cites your refund policy and one that invents one.
The cost is in the data work, not the algorithm. A basic RAG pipeline over clean, well-structured documentation adds $8,000 to $20,000 to a build. The number climbs when your knowledge is messy: PDFs with broken layouts, content scattered across six systems, contradictory versions of the same policy, or information that changes weekly and needs re-indexing pipelines. Most of the hours go into ingestion, chunking, deduplication and freshness — the unglamorous plumbing that determines whether the chatbot sounds informed or sounds drunk.
Budget separately for the knowledge base itself. If your documentation would not let a new human hire answer customer questions, it will not let a chatbot answer them either. A documentation remediation phase is a common and honest line item — typically $5,000 to $15,000 — and skipping it is the most reliable way to build an expensive chatbot that gives cheap answers.
A chatbot is only as good as the knowledge it retrieves. Buyers shop for models; they should be auditing their documentation. The retrieval layer is where the accuracy comes from, and accuracy is the entire product.
🔌Channel integrations: each one is a project
A web chat widget is the base case and is included in any sensible build quote. Every additional channel — Slack, Microsoft Teams, WhatsApp, SMS, Instagram, email — is its own integration with its own API constraints, message formats, rate limits and approval processes. Budget $3,000 to $10,000 per channel beyond the first, with WhatsApp and the Meta ecosystem at the higher end because of template approval and business verification overhead.
Channels also differ in what the conversation can do. A web widget can render cards, buttons and file uploads. SMS cannot. A chatbot designed for the web and ported to SMS without redesign will truncate, confuse and frustrate. The honest way to scope multi-channel is to design the conversation per channel, sharing the brain but not the interface.
The integration that costs the most is not a channel at all — it is the handoff to humans. Routing to live agents, passing conversation context so the customer never repeats themselves, and fitting into your existing helpdesk (Zendesk, Intercom, Salesforce Service Cloud and similar) typically runs $5,000 to $15,000 and is the single feature that most determines customer satisfaction with the whole system.
🛡️Guardrails and evaluations: the part that keeps you out of the news
An LLM chatbot without guardrails will eventually promise a refund you do not offer, invent a product feature, or get talked into something by a determined user. Guardrails are the engineering layer that prevents this: topic boundaries, refusal behaviours, escalation triggers, PII handling, and checks on output before it reaches the user. On a professional build, this layer is $5,000 to $20,000 of the budget, and cutting it is false economy measured in screenshots on social media.
Evaluations are the discipline nobody buys and everybody needs. An eval suite is a set of hundreds of representative questions with expected behaviours, run automatically against every change to prompts, models or retrieval. Without it, every improvement is a guess and every model upgrade is a gamble. With it, you can answer the only question that matters — is it getting better? — with a number instead of a vibe.
This is also where regulated industries add cost. Healthcare, finance and insurance chatbots need audit trails, disclosure language, and human-review paths for sensitive answers. That is not a model problem; it is a process and documentation problem, and it adds 20 to 40 percent to the guardrail and evaluation scope.
🧮LLM token running costs: the honest arithmetic
Every chatbot message costs money at inference time. You pay the model provider per token — roughly, per three-quarters of a word — for both the input (the question plus the retrieved context and conversation history) and the output (the answer). Current mid-tier hosted models run roughly $0.10 to $3.00 per million input tokens and $0.40 to $15.00 per million output tokens, depending on the model class; frontier models cost several times more, and prices have been falling steadily. Treat these as labelled ranges — providers reprice frequently.
A typical grounded support conversation of eight exchanges, with retrieved context included, consumes roughly 15,000 to 40,000 tokens total. At mid-tier pricing, that puts the raw model cost of a conversation at roughly $0.02 to $0.30. At 1,000 conversations a month, your token bill is $20 to $300. At 50,000 conversations a month, it is $1,000 to $15,000 — and at that volume, model selection, context trimming and caching stop being optimisations and start being the difference between a viable product and a charity.
Three levers control the bill. Model routing — cheap models for simple questions, expensive ones only when needed — typically cuts costs 40 to 70 percent with no quality loss users can detect. Context discipline — retrieving three good passages instead of stuffing in twenty mediocre ones — shrinks the input side, which is usually the larger half. And caching repeated context across turns avoids paying for the same tokens twice. A well-engineered chatbot at scale costs a fraction of a naive one; this is where build quality pays for itself every month.
How we engineer chatbot running costs down
| Monthly conversation volume | Naive build (frontier model, fat context) | Engineered build (routing, trimming, caching) |
|---|---|---|
| 1,000 conversations | $50–$300 | $20–$100 |
| 10,000 conversations | $500–$3,000 | $200–$1,000 |
| 50,000 conversations | $2,500–$15,000 | $1,000–$5,000 |
| 200,000 conversations | $10,000–$60,000 | $4,000–$20,000 |
📊What each build tier actually includes
The three tiers from the summary differ in more than price — they differ in what the chatbot is allowed to do, and permission is the real cost driver. Reading your documentation is safe and cheap. Reading your customer database requires auth and data-scoping work. Writing to your systems — issuing refunds, changing orders, booking appointments — requires transactional safeguards, confirmation flows, rollback logic and a much heavier evaluation suite, because a wrong action is worse than a wrong answer.
| Scope item | Support bot ($15–40K) | Product assistant ($40–120K) | Action-taking agent ($120K+) |
|---|---|---|---|
| RAG over your documentation | Core | Core, multi-source | Core, multi-source, fresh pipelines |
| Channels | Web widget | 2–4 channels | All relevant channels |
| Guardrails and refusal behaviour | Standard | Tuned, with eval suite | Heavy, with audit trail |
| Human handoff | Basic routing | Context-passing helpdesk integration | Full context plus agent assist |
| Reads your business systems | No | Read-only (order status, account info) | Yes |
| Writes to your business systems | No | No | Yes — refunds, bookings, CRM updates |
| Evaluation suite | Smoke tests | Automated, hundreds of cases | Automated, continuous, with red-teaming |
| Analytics and improvement loop | Basic reporting | Conversation analytics | Full funnel plus cost-per-resolution |
✅What to ask before you sign anything
Three questions separate real chatbot builders from prompt-wrapping shops. First: show me the evaluation suite — if a vendor cannot show you how they measure accuracy, they are not measuring it. Second: what does this cost to run at ten times my expected volume — the answer reveals whether they have thought about model routing and caching or are passing a frontier-model invoice straight through to you. Third: what happens when the bot does not know — the honest answer involves a designed escalation path, not a promise that it will not happen.
Also ask what you own. The prompts, retrieval pipeline, eval suites and integrations should be yours, in your accounts, on infrastructure you can keep. A chatbot you cannot take with you is a subscription, not a build, and should be priced like one.
If you are scoping a chatbot now, we will tell you which tier your use case actually lands in — including when the honest answer is that a $10,000 rule-based bot or an off-the-shelf tool covers your need and a custom build does not.