AI Chatbot Cost for 1,000 Daily Users: API Breakdown
Monthly API costs for a chatbot with 1,000 daily users across OpenAI, Anthropic, Google, DeepSeek and Groq. Numbers worked October 2026.
A chatbot with 1,000 daily users running on a flagship model like GPT-6 Astra or Claude Fable 5.1 costs roughly $2,250 per month in API fees alone. Drop to a mid-tier model and the same traffic costs $450 to $900. Move to one of the budget models and the bill falls below $100, sometimes below $25. The gap is real and the math is straightforward once you fix your token assumptions.
The Token Assumptions Behind This Estimate
Before the numbers mean anything, you need a usage model. Here is what this article assumes:
- 1,000 daily users, each having 5 conversational turns per day
- 500 input tokens per turn (system prompt, conversation history, and the user's message)
- 200 output tokens per turn (the model's reply)
That gives you 5,000 turns per day and 150,000 turns per month. Across those turns:
- Input tokens per month: 75 million (75M)
- Output tokens per month: 30 million (30M)
These numbers fit a typical support or Q&A chatbot: a medium-length system prompt, a few prior turns of context, and concise answers. A coding assistant or a long-document chat would use more tokens per turn. A simple FAQ bot with a short system prompt would use fewer. Adjust the multipliers if your workload differs, but the relative gaps between providers will hold.
Monthly Cost by Model and Provider
All prices below are per million tokens (input / output) from each provider's own pricing page, checked October 24, 2026. The monthly cost column applies the 75M input and 30M output figures from the scenario above.
| Provider | Model | Input $/M | Output $/M | Monthly cost |
|---|---|---|---|---|
| OpenAI | GPT-6 Astra | $10.00 | $50.00 | $2,250 |
| Anthropic | Claude Fable 5.1 | $10.00 | $50.00 | $2,250 |
| OpenAI | GPT-5.6 Sol | $4.00 | $20.00 | $900 |
| Anthropic | Claude Opus 5.5 | $4.00 | $20.00 | $900 |
| Gemini 4 Argon* | $2.00 | $10.00 | $450 | |
| Anthropic | Claude Sonnet 5.5 | $2.00 | $10.00 | $450 |
| Gemini 3.8 Flash | $0.75 | $3.75 | $169 | |
| Gemini 3.5 Flash-Lite | $0.30 | $2.50 | $98 | |
| DeepSeek | deepseek-v4-pro (off-peak) | $0.66 | $1.98 | $109 |
| OpenAI | GPT-6 Luna | $0.10 | $0.50 | $23 |
| Anthropic | Claude Haiku 5.5 | $0.10 | $0.50 | $23 |
| DeepSeek | deepseek-flash (off-peak) | $0.15 | $0.60 | $29 |
| Groq | GPT OSS 120B | $0.15 | $0.60 | $29 |
| Groq | GPT OSS 20B | $0.075 | $0.30 | $15 |
*Gemini 4 Argon introductory pricing runs through November 30, 2026. Input rises to $4.00/M and output to $20.00/M from December 1, which doubles the monthly cost to $900. Gemini 3.8 Flash also doubles, on January 1, 2027, to $1.50/M input and $7.50/M output, which puts it at about $338 a month.
See what each request costs
PromptUnit shows every request your app sends: the model it asked for, the model that answered, what it cost and what it saved. You change two settings, and your own provider key stays.
Try it free →What the Range Actually Means
The cheapest option in the table, Groq's GPT OSS 20B at about $15 per month, costs 150 times less than a flagship. That is not a slight discount; it is a different economic category entirely.
The practical question is not "what is the cheapest?" but "what is cheap enough for the quality my app needs?" The budget models are fast and capable for narrow tasks: answering FAQ questions, classifying support tickets, generating short structured outputs. They tend to struggle with nuanced reasoning, long documents, or tasks that require following complex instructions across many turns.
The AI Cost Per User: Formula, Examples and SaaS Margins post works through the SaaS unit economics side of this: how the per-user API cost compares to what you charge, and where margins compress. This post focuses only on the provider math.
Three Factors That Change the Calculation
1. Prompt caching
If your system prompt is the same across all users, every provider's caching mechanism cuts input costs significantly. On Anthropic, cached input tokens cost 10% of the base input price on most models, 5% on Opus 5.5 and Sonnet 5.5, and 2.5% on Fable 5.1. On OpenAI, cached input tokens are $1.00/M for GPT-6 Astra versus $10/M uncached. On Google, implicit caching on Gemini 4 Argon discounts cached input by 95%.
A 300-token system prompt repeated across 150,000 turns is 45M tokens of input. If all of it hits cache on Claude Sonnet 5.5, you pay $0.10/M instead of $2.00/M for those tokens, saving around $85 per month on that alone. The post on Prompt Caching on OpenAI and Anthropic: Real Savings Numbers covers when this actually works and when it does not.
2. DeepSeek peak vs. off-peak pricing
DeepSeek is the only provider in this comparison with time-of-day pricing. Peak hours (01:00 to 04:00 UTC and 06:00 to 10:00 UTC on weekdays, excluding Chinese public holidays) cost exactly double the off-peak rate. If your 1,000 daily users are spread evenly around the clock, a rough estimate is that maybe 20 to 30% of your traffic falls in peak windows, which pushes the blended monthly cost for deepseek-flash from $29 toward $35 to $38. For deepseek-v4-pro the same logic pushes from $109 toward roughly $130 to $140. Worth checking against your actual traffic distribution.
3. Output length dominates cost on expensive models
On a $10/$50 model, output tokens cost five times more per token than input tokens. In this scenario, 30M output tokens cost $1,500 while 75M input tokens cost $750. If your chatbot is verbose, you can cut costs just by instructing the model to be concise. On cheap models the difference matters less: at $0.10/$0.50, the output share is the same ratio but the absolute dollars are small.
Rate Limits and Scale Considerations
At 1,000 daily users with 5 turns each, peak traffic is uneven. If users cluster in a two-hour window, you might send 5,000 to 7,000 requests per hour, or roughly 83 to 117 requests per minute. Most providers handle that comfortably at the standard paid tiers.
On OpenAI, the Build tier allows 5,000 RPM and 1,000,000 tokens per minute for the Astra, Sol and Terra models. On Anthropic, the Start tier allows 1,000 RPM for Sonnet and Haiku. On Groq, the free plan allows 30 RPM for GPT OSS 120B and 20B, which is tight at peak; the paid Developer plan raises that to 1,000 RPM. Groq's limits are per minute per model. Google's limits vary by tier and are visible in AI Studio.
For a 1,000 daily user app, none of these limits are binding under uniform traffic, but real apps have spikes. Build for retry with backoff and don't run production traffic on Groq's free plan, whose 30 RPM limit would cause errors during peak bursts.
When You Are Running Multiple Models
Most real chatbots are not a single model for every request. A common pattern is: a cheap model for intent classification, a mid-tier model for the main response, and a flagship only for complex cases that the cheaper model flags as out of scope. That layered approach can keep the average cost close to the cheap tier while preserving quality on hard queries.
The LLM Routing: How It Works, Strategies and Real Data post covers the routing strategies in detail. The short version is that routing decisions made at the request level, based on the content of each call, tend to outperform static per-step model assignments because traffic patterns change and model capabilities improve over time.
PromptUnit applies this at the request level: you point your app's AI API base URL at it and add your PromptUnit key in the x-promptunit-key header, keeping your own provider key. When the per-request check finds a cheaper model is likely just as good, it routes there instead. The dashboard shows what each request cost and what it saved.
What to Expect as You Scale
These monthly costs scale linearly with users, turns per user, and tokens per turn. A few reference points:
- 100 daily users: roughly $2 to $225 per month depending on model
- 1,000 daily users: roughly $15 to $2,250 per month
- 10,000 daily users: roughly $150 to $22,500 per month
- 100,000 daily users: roughly $1,500 to $225,000 per month
At 10,000 users the flagship models become seriously expensive. At 100,000 users, even mid-tier models like Sonnet 5.5 at $450 for 1,000 users would reach $45,000 per month. That is the point where caching, batching, and routing decisions become the most important engineering work in your stack, not an optimization you defer.
The AI Cost Optimization Checklist 2026: 15 Steps to Lower Your API Bill has the ordered list of levers to pull as you scale.