How to Read an AI API Free Tier: Six Questions Before You Sign Up

"Free" is the most overloaded word in AI APIs. A monthly compute credit, a requests-per-minute ceiling, and a tokens-per-day allowance that resets at midnight UTC are all called free tiers — and they fit three completely different jobs. Two providers can both advertise "free API access" while one is a research allowance and the other is a rate-limited production sandbox.

These are the six questions we ask before we characterize any free tier, and the answers that actually decide whether you can build on it.

Question 1: What shape is the free grant — credits, limits, or both?

Three shapes recur, and each behaves differently under load.

The practical difference is what happens when you are idle. Rate limits punish idleness: if you do not spend today's requests, they are gone. Dollar credits reward idleness in the wrong direction — they keep their value until you burn them, which is why they are the right shape for a bursty workload and the wrong shape for a continuous one.

If your workload is one large job per week, credits and monthly allowances beat daily resets. If your workload is small and constant, daily resets beat everything, because you never pay.

Question 2: What happens when you add a payment method?

This is the question most people never ask, and it is where free tiers quietly stop being free.

• The tier is sometimes defined by the absence of a card. SambaNova's free tier applies when no payment method is linked: 20 requests/minute, 20 requests/day, and 200,000 tokens/day per model according to its rate-limit documentation↗. Link a card and the account moves to the Developer tier — different limits and different pricing, simultaneously. Verification is not neutral there.
• Adding billing can charge you immediately. Nebius's billing setup charges an initial amount to your card and credits it to the account balance, so the trial period is prepaid spend from the first minute.
• A trial account can expire rather than downgrade. Amazon Bedrock's free-plan account for new AWS customers runs for six months with credits, then the account closes unless you convert to a normal paid account.

Before you add a card "just in case", read what the button does. In several cases it re-categorizes your entire account, which means the limits you evaluated are not the limits you will get.

Question 3: Will the provider train on your prompts?

Data use is where free tiers diverge most, and the answers are stated — if you look for them.

• Google AI Studio's free tier says it plainly on its pricing documentation↗: free-tier content is used to improve Google's products, and the paid tier is where that switches off.
• Anthropic's consumer plans default to training on free usage with an opt-out, while Team and Enterprise default to no training. Check the pricing page↗ for the tier you are on.
• Cohere's trial keys are free but explicitly barred from production or commercial use, per its pricing page↗. The restriction is on what you may do with the output, not on what the provider does with the input.

Two habits follow. First, during evaluation, send synthetic or public data — the free tier is the cheapest way to learn a provider's quality, and the worst place to test its confidentiality. Second, remember that the training clause is tier-specific. "Does this provider train on my data?" is the wrong question; "does it train on my data on the tier I am actually on?" is the right one.

Question 4: Is the cap requests, tokens, or a proprietary unit?

This is the question with the biggest gap between the headline and reality. A "10,000 free tokens" tier and a "10,000 free requests" tier are different universes. For scale: a single agentic conversation can burn 5,000 tokens across two tool calls, so 10,000 tokens is two interactions, while 10,000 requests is a small application.

Three metering styles to expect:

• Requests per minute. NVIDIA NIM's default is 40 requests/minute, with increases available on request. Excellent for many small calls; silent about how much output each call may produce.
• A normalized compute unit. Cloudflare meters Workers AI in Neurons, with a daily free allocation of 10,000 Neurons resetting at 00:00 UTC, per the official pricing documentation↗.
• Per-model token and request ceilings. Groq publishes limits per model — for example 30 requests/minute, 1,000 requests/day and 8,000 tokens/minute on a mid-size open model, per the rate-limit documentation↗. The pool does not transfer between models.

Doing the unit conversion before you plan

Never plan capacity around a metered unit you have not converted. Three worked conversions using published numbers:

Cloudflare Neurons. If 1M output tokens on a given model costs 68,182 Neurons, then the free 10,000 Neurons per day covers:

[object Object]

That is the real allowance, and it is nowhere on the marketing page.

Groq's per-minute token ceiling. At 8,000 tokens per minute across 30 requests per minute, the average request can carry:

[object Object]

The 1,000 requests/day ceiling is more generous than the per-minute token ceiling implies, which tells you the binding constraint is throughput, not request count.

SambaNova's daily token pool. At 200,000 tokens/day across only 20 requests/day:

[object Object]

A 20-request day is not a workload, it is a test suite — but each test can be large, which is exactly the shape that suits evaluation rather than serving.

Question 5: What is the failure mode when you hit the cap?

Three failure modes exist, and they determine how you architect around the tier.

• Hard failure with a retry hint (usually HTTP 429). Your client queues and retries into the next window. Most providers behave this way, including Groq. This is the friendliest mode, because the recovery is local to your code.
• Hard failure until the next reset. A daily pool that resets at 00:00 UTC simply stops serving when exhausted. Anything time-sensitive needs an overflow provider, because waiting is not an option.
• Silent fallback. Aggregators and routers may retry another provider for the same model when one returns 429, per OpenRouter's documented limit behaviour↗. Your code sees success; your costs and your data path may have changed without a log entry.

