Go to content
Startups

Free Tier Limits from Operating Costs

A free tier needs a budget. Start with the variable cost of one unit of usage. Decide how much you can spend on a free account each month, then divide that budget by the unit cost. That gives you a usage ceiling. Check that the allowance lets someone try the product before you publish it.

Variable cost is the cost that changes with usage: the server time, model inference, bandwidth, or storage that a single request consumes. Fixed overhead is the cost that stays roughly the same whether you serve one user or ten thousand: salaries, base infrastructure, and the support staff who answer tickets. If you set the limit from variable cost alone, you ignore overhead. If you set it from averages alone, you hide the request that costs ten times more than the typical one. The method below handles both, then checks the two problems that will otherwise break the limit: heavy users and abuse.

The numbers in the worked example are hypothetical. Your own unit costs come from your cloud bill and provider pricing, and the calculation is only as good as the numbers you put into it.

Measure the variable cost per unit

The starting point is the unit your meter counts: one API call, one page processed, one million tokens, one gigabyte stored. The meter is the counter that records how much each account consumes. For each unit, compute the marginal cost of serving it, meaning the extra cost of one more unit: the compute time, the model call, the bandwidth, and the storage that unit uses.

For an API that calls a hosted model, the provider’s price list is the raw material of your cost. OpenAI’s pricing page lists per-million-token prices for each model plus storage charges for file search, and AWS pricing describes pay-as-you-go billing with tiered volume discounts on services such as S3. Provider prices are not the same as your costs. Your variable cost per unit is what you actually pay after discounts, caching, and your own infrastructure, and that number belongs in the calculation.

If some of your endpoints cost much more than others, one average number hides the problem. A profile lookup and a PDF export do not cost the same to serve. Guidance on API resource limits recommends setting hard ceilings per endpoint for page size, payload size, and other factors that drive request cost, because a small number of expensive calls can trigger large backend workloads. The same logic applies to cost accounting: measure the expensive endpoint separately and give it its own allowance.

A worked example: a document-processing API

Say the product extracts structured fields from documents. For this illustration, processing costs $0.004 per document. Storage costs $0.10 per GB-month, and each document uses 5 MB for one month. Using decimal units, that adds $0.0005 in storage, giving $0.0045 per document in total. These are hypothetical inputs, not quoted provider prices.

Item Value
Variable cost per document (compute, inference, storage share) $0.0045
Monthly variable-cost budget per free account $1 per month
Free limit before rounding 222 documents (rounded down from $1 ÷ $0.0045)
Rounded free limit 200 documents
Burst rate limit 20 documents per minute, subject to your capacity
Worst-case variable cost per free account $0.90 per month (200 × $0.0045)

The founder decides the free tier should cost at most a chosen budget per account per month in variable cost. Dividing the budget by the unit cost gives the limit. Round down to a round number, and add a rate limit so a single account cannot burn its monthly allowance in one burst. The worst-case variable cost per free account is then the budget.

The limit still lets a user process a meaningful batch of invoices or receipts, and that check matters. A free tier should let someone finish a useful task, because a restriction that blocks all meaningful progress prevents evaluation. If the calculated limit is not enough to demonstrate value, you can reduce the unit cost, raise the budget per free account, or accept that the free tier is a marketing expense rather than one that limits its own cost.

The budget covers variable cost only. Support also needs funding. In this illustration, a ticket costs $20 of staff time and one account in fifty opens one. That averages $0.40 per account. These are assumptions, not an industry benchmark. Combined with the $0.90 usage allowance, the modeled cost is $1.30, so an all-in $1 budget would need a smaller allowance or other funding. The Ficilcom freemium model shows the trap with a fictional monthly example: 1,000 active accounts, 50 of them paid at JPY 1,000 per month and 950 free, variable costs of JPY 20 per free account and JPY 100 per paid account, a 3% payment fee, and JPY 100,000 in fixed costs. After variable costs and fees, the contribution is JPY 24,500. After fixed costs, the month loses JPY 75,500 despite having paying customers. The model breaks even only when paid accounts reach 135, assuming each new paid account replaces a free one: the balance equals 890 times the number of paid accounts, minus 120,000. Ficilcom is explicit that these numbers belong only to these assumptions. The structural lesson is that a free tier that looks cheap per account can still sink the product if conversion is low and fixed costs are high.

Check heavy users and abuse, not averages

The limit from the calculation is a per-account ceiling, and per-account ceilings have two known failure modes.

The first is that averages hide heavy users. The median free account might process 10 documents per month while the 99th percentile processes far more. If the limit is set from the average, the heavy users blow through the budget. Set the limit from the high end of usage, and recheck that high end after the limit ships, because users adapt to limits. The stability risk is real: guidance on API resource limits notes that without resource limits, a small number of calls can trigger large backend workloads, causing slow responses, timeouts, service instability, and unexpected cloud spend.

