How to stay within free-tier rate limits (without paying)

The short answer

Free tiers fail people for predictable reasons: unknown caps, blind retries and single-provider dependence. Fix all three — learn each provider's verified limits (e.g. OpenRouter 20/min and 50/day, Groq's published per-model table at 30/min and 1,000/day, Cohere's 1,000 calls/month), treat 429s with exponential backoff (failed requests can count against quotas), cache and batch aggressively, and spread workloads across providers whose quotas are independent.

A free allowance is not a service-level guarantee. The teams that live comfortably inside one do three things differently: they know their numbers, they respect the 429, and they never depend on a single quota.

1. Know the actual numbers (not vibes)

The verified caps as of our last check — each offer page links the primary source:

  • OpenRouter: 20 requests/min, 50 ‘:free’ requests/day (1,000/day once you’ve ever bought $10 of credits).
  • Groq: published per model, e.g. openai/gpt-oss-120b at 30 requests/min, 1,000 requests/day, 8K tokens/min, 200K tokens/day.
  • Cohere: 1,000 calls/month shared across the key, with per-endpoint caps (Chat 20/min, Rerank 10/min). Check the current trial Embed limit in your dashboard.
  • Cloudflare Workers AI: 10,000 Neurons/day, resetting at 00:00 UTC — but note that eight large third-party models require a paid billing method and won’t run on the free allowance at all.
  • Gemini API: per-model limits that vary by usage tier — check them in AI Studio for your account rather than trusting a blog’s copy-paste.

Write these into your config as constants with a comment linking the source. When a limit is “not published”, treat the number you observe as the number.

For the same numbers laid out side by side, with what each provider actually meters, see free LLM API rate limits compared.

2. Treat 429s as a protocol, not an error

Retry with exponential backoff and jitter, cap total attempts, and distinguish retryable (429, transient 5xx) from non-retryable failures. This matters doubly on platforms where failed requests count against the quota — OpenRouter states that “Failed attempts count toward that daily cap” — so a naive retry loop can convert one bad request into a burned day. Where reset timing is known (Cloudflare resets at 00:00 UTC), schedule deferred work for the reset instead of polling.

3. Spend fewer tokens per outcome

  • Cache aggressively: identical prompts should never hit the API twice.
  • Batch: one request with ten items beats ten requests on request-metered tiers (OpenRouter, Groq’s RPM/RPD); on compute- or token-metered tiers (Cloudflare’s Neurons, Groq’s tokens per minute), the math flips — mind the meter instead.
  • Right-size the model: free tiers often include smaller variants whose quality is fine for classification, extraction or routing; save the big model for the calls that need it.
  • Trim prompts: system-prompt bloat is pure quota tax on token-metered tiers.

4. Route across independent quotas

The strongest tactic is architectural: hold one account with several providers and route by workload — volume and speed to Groq, variety to OpenRouter, embeddings to Cohere, edge inference to Cloudflare — with a fallback chain for 429s. Every quota listed above is independent, and holding all the keys costs nothing. The combining guide covers what’s legitimate (many providers) versus what isn’t (many accounts at one provider).

5. Upgrade honestly when you outgrow it

When you’re engineering around limits weekly, the cheap exits are: OpenRouter’s one-time $10 unlock (20x the daily allowance), Groq’s paid Developer tier (Groq asks for a payment method when you upgrade), or a cloud trial credit for a bounded burst. That’s cheaper than the engineering time spent squeezing a free tier — and keeps your accounts clean.

The offers in this guide

Frequently asked questions

What happens when I hit a free-tier rate limit?
Requests start failing with HTTP 429 until the window resets — per minute, per day (Cloudflare resets daily at 00:00 UTC; Groq publishes per-day caps) or per month (Cohere). On a free-only plan requests may stop; a billing-enabled account can instead incur paid usage under its terms. On some platforms failed requests still consume quota, which is why blind retries make the problem worse.
Where do I find the real limits for each provider?
Groq publishes a per-model table in its docs; OpenRouter documents 20/minute and 50/day (1,000/day after a $10 lifetime purchase); Cohere documents 1,000 calls/month with per-endpoint caps. Google's Gemini free-tier limits vary by usage tier and are shown inside AI Studio rather than published. Our offer pages link each source and carry a last-verified date.
Is it OK to spread one app across several providers to get more free capacity?
Yes — routing different requests to different providers you hold one account with is ordinary engineering. What breaks terms of service is multiplying accounts on a single provider to reset its quota.