Production-adjacent work needs a provider whose failure mode you can detect, not merely one whose limit is high. Add the mode to your monitoring before you add the provider to production.

Question 6: Will this tier still exist in three months?

Free tiers have a half-life, and two signals are worth tracking.

• Promotional dating. OpenAI marks its promotional flagship pricing with an explicit "available at least through" date on its pricing page↗, which is effectively an admission that the economics will change. Perplexity has published a sunset date for its Sonar API with a named successor — a reminder that an entire endpoint can be retired on a schedule.
• Quiet churn. Model names get retired and re-routed so that legacy identifiers serve newer models at newer prices, and free model catalogs shrink without a changelog entry. If you built on a model name, you may now be running something else.

Our rule: never build a durable workflow on a free tier you would not still find acceptable at paid prices. The exit path — migrating to a paid plan, or to another provider with a comparable API surface — is the real feature.

The six-question checklist

Fill this in before you write a line of code against a new free tier, and keep it next to your API keys.

If a provider cannot answer all six from its own documentation, that is itself the answer.

How do you compare two free tiers that meter in different units?

You cannot compare "40 requests per minute" against "200,000 tokens per day" by eye, and you cannot compare either against a normalized compute unit. The method is to convert every published allowance into a common unit for your workload, then find out which meter reaches zero first.

Notice how differently these read once converted. The tier with the largest number of requests is constrained by a per-minute token ceiling; the tier with the largest token pool is constrained by a request count small enough to fit on one line.

A worked comparison: one workload against three free tiers

Abstract comparisons hide the decision. Put a concrete workload against the same three tiers.

The workload: 150 support tickets per day, each averaging 1,200 input tokens and 400 output tokens.

• Input tokens: 150 × 1,200 = 180,000
• Output tokens: 150 × 400 = 60,000
• Total: 240,000 tokens per day across 150 requests

Now test it against each tier's published shape.

Three tiers, three different answers, and the interesting part is why each answer differs. SambaNova fails on request count before token count. Cloudflare's constraint is a unit conversion you have to perform before you can answer at all. Groq's constraint is throughput per minute, which is a scheduling problem rather than a capacity problem.

That is the whole technique: do not ask "how big is the free tier?" Ask "which meter reaches zero first for my traffic, and how much work do I have left when it does?"

The five-minute decision: from six answers to a go/no-go

Once the six questions are answered, the decision takes four binary gates and one fit check.

1. Gate: is commercial use permitted on this tier? If no, the tier is an evaluation venue only.
2. Gate: is the card trigger acceptable? If adding a payment method re-categorizes your account into different limits at different prices, decide before you link anything, not after.
3. Gate: is the failure mode detectable? If exhaustion arrives as a silent fallback rather than a signal your code can read, the tier cannot sit in a critical path.
4. Gate: is the exit path real? If the tier disappeared tomorrow, would the paid rate still be acceptable? If not, the integration is a liability with a sunset clause.
5. Fit check: does the converted allowance clear the workload? The worked comparison above is the template. If the binding meter sits inside your daily volume, the tier cannot serve you alone — it can only serve you as one shape in a union of shapes.

A tier that passes all four gates and the fit check can go into production. A tier that fails a gate can still be useful, but only in the role the failure implies: evaluation, prototyping, or burst overflow.

How we verified this

How we verified this (2026-09-17): the limit figures and tier behaviours above were taken from each provider's own pages — the Cloudflare Workers AI pricing documentation, Groq's rate-limit documentation, Cohere's pricing page, Google's Gemini API pricing documentation, Anthropic's pricing page, SambaNova's rate-limit documentation, and AWS's Bedrock pricing pages — on the date shown. Where a provider did not publish a figure on an official page, we describe the behaviour qualitatively instead of quoting a number. All division and unit conversions in this article are our own arithmetic over those published figures; we did not measure latency, uptime, or throughput ourselves for this piece.

Red flags that answer the question for you

A few patterns make the decision quickly:

• The allowance is described in an adjectival unit. "Generous free tier" without a number, or a number with no linked definition, means the limit is discretionary.
• The free tier's limit page is behind a login. You cannot evaluate what you cannot read.
• A single global free bucket across all models. Free requests that silently consume the expensive model's budget can exhaust a month of allowance in an afternoon.
• No published paid prices. If you cannot find the post-trial rate, you cannot compute the cost of success — and success is the scenario that matters.

Where to record the answers, and when to re-check

Put the six answers in the same place you keep credentials, with the date you read them. Then re-check on two triggers: whenever a provider emails about pricing or model updates, and whenever your own error logs show a new failure shape. Free tiers change quietly, and the failure mode usually changes with them.

The token count tells you what the tier is worth this month. The six answers tell you what the tier is worth to your project.