The second problem is that per-account limits can be bypassed by creating many accounts. In one practitioner’s account of an API abuse incident, an attacker used 200 legitimate accounts to rotate requests against an expensive PDF-report endpoint and drove a $12,000 AWS bill in a single week. The fix was multi-dimensional rate limiting, including cost-based limits: each endpoint gets a cost in points, such as profile=1, search=5, analytics report=50, and PDF export=100, and each user gets a budget of points per hour. A budget of 1,000 points allows 1,000 cheap requests, 10 expensive ones, or a combination. The same idea applies to the free tier: if the expensive endpoint is the abuse target, give it a separate, lower allowance.

Per-account limits also need a global safety net. Guidance on differentiated quotas recommends applying a global rate limit first, then overriding it with lower-level controls for specific consumers, routes, or tenants, and warns that quotas can grow over time: temporary exceptions often become permanent. Broad overrides are harder to audit and easier to misuse, so the narrowest scope that matches the need is the right one.

Turn the limit into a paid path

The free limit is only half the design. The other half is what happens when a user hits it. The cleanest mechanism is usage-based billing: the free tier is an allowance included in the price, and usage beyond it is metered and billed. Stripe’s usage-based billing documentation describes metered billing where a subscription includes a quantity of usage and the provider reports the customer’s usage to the billing system, which invoices for what the customer used. This connects the free limit directly to revenue: the same counter that enforces the free allowance feeds the bill.

Two decisions matter here. The first is metering accuracy: the enforcement counter and the billing counter must be the same number. If the enforcement counter and the billing counter disagree, the user gets a bill they did not expect. The second is the hard cap. Alguna’s SaaS pricing guide recommends hard caps, spending alerts, and usage dashboards to prevent bill shock, because usage-based pricing shifts cost uncertainty onto the customer. A hard cap stops service at a threshold; a soft limit warns and lets the user continue, which risks a bill the user did not approve.

Pick the limit type that matches what costs you money. DigitalAPI’s guide to API free tiers lists the common limit models: rate limits such as 1,000 calls per day, feature limits, time limits, data limits, and project limits. If storage drives cost, limit storage. If compute drives cost, limit calls. The free tier should be generous enough to demonstrate value but restrictive enough that professional or high-volume users hit the ceiling, which creates the upgrade pressure. The paid tier then needs to be priced so that a user who hits the ceiling finds it cheaper to pay than to work around the limit.

The free tier should also map to a specific paid benefit. If the free limit is measured in documents per month, the paid tier should offer something concrete beyond more documents: higher rate limits, priority processing, longer retention, or support. Otherwise the upgrade is just a meter running, and users will resent it.

Revisit the numbers as costs and conversion change

The calculation is only as good as its assumptions, and the assumptions change. Provider prices change, your infrastructure changes, and usage patterns shift as users adapt to the limit. The Ficilcom model is explicitly fictional and not a market benchmark, and the abuse incident above is one practitioner’s experience, not a controlled study. Treat both as illustrations of mechanism, not as evidence about your product.

The biggest unknown is conversion. The whole model assumes free users become paid users at some rate, and that rate is a guess until you have data. Ficilcom’s freemium model distinguishes current account mix from cohort conversion: 50 paid out of 1,000 accounts is a current mix, while a 5% thirty-day conversion means 50 first paid upgrades among 1,000 new free registrations that all completed a thirty-day window. If you count users who have not yet had a full thirty days, they look less likely to convert, so track cohorts, not just the current mix.

Revenue per tenant, meaning per customer account, also does not show profitability. Tenant cost allocation guidance notes that you need cost per tenant, and describes two levels of detail: coarse allocation divides total cost by total usage, while fine-grained allocation tags resources per tenant. For the free tier decision, the coarse version is the minimum: total cost of serving free users divided by the number of free users, compared against the conversion value those users produce.

If you set the limit too high and need to lower it, existing users will notice. A restriction that blocks work they already depend on creates support tickets, and the support cost can eat the savings. Plan the communication and transition before changing a limit, and consider letting existing accounts keep their old limit.

Key takeaways for setting free tier limits

  • Compute the variable cost per unit first: measure the marginal cost of one API call, document, or token from your actual cloud bill and provider pricing, and treat expensive endpoints separately.
  • Divide your per-account budget by the unit cost: if you can absorb a chosen budget per free account per month and each unit costs a known amount, the free limit is the budget divided by the unit cost, rounded down.
  • Set limits from the usage tail and add a global ceiling: averages hide heavy users, and per-account limits can be bypassed with many accounts, so combine per-account limits with global and cost-based controls.
  • Meter the same counter you bill from: feed the enforcement counter into usage-based billing so the free allowance and the paid overage are the same number.
  • Recheck the model as costs and conversion change: provider prices, infrastructure, and cohort conversion rates all shift, and the calculation is only as good as its assumptions.
More in Startups Back to top ↑