Some links in this article are affiliate links. Automated Wealth Lab may earn a commission at no extra cost to you. See our Affiliate Disclosure.
- What a RAG chatbot actually consists of
- The assumptions behind every number below
- Component 1: Embedding costs (the bill that isn’t)
- Component 2: Vector database pricing
- Component 3: The answer model, priced per conversation
- Component 4: Hosting
- The full self-hosted bill, computed
- Build vs buy: what Chatbase actually costs at the same volumes
- Component 5: Build time, honestly labelled
- Caveats that move the real bill
- FAQ
- Methodology
- AWL verdict
- Sources
Disclosure: This article contains affiliate links for DigitalOcean and n8n. If you sign up through one of those links we may earn a commission at no extra cost to you. Every price below was checked against the vendor’s published pricing in October 2026, and the commission does not change the rankings — the cheapest stack in this article contains no affiliate link at all.
Every “AI chatbot for your website” pitch hides the same question: what does it actually cost per month once real customers start asking real questions? The demo always looks cheap. The invoice depends on four moving parts — embedding your documents, storing the vectors, generating each answer, and hosting the whole thing — plus a fifth cost nobody puts in the sales deck: your time building and maintaining it.
This article prices a retrieval-augmented generation (RAG) chatbot for a typical small business: a support and FAQ bot trained on your help docs, product pages and policies, embedded as a widget on your site. We priced every component from published vendor pricing, computed the total monthly run cost at three traffic volumes with all assumptions printed, and then compared building it yourself against renting a finished platform like Chatbase. No benchmarks we didn’t run, no “we tested” claims — just arithmetic you can redo yourself.
One finding up front, because it inverts the usual pitch: at small-business scale, the AI itself is nearly free. The answer model costs fractions of a cent per conversation. What you actually pay for is the platform around it — or the hours needed to replace that platform.
The short answer: A self-hosted RAG chatbot for a small business runs about $16/month at 1,000 answers, $30/month at 5,000 answers, and $94/month at 20,000 answers, using OpenAI’s mid-tier model and a $12–24 VPS. The token math is tiny — roughly $0.0035 per answer on a capable model, $0.00035 on the budget tier — and embedding a whole knowledge base costs about 3 cents, once. Renting instead of building (Chatbase) costs roughly $80, $190 and $700/month at the same volumes. Building wins on price from day one; buying wins on time — a no-code bot is live in 2–4 hours versus 25–50 hours for a custom build.
What a RAG chatbot actually consists of
“RAG chatbot” sounds like one product. It is five separate bills wearing a trench coat:
- Embedding model — converts your documents into vectors, and converts each visitor question into a vector so the system can find matching passages. Charged per token, one time for your documents, per question after that.
- Vector database — stores those vectors and retrieves the most relevant chunks in milliseconds. Pinecone, Qdrant and Weaviate are the common names.
- Answer model (LLM) — receives the question plus the retrieved chunks and writes the reply in plain language. This is the per-conversation cost that scales with traffic.
- Hosting and plumbing — a small server running your app (or a workflow tool like n8n), the chat widget, and a sync process that re-indexes documents when they change.
- Your time — setup, testing against real questions, and monthly upkeep when docs change or answers drift.
Most cost guides price item 3 and stop. Items 2, 4 and 5 are where small businesses actually feel the bill, so we price all five.
The assumptions behind every number below
Cost models are only honest if the assumptions are printed next to them. Here is the model used throughout this article:
| Assumption | Value used |
|---|---|
| Knowledge base size | ~500 pages/docs → ~2,500 text chunks, ~1.5 million tokens total |
| Tokens per answer | 2,000 input (system prompt + 4 retrieved chunks + short chat history), 300 output |
| Query embedding per question | ~25 tokens — cost rounds to zero, shown for completeness |
| Traffic volumes | 1,000 / 5,000 / 20,000 answered questions per month |
| Document churn | 10% of the knowledge base re-embedded monthly |
If your bot writes long answers or stuffs ten chunks into every prompt, your token cost rises proportionally — the per-answer formula in the next section lets you recompute with your own numbers.
Component 1: Embedding costs (the bill that isn’t)
OpenAI’s text-embedding-3-small costs $0.02 per million tokens; the larger text-embedding-3-large costs $0.13 per million (using the Batch API halves both). Voyage AI’s voyage-4 sits at $0.06 per million, Cohere’s embed-v4 at $0.12. Applied to our model knowledge base:
| Embedding task | Tokens | text-embedding-3-small | text-embedding-3-large |
|---|---|---|---|
| Initial indexing of full knowledge base | ~1.5M | $0.03 | $0.20 |
| Monthly re-index (10% churn) | ~150K | $0.003 | $0.02 |
| Embedding 20,000 visitor questions | ~500K | $0.01 | $0.07 |
Read that table again, because it kills a common upsell: embeddings are a rounding error. Vendors who price “per document indexed” are charging you dollars for a three-cent operation. Whichever embedding model you pick, this line never decides your budget. Pick the small model unless your retrieval quality measurably suffers — and note that you can only know that with a test set of real questions, which is a build-time task, not a purchase.
Component 2: Vector database pricing
Your chunks have to live somewhere searchable. The three mainstream options price very differently:
| Option | Entry paid tier | What you get | Notes |
|---|---|---|---|
| Qdrant self-hosted | $0 license (Apache 2.0) | Runs in Docker on your own VPS | You pay only for the server it shares |
| Qdrant Cloud | Free tier (1 GB RAM cluster); paid clusters priced by resources | Managed, 99.5% SLA on paid | Pricing scales with vCPU/RAM/storage |
| Pinecone Builder | $20/month flat | 10 GB storage, 5M write units, 2M read units/month | Enough for most small-business bots |
| Pinecone Standard | $50/month minimum | Usage-based: storage $0.33/GB/mo, reads $16–18 per million units | Minimum spend applies before any usage |
| Weaviate Cloud Flex | From $45/month | Pay-as-you-go, priced by vector dimensions stored | Free tier: 100K objects for testing |
For our model’s 2,500 chunks, every option above is technically oversized — the entire vector store is well under 1 GB. The practical choice is between $0 (Qdrant in Docker on the same VPS as your app), $20/month (Pinecone Builder, zero maintenance) and $45–50/month (Weaviate Flex or Pinecone Standard minimums, paying for headroom you won’t use this year). At small scale, managed vector databases are a convenience purchase, not a capacity purchase. That’s fine — convenience is worth money — but know that’s what you’re buying.
Component 3: The answer model, priced per conversation
This is the only component that truly scales with traffic, so let’s do the arithmetic in the open. OpenAI’s current lineup, per million tokens: the budget gpt-6-luna at $0.10 input / $0.50 output, the mid-tier gpt-6.1-terra at $1.00 / $5.00, and the flagship gpt-6.1-sol at $2.00 / $10.00.
Cost per answer = (2,000 input tokens × input rate) + (300 output tokens × output rate):
| Model | Per-answer cost | 1,000 answers | 5,000 answers | 20,000 answers |
|---|---|---|---|---|
| gpt-6-luna (budget) | $0.00035 | $0.35 | $1.75 | $7.00 |
| gpt-6.1-terra (mid-tier) | $0.0035 | $3.50 | $17.50 | $70.00 |
| gpt-6.1-sol (flagship) | $0.0070 | $7.00 | $35.00 | $140.00 |
Two lessons fall out of this table. First, even at 20,000 answers a month — a busy small business — the mid-tier model costs $70. Second, model choice matters more than model haggling: the flagship costs exactly double the mid-tier per answer, and for FAQ-style answers grounded in retrieved text, most businesses won’t see a quality difference worth 2×. Start mid-tier; spend your effort on good source documents and retrieval, which is where answer quality actually comes from in a RAG system.
Component 4: Hosting
A chatbot backend is a light workload. DigitalOcean’s published Droplet pricing runs $6/month for 1 GB RAM, $12 for 2 GB, $24 for 4 GB — and a 2 GB droplet comfortably runs the app, the widget backend and a self-hosted Qdrant instance for a small knowledge base. At 20,000 answers a month we’d step up to the $24 tier for headroom, mostly for the vector store and concurrent traffic, not because the AI needs it.
The alternative shape is orchestration-first: run the retrieval and answer flow inside n8n on the same VPS, which many solo founders already have for other automations, making the marginal hosting cost of the bot effectively $0 on infrastructure you’ve already paid for. Either way, hosting is a $6–24 line item, not a decision-maker.
The full self-hosted bill, computed
Adding the components (mid-tier answer model, self-hosted Qdrant, embeddings included):
| Monthly cost | 1,000 answers | 5,000 answers | 20,000 answers |
|---|---|---|---|
| Answer model (gpt-6.1-terra) | $3.50 | $17.50 | $70.00 |
| Embeddings (queries + re-indexing) | ~$0.01 | ~$0.03 | ~$0.08 |
| Vector DB (Qdrant, self-hosted) | $0 | $0 | $0 |
| VPS hosting | $12 | $12 | $24 |
| Total run cost | ≈ $16 | ≈ $30 | ≈ $94 |
| Effective cost per answer | 1.6¢ | 0.6¢ | 0.5¢ |
Swap in managed Pinecone Builder (+$20/month flat) and the same table reads roughly $36 / $50 / $114. Swap the answer model down to the budget tier and it reads $12 / $14 / $31. Every variant lands in the same territory: a self-built RAG bot costs tens of dollars a month to run, not hundreds. Anyone quoting you $500/month in “AI costs” for a support bot at this scale is either bundling their labour (fine, if disclosed) or marking up tokens (not fine).
Build vs buy: what Chatbase actually costs at the same volumes
Chatbase is the reference point for the buy path: upload documents, get a hosted bot and widget, no server to manage. Its published plans (monthly billing) are a $40/month tier with 700 message credits, a $150/month tier with 4,000 credits, and a $500/month tier with 15,000 credits; annual billing takes 20% off. Extra credits cost $40 per 1,000, and removing Chatbase branding is a $99/month add-on. Credits are consumed per AI message request — and features like automated actions can make a single user-visible reply consume more than one request, so treat 1 credit ≈ 1 answer as the optimistic case.
| Monthly cost, buy path | 1,000 answers | 5,000 answers | 20,000 answers |
|---|---|---|---|
| Plan that fits | $40 tier + 1,000 extra credits | $150 tier + 1,000 extra credits | $500 tier + 5,000 extra credits |
| Total | ≈ $80 | ≈ $190 | ≈ $700 |
| Add: remove branding | +$99 | +$99 | +$99 |
Set the two tables side by side: $16 vs $80, $30 vs $190, $94 vs $700. The gap widens with volume because platform credits scale per answer while a self-hosted stack’s fixed cost barely moves. But the platform price includes things our build table doesn’t: the hosting, the widget, analytics, lead capture, human handoff tooling, and — most importantly — the fact that it exists today instead of after a build project. Which side of that trade is right depends entirely on the fifth component.
Component 5: Build time, honestly labelled
The figures below are a planning model, not measured results — ranges from the published scope of each approach (setup tasks are enumerable: account/config, document prep, chunking choices, widget install, testing against real questions). Your mileage varies with experience; treat them as budgeting aids, not benchmarks.
| Approach | Time to live bot | Monthly upkeep | Who it’s for |
|---|---|---|---|
| No-code platform (Chatbase-type) | 2–4 hours | ~30 min | Owners who need it live this week |
| Low-code self-host (visual builder + VPS) | 8–16 hours | 1–2 hours | Technical founders avoiding per-answer fees |
| Custom build (own code, Qdrant, own widget) | 25–50 hours | 2–4 hours | Businesses needing custom behaviour/integrations |
The honest way to compare build vs buy is to price your hours. At 5,000 answers a month, buying costs about $160/month more than running your own stack. If a custom build takes 35 hours, the platform “pays you” roughly $160/month to not build — the build breaks even against the platform in well over a year of upkeep-inclusive time if your hour is worth little, or never, if your hour bills at professional rates and you’d spend it on revenue work instead. Conversely, at 20,000 answers a month the $600/month gap repays a 35-hour build quickly for almost anyone. Volume is the deciding variable — which is convenient, because volume is also the thing you can measure before choosing.
Caveats that move the real bill
- Long answers and fat prompts. Our model uses 2,000 input / 300 output tokens. A bot that pastes ten chunks and writes essays can triple the token line. It changes $70 into ~$200 at high volume — noticeable, still not catastrophic.
- Credit burn on platforms. If your platform counts an action-equipped reply as 2 requests, your buy-path volumes effectively halve. Check the credit definition before signing, not after the first invoice.
- Answer quality is a documents problem. A RAG bot is only as good as the text it retrieves. Budget real time for cleaning help docs; no model upgrade fixes contradictory source pages.
- Compliance and privacy. Customer questions flow through your model provider’s API. For most small businesses that’s acceptable under the provider’s API data terms, but regulated industries (health, legal, finance) need a review before launch — a cost in advice, not tokens.
FAQ
How much does it cost to build a RAG chatbot for a small business?
In run costs, roughly $16/month at 1,000 answers to $94/month at 20,000 answers for a self-hosted build, using published prices for a mid-tier answer model and a small VPS. The real cost is build time: budget 2–4 hours on a no-code platform, or 25–50 hours for a custom build, as a planning estimate.
Why is the embedding cost so low — am I misreading?
No. OpenAI’s text-embedding-3-small costs $0.02 per million tokens, and a typical small-business knowledge base is around 1.5 million tokens — about 3 cents to index completely. Embeddings are priced per token with no output charge, which makes them 10–100× cheaper than generating answers at similar volumes.
Is Pinecone worth paying for at small scale?
As convenience, yes; as capacity, no. Pinecone’s $20/month Builder tier removes all vector-DB maintenance, and your 2,500-chunk store would use a fraction of its allowance. But a self-hosted Qdrant on the same VPS does the same job for $0 at this scale — you’re paying to not think about it, which is a legitimate reason, priced honestly at $20/month.
Chatbase or build my own — which is cheaper after a year?
At 5,000 answers a month: buying costs roughly $190/month (~$2,280/year) versus roughly $30/month (~$360/year) self-hosted — building saves around $1,900/year but consumes an estimated 25–50 hours up front plus upkeep. At 1,000 answers a month the yearly saving shrinks to roughly $770, which many owners rationally trade for a bot that was live the same afternoon.
Can I run the whole chatbot on a $6 VPS?
Technically yes for a small knowledge base — the app plus Qdrant fits in 1 GB if you’re careful — but the $12 / 2 GB tier is the sane floor once you add an orchestration tool or traffic spikes. Hosting is the least consequential line in the budget either way.
What makes RAG chatbot costs spike unexpectedly?
Three things: long generated answers (output tokens cost 5× input tokens on current OpenAI pricing), oversized retrieval (too many chunks per prompt), and platform credit definitions that charge extra requests for actions or tool calls. All three are visible in a week of real usage logs — check them before your first full month.
Methodology
What we did: Collected published pricing from OpenAI (chat and embedding model rates), Pinecone, Qdrant, Weaviate and DigitalOcean pricing pages, and Chatbase’s published plans and add-ons, in October 2026. We then computed per-answer and monthly costs from an explicit assumptions table (knowledge base size, tokens per answer, traffic volumes) that is printed in full above, so any reader can recompute every figure with different assumptions.
What we did NOT do: We did not build or benchmark a production chatbot for this article, and we make no claims about answer quality, retrieval accuracy or latency for any tool named — those require a test corpus and measured runs, which we have not done. Build-time figures are explicitly labelled planning-model ranges, not observations.
Conflict disclosure: This site earns affiliate commissions from DigitalOcean and n8n, both mentioned above. Pinecone, Qdrant, Weaviate, OpenAI and Chatbase pay us nothing. The cheapest recommended stack (self-hosted Qdrant) contains no affiliate relationship.
AWL verdict
Build it — but only once volume justifies your hours. Under ~2,000 answers a month, rent: a $40–80/month platform buys back a build project for less than the value of the time it saves, and the run-cost difference is a rounding error. Above ~5,000 answers a month, the math flips decisively — a self-hosted stack on a $12–24 VPS with a mid-tier answer model runs at $30–94/month against $190–700 on platform credits, and the gap pays for the build. Whichever path you choose, ignore any quote built on “AI costs”: at small-business scale the tokens are pennies, and the real price is always the platform or the person.
Sources
- OpenAI API pricing — chat model and embedding rates — https://platform.openai.com/docs/pricing (verified October 2026)
- Embedding model price comparison — text-embedding-3-small $0.02/M, 3-large $0.13/M, Voyage and Cohere rates — https://embeddingcost.com/ (verified October 2026)
- Pinecone pricing — Builder $20/month, Standard $50/month minimum and unit rates — https://www.pinecone.io/pricing/ (verified October 2026)
- Qdrant Cloud pricing — free tier and resource-based paid clusters — https://qdrant.tech/pricing/ (verified October 2026)
- Chatbase pricing — plan credit allowances and tiers — https://www.chatbase.co/pricing (verified October 2026)
- DigitalOcean Droplet pricing — $6 / $12 / $24 Basic tiers — https://www.digitalocean.com/pricing/droplets (verified October 2026)
- Weaviate pricing overview — Cloud Flex from $45/month — https://www.eesel.ai/blog/weaviate (verified October 2026)
