Free tier cost control for LLM apps: unit economics that survive growth

Quick answer: meter tokens, cap spend, split models by tier.

Classic SaaS intuition says a free user costs nearly nothing to serve, so the free tier is a marketing expense you never meter. That intuition is wrong for AI products. Every free message hits a paid inference API, which makes the free tier a cost-of-goods line that scales exactly as fast as your signup chart. Three controls do most of the work. First, meter tokens, not messages: a message cap does not bound cost, because one message can carry a pasted 100-page document. Second, split models by tier: serve free users on a budget model like deepseek-v4-flash and keep the flagship for paid plans, which cuts the unit cost by up to 50 times at identical usage. Third, enforce a hard per-user token budget in your own middleware, before the request leaves your server, so the worst case per account is a number you chose in advance. With those three in place, the worked profile below prices a typical free user at about $0.014 a month on a budget model and about $0.70 on a flagship. The rest of this page walks through where the money goes, a full 10,000-user table, the free-tier designs that actually hold, and the middleware that enforces the budget.

Where free-tier money actually goes.

Input tokens usually dominate. Your system prompt, retrieved context, and accumulated history are resent on every single call, while the visible answer is a few hundred tokens. That is why two free users with identical message counts can differ in cost by a factor of fifty: one asks short questions in fresh chats, the other pastes documents into a month-long thread. The uncomfortable part is that none of this is offset by revenue. A paid user who burns extra tokens compresses your margin; a free user who burns extra tokens is pure loss. That asymmetry is the whole reason free-tier cost control deserves its own design work instead of a copied message cap.

• The system prompt is resent with every message: 1,500 tokens of instructions and brand voice becomes 60,000 billed input tokens per user per month at 40 messages.
• Chat history compounds: each turn carries the turns before it, so a long free conversation quietly costs a multiple of a short one at the same message count.
• RAG context rides along: retrieved chunks are often several times the size of the question they answer, and they bill as input on every call that includes them.
• Output verbosity is a setting you pay for: an unconstrained model happily writes 800 tokens where 150 would do, and output tokens price at 2 to 6 times the input rate.
• Retries and regenerations bill in full: every "try again" tap is a complete second request carrying the whole context.

Worked example: what 10,000 free users cost per month.

Put real numbers on it. Assume an average free user sends 40 requests a month, and each request carries about 2,000 input tokens (system prompt, retrieved context, recent history) and returns about 400 output tokens. That is 80K input and 16K output tokens per user per month, which matches a modest chat or writing assistant with a trimmed context window. The table prices that identical usage profile across models a SaaS would realistically ship. Nothing changes between rows except the model ID, and the monthly bill for the same free tier spans $141 to $7,040.

Why free-tier costs blindside SaaS operators.

Run the margin math on the worked table and the danger is obvious. Say 10,000 free users convert at about 3 percent, giving 300 subscribers at $15 a month, or $4,500 of MRR. On gpt-5.5 the free tier alone costs $7,040: the giveaway outspends every dollar of revenue before you pay for anything else. On deepseek-v4-flash the same free tier costs $141, about 3 percent of revenue, which is a rounding error you can grow on. Same product, same users, same conversion rate. The difference between "our free tier is a growth engine" and "our free tier is killing us" is almost entirely model routing plus a working cap.

• Zero-marginal-cost habits: teams price the free tier as a marketing expense, skip metering at launch, and only discover per-user COGS when the first real invoice lands.
• Message caps are not cost caps: a "20 messages per day" limit lets one user paste a book chapter into every message and cost fifty times the average account.
• Context grows silently: message 30 in a thread can carry ten times the input tokens of message 1 while looking identical in your analytics.
• Free tiers attract scripted abuse: burner emails farm accounts and resell or automate access, and the traffic reads as growth in the dashboard while it drains the budget.
• The flagship-model default: launching the free tier on the same model as the paid tier feels fair and demos beautifully, and it is usually the single most expensive decision in the product.

Free-tier designs compared: caps, budgets, credits, gates.

There are five workable designs, and most healthy AI products combine two of them: a cost-side control (what each account may burn) and a model-side control (what each tier is allowed to run). Pick based on how predictable you need COGS to be and how much billing UX you can afford to build.

Seven levers that actually cut free-tier COGS.

The second and sixth levers compound, because both multiply into every token your growth generates. One gateway option for the sixth is APIsRouter, an OpenAI-compatible API with pay-as-you-go billing and no subscription: global models are priced 20% below official list, Chinese models sit below their official rates, the first top-up adds +100% balance, and the /topup checkout takes payment first and emails the key. At free-tier volumes the absolute savings start small; the point is the discount applies to a bill that scales with signups. Sequence matters less than coverage. Model gating plus a token budget removes most of the downside on day one, and caching, signup gating, and outlier alerts each claw back a slice of what remains.

• Meter tokens, not messages. Log usage.prompt_tokens and usage.completion_tokens from every response and debit a per-user budget. A message cap without a token cap is decoration.
• Split models by tier. Free on deepseek-v4-flash or gpt-5.4-mini, paid on claude-sonnet-4-6 or gpt-5.5. The quality gap becomes your upgrade pitch instead of your cost problem.
• Cap the context you send. Truncate history to the last few turns, summarize older ones, and set a low max_tokens on free requests. Nobody needs an 800-token answer on a free plan.
• Cache what repeats. Identical onboarding prompts and template requests can be served from a response cache, and provider-side prompt caching discounts the resent system prompt.
• Gate signup enough to stop farming. Verified email plus per-IP and per-device rate limits shuts down the burner-account scripts that quietly become your biggest traffic source.
• Lower the unit price itself. Route free-tier traffic through a cheaper OpenAI-compatible endpoint so the same model IDs bill below list price.
• Alert on outliers. A daily job that flags any free account above the 99th percentile of spend catches bugs and abuse while they cost dollars, not thousands.

Config: a hard per-user token budget in one middleware.

Enforce the budget where requests originate. Provider dashboards cap your whole account, not one abusive free user, so the check has to live in your own request path: read the tier, deny before calling the API if the budget is spent, route the model by tier, and debit real usage from the response. The example below uses the OpenAI SDK against an OpenAI-compatible base URL, so the same code serves both tiers with different model IDs. Verify the endpoint and the free-tier model with a one-off request before wiring it into the app:

from openai import OpenAI

client = OpenAI(
    base_url="https://api.apisrouter.com/v1",
    api_key="sk-APIsRouter-...",
)

TIER_MODELS = {"free": "deepseek-v4-flash", "pro": "claude-sonnet-4-6"}
FREE_MONTHLY_TOKEN_BUDGET = 150_000  # about $0.02/month at flash rates

def chat(user, messages):
    if user.tier == "free" and user.tokens_this_month >= FREE_MONTHLY_TOKEN_BUDGET:
        raise BudgetExceeded("Free limit reached. Upgrade to continue.")

    resp = client.chat.completions.create(
        model=TIER_MODELS[user.tier],
        messages=trim_history(messages, max_turns=6),
        max_tokens=400 if user.tier == "free" else 2000,
    )
    usage = resp.usage
    user.add_tokens(usage.prompt_tokens + usage.completion_tokens)
    return resp.choices[0].message.content

FAQ