What a customer support chatbot really costs per month (real API bill breakdown)

A chatbot can cost less than expected to generate answers and more than expected to retrieve the information behind them.

That sounds contradictory until you examine an actual workload.

This breakdown models a customer-support chatbot handling 50,000 conversations per month. It uses published API prices available in October 2026.

This is not presented as a private customer invoice. It is a reproducible estimate with every assumption exposed, so you can replace the numbers with your own.

Start With the Workload, Not the Model Price

Assume the chatbot handles:

• 50,000 conversations per month
• Four generated replies per conversation
• 200,000 total model responses
• 1,800 input tokens and 250 output tokens for a normal reply
• Five percent of requests routed to a stronger model
• One knowledge-base search for each generated reply

The input includes system instructions, conversation history, customer information, and retrieved support content.

That last part matters. A chatbot with a growing conversation history can consume far more input tokens than a single-question demo.

The Model Bill: $147.95

For routine questions, the system uses GPT-6 Luna.

OpenAI’s published standard pricing lists GPT-6 Luna at $0.10 per million input tokens and $0.50 per million output tokens.

Ninety-five percent of 200,000 responses equals 190,000 Luna calls.

Those calls process:

342 million input tokens   = $34.20
47.5 million output tokens = $23.75

Luna subtotal              = $57.95

The remaining 10,000 requests are harder cases. They may involve conflicting policies, unusual account histories, or complicated troubleshooting.

Route those requests to GPT-6.1 Sol, currently priced at $2 per million input tokens and $10 per million output tokens.

Assuming 2,500 input tokens and 400 output tokens for each escalated request:

25 million input tokens = $50.00
4 million output tokens = $40.00

Sol subtotal            = $90.00

The combined generation bill is:

$57.95 + $90.00 = $147.95

Using the strongest model for every request would be simpler, but it would waste money on password resets, delivery questions, and other predictable tasks.

Model routing only works when evaluations prove that the cheaper model can handle those requests safely.

Retrieval Costs More Than Generation

A support chatbot normally searches product documentation, policies, previous tickets, or account information before answering.

OpenAI currently charges $2.50 per 1,000 file-search calls through the Responses API. Storage costs $0.10 per GB per day, with the first gigabyte free.

At 200,000 searches per month:

200,000 / 1,000 × $2.50 = $500

For a four-gigabyte knowledge base:

3 billable GB × $0.10 × 30 days = $9

Retrieval therefore adds $509, more than three times the model-generation bill.

This is the line item many estimates miss.

Not every message needs a new search. Greetings, confirmations, and follow-up questions can sometimes reuse existing context. Query classification and retrieval caching can reduce costs, but only if they do not introduce outdated answers.

The Infrastructure Still Has a Bill

The chatbot also needs an application around the model.

For this example, reserve:

Backend, database and queue: $140
Logs, traces and alerts:      $90

These are planning allowances rather than universal vendor prices.

Your number will depend on traffic patterns, retention periods, cloud provider, availability requirements, and how much conversation data you store.

Add a ten-percent allowance for failed requests, retries, traffic spikes, and evaluation runs:

Metered AI and retrieval: $656.95
Ten-percent headroom:      $65.70
Infrastructure:           $230.00

Estimated monthly total:  $952.65

That equals approximately $0.019 per conversation, or just under two cents.

Build Your Own Cost Calculator

Here is the complete Python calculation:

conversations = 50_000
replies = conversations * 4

luna_calls = int(replies * 0.95)
sol_calls = replies - luna_calls


def model_cost(
    calls,
    input_tokens,
    output_tokens,
    input_rate,
    output_rate,
):
    input_cost = (
        calls * input_tokens / 1_000_000 * input_rate
    )
    output_cost = (
        calls * output_tokens / 1_000_000 * output_rate
    )

    return input_cost + output_cost


luna = model_cost(
    luna_calls,
    input_tokens=1800,
    output_tokens=250,
    input_rate=0.10,
    output_rate=0.50,
)

sol = model_cost(
    sol_calls,
    input_tokens=2500,
    output_tokens=400,
    input_rate=2.00,
    output_rate=10.00,
)

file_search = replies / 1000 * 2.50
storage = (4 - 1) * 0.10 * 30

metered = luna + sol + file_search + storage
infrastructure = 140
observability = 90
headroom = metered * 0.10

monthly_total = (
    metered
    + infrastructure
    + observability
    + headroom
)

cost_per_conversation = monthly_total / conversations

print(f"Monthly cost: ${monthly_total:.2f}")
print(
    "Cost per conversation: "
    f"${cost_per_conversation:.4f}"
)

The output is:

Monthly cost: $952.65
Cost per conversation: $0.0191

Change the conversation volume, token counts, model rates, and retrieval frequency to estimate your own workload.

What This Estimate Does Not Include

The $952.65 total excludes:

• Initial chatbot development
• Customer-support platform fees
• Human review
• Security testing
• Maintenance and evaluation
• Engineering time spent investigating failures

Human escalation may eventually become the largest expense.

If five percent of 50,000 conversations require five minutes of agent review, that creates more than 208 hours of monthly support work.

A chatbot that routes uncertain cases correctly can still be valuable, but those hours belong in the business case.

Regional processing can also change the invoice. OpenAI currently applies a ten-percent uplift to eligible regional-processing and FedRAMP endpoints for newer models.

Ask for the Worksheet, Not One Monthly Number

When evaluating an AI chatbot development company, ask to see the assumptions behind its operating-cost estimate.

You should be able to identify:

• Expected conversation volume
• Model calls and token usage
• Retrieval frequency
• Escalation rate
• Storage requirements
• Failed calls and retries
• Monitoring costs
• Human-review workload

The model price is only one line on the invoice.

For this example, generating answers costs about $148. Finding the information behind those answers costs $509.

That is the cost relationship worth designing around.