uprouter — categories

Subscription AI API Routers

42 AI API subscriptions with documented plans — flat monthly prices, bundled API credits, and the breakeven math that tells you when flat beats per-use.

Free tiers & credit values, verified
Normalized pricing across providers
Live uptime probes — no pay-to-rank
Community corrections & reviews

Explore the directory

directory — subscription-router

$ uprouter directory --scope subscription-router
→   42 entries · 28 free tiers · $2.12 in free credits
→   2 live now · ordered by free-credit value

  # a data sort, never sponsored — every row links
  # to its full entry with sources + verification date

entries

free credits

$2.12

live now

routers 42 free-tier 28 free credits $2.12 live up 2 scope subscription-router

// community-regulatedthe ranking is earned, never bought

Every entry answers to the community

The index is expansive; the community keeps it honest. Votes, reviews and verified corrections feed straight back into rankings and data confidence.

Vote
Upvote routers that deliver, downvote the ones that don’t — the score re-ranks the index.
Review
Evidence-based reviews with verification tags. Ratings, not vibes.
Verify
Corrections that survive review flip the entry to verified — with the evidence on file.

Join & start voting See community activity →

Anyone can edit this index

Every router page has an edit button — propose corrections to descriptions, prices and free tiers. Editors review each proposal against primary sources before it goes live.

Propose
Open a router page, hit the edit button, and detail your proposed corrections.
Review
Editors rigorously verify every proposed correction against primary sources.
Live
Accepted edits are published instantly and logged in the public journal.

Browse the index → pick edit

// directory

The directory

filtered to subscription router

$ 42 entries match — showing the top 9 · sort: Free credits ↓

Subscription routerAPI keyOAuth
up726msupdated 21h ago
platform.kimi.com
source · kimi.com/code
overview
platform.kimi.com is the Kimi (Moonshot AI) open platform; the China-facing site quotes CNY while the published USD price list is at platform.moonshot.ai/docs/pricing/chat. Kimi K3 is listed at $3.00 per 1M input tokens (cache miss), $0.30 cached input and $15.00 output with a 1,048,576-token context; K2.7 Code is $0.95 / $0.19 / $4.00 and K2.6 is $0.95 / $0.16 / $4.00, both with 262,144-token contexts. The API is paid prepaid usage rather than subscription, and the only free grant documented is an exchange voucher of 15 CNY issued after identity verification, which the docs state cannot be spent on Kimi K3.
free quota
Official docs state a 15 CNY voucher is granted after personal or enterprise identity verification (platform.kimi.com/docs/guide/account-and-payments), converted at roughly 7.1 CNY/USD; the same page states the voucher cannot be used on Kimi K3.
free models
Kimi K2.7 Codekimi-k3
see platform.kimi.com’s free quota / risk review →
Subscription routerWeb cookie
unknownupdated 28d ago
hyperagent.com
source · hyperagent.com/docs/billing/plans
overview
HyperAgent (hyperagent.com) — fleet-of-AI-agents platform (research, docs, sites, decks, video). Plans convert monthly price 1:1 into spendable credits (up to 45% bonus); agents draw on hosted LLMs (Claude, ChatGPT, Kimi, etc.). Unofficial browser/cookie integration.
free quota
Every dollar of plan price returns as credit (1 credit = $1 of model spend); higher tiers add 10-45% bonus. Pay-as-you-go discontinued Aug 2026; top-ups via credit blocks.
free models
Claude Opus 4.5GPT-5.1kimi-k3HyperAgent
see hyperagent.com’s free quota / risk review →
Subscription routerWeb cookie
unknownupdated 28d ago
notion.so
source · notion.com
overview
Notion AI (notion.so) embeds multi-model LLM access into the Notion workspace (Notion Agent, AI blocks, Enterprise Search, Research Mode). Model vendors are not individually named publicly (FAQ states Notion charges tokens at each provider's published rates, no markup), so no catalog models are linked. Free/Plus plans get only a limited trial of complimentary AI responses; full Notion AI requires Business/Enterprise with a usage allowance, and premium models spend Notion credits ($10 per 1,000 monthly credits). This route is an unofficial web integration using the token_v2 cookie from app.notion.com.
free quota
Notion credits: $10 per 1,000 monthly Notion credits (notion.com/pricing) -> $0.01/credit.
free models
— none tracked
see notion.so’s free quota / risk review →
Subscription routerOAuth
unknownupdated 28d ago
qoder.com
source · qoder.com/pricing
overview
Qoder - AI coding IDE (Agent/Quest modes) with credit-based plans; Free tier (2-week Pro trial with 300 credits, limited completions/NES, BYOK); Pro/Pro+/Ultra; Credit Pack; per-model cost varies by tier multiplier (Auto approx 1.0x, Ultimate approx 1.6x, Performance approx 1.1x, Efficient approx 0.3x now free for paid, Lite free); context options 200K/400K/1M.
free quota
Plan quota approx subscription value (approx USD 0.01/credit). qoder.com/pricing headline shows Pro at 4,000 credits incl. a 2,000 first-purchase bonus; docs base is 2,000 credits/mo.
free models
qwen3.8-maxQwen3.8 Flashqwen3.7-MAXdeepseek-v4-proDeepSeek V4 Flashglm-5.3+4
see qoder.com’s free quota / risk review →
Subscription routerWeb cookie
unknownupdated 28d ago
app.innerai.com
source · innerai.com/en
overview
Inner AI (innerai.com / app.innerai.com) is a multi-model AI productivity app (chat, image/audio/slide generation, custom assistants). Access via this route is an unofficial web-cookie integration (token cookie + account email). Official pricing page documents Lite and Pro plans with GPT-5 Mini/DeepSeek 3.1 +5 fast models, GPT-5/Claude 4.6 Sonnet +5 advanced models, and credit-based generation (Nano Banana, ElevenLabs, Gamma +25). Third-party sources report a 7-day free trial/money-back guarantee rather than a perpetual free tier.
free quota
Derived: Pro plan ($15/mo) includes 10,000 monthly generation credits (pt innerai.com/pricing) -> ~$0.0015/credit.
free models
Eleven v3DeepSeek V3.1gpt-5claude-sonnet-4-6nano-banana-2
see app.innerai.com’s free quota / risk review →
Subscription routerAPI keyOAuth
unknownupdated 26d ago
cursor.com
source · cursor.com/pricing
overview
Cursor is an AI code editor sold on self-serve plans: Hobby is free, the $20/month individual tier (listed as Individual on the pricing page and as Pro in the docs) adds extended Agent limits and frontier models, Pro Plus is $60/month, Ultra is $200/month, and Teams is $40/user/month Standard or $120/user/month Premium with Enterprise as custom. Hobby requires no credit card and lists limited Agent requests and access to Composer. Cursor states there are two usage pools - Cursor Models for Grok 4.6, Grok 4.5 and Composer 2.5, and Other Models for third-party models billed at API price - and that Teams and Enterprise add a $0.25 per million token Cursor Token Rate on third-party model requests.
free quota
Cursor Hobby is free with no credit card required, limited Agent requests and access to Composer (cursor.com/pricing, checked 2026-09-16).
free models
gpt-3.5-turboAnthropic: Claude 3.5 SonnetGPT-4oGPT-5.6 Terra ProGPT-5.6 Luna ProGPT-5.5 Pro+8
see cursor.com’s free quota / risk review →
Subscription routerAPI keyNo authOAuthCloud agent
unknownupdated 26d ago
devin.ai
source · docs.devin.ai/cli
overview
Devin, built by Cognition, is an agentic software engineering product spanning Devin Desktop, a CLI, Devin Cloud agents, DeepWiki and the Devin API, aimed at multi-repo engineering work such as migrations, PR review, incident triage and scheduled chores. Its pricing page lists Free at $0 with "a light quota to code with agents", limited model availability, unlimited inline edits and unlimited Tab completions, then Pro at $20/month, Max at $200/month for significantly higher quotas, Teams at $80/month for the team plan plus $40/month per full dev seat, and Enterprise by contact. Paid plans come with a usage allowance that refreshes daily and weekly, and usage beyond the allowance is purchased and consumed at API pricing.
free quota
Devin Free is $0 with a light agent quota, limited model availability, unlimited inline edits and unlimited Tab completions (devin.ai/pricing, checked 2026-09-16).
free models
Claude Sonnet 4.5Claude Opus 4.5GPT-5.5 ProGemini 3.8 FlashDeepSeek V3.2kimi-k3+3
see devin.ai’s free quota / risk review →
Subscription routerOAuth
unknownupdated 26d ago
copilot.github.com
source · features/copilot/plans
overview
GitHub Copilot is GitHub's AI coding assistant, sold to individuals as Free ($0), Pro ($10/user/month), Pro+ ($39/user/month) and Max ($100/user/month), and to organizations as Business ($19/user/month) and Enterprise ($39/user/month). The Free tier needs no credit card and lists 2,000 completions per month, access to Claude Haiku 4.5 and GPT-5 mini "and more", the Copilot CLI and community support; GitHub's own FAQ on the same page states Free users are limited to 2,000 completions and 50 chat requests per month, including Copilot Edits. Paid individual plans add unlimited code completion and next edit suggestions, cloud agent, code review, delegation to third-party agents (Claude Code and Codex), model selection and monthly GitHub AI Credits of $15 (Pro), $70 (Pro+) and $200 (Max).
free quota
GitHub Copilot Free is $0/user/month with 2,000 completions and 50 chat requests per month and no credit card required, stated on github.com/features/copilot/plans and its Free-plan FAQ (checked 2026-09-16).
free models
Google: Gemma 4 31B (free)Google: Lyria 3 Clip PreviewGoogle: Gemma 4 26B A4B (free)Google: Lyria 3 Pro PreviewOpenAI: GPT-5 Nano (batch)OpenAI: gpt-oss-20b+160
see copilot.github.com’s free quota / risk review →
Subscription routerAPI keyOAuth
unknownupdated 26d ago
docs.gitlab.com
source · docs.gitlab.com/user/duo_agent_platform/code_suggestions
overview
GitLab Duo is GitLab's set of AI features across the software lifecycle, including AI chat and code suggestions in the IDE, agentic chat, foundational agents and flows, a custom agent catalog, model selection and MCP integrations. GitLab's pricing page lists GitLab.com Free at $0/user/month with up to 5 users in a private top-level group, 400 compute minutes per month, 10 GiB storage and static application security testing, but states plainly that on Free "AI features can be accessed via the purchase of GitLab Credits add-on". Included AI credits appear only on paid tiers, shown as a limited-time promotional offer: $12 GitLab Credits per user/month on Premium ($29/user/month billed annually) and $24 per user/month on Ultimate, with GitLab Credits priced at $1 per credit.
free quota
GitLab.com Free is $0/user/month but includes no AI credits: the pricing page states AI features on Free are accessed only by purchasing the GitLab Credits add-on at $1 per credit, so the free AI grant is zero (checked 2026-09-16).
free models
claude-sonnet-5gemini-3.1-pro-previewClaude Sonnet 4.5Claude Haiku 4.5
see docs.gitlab.com’s free quota / risk review →

Open the full directory →

// sources & references

Sources & references

Claims on this page are checked against the providers’ own pricing and policy pages (verified 2026-10-12) and against the UPROUTER public dataset.

Pricing Mistral — Pro plan $14.99/mo with $15–25.50 of API credits; Large at $0.50/$1.50 per 1M — the worked breakeven example
Pricing Modal — Subscription shape: plan tiers with monthly free compute (Starter includes $30/mo)
Inference Providers documentation Hugging Face — Platform subscription (PRO) with monthly credits for partner inference; "no extra markup" routing
Copilot — plans & pricing GitHub — Copilot Free ($0, 2,000 completions/mo) and paid tiers with pooled API credits ($15/$70/$200) — the worked $0-plan and credit-pool examples
Usage policies OpenAI — No sharing or reselling of access — the key-sharing policy FAQ
Public dataset (CSV, CC BY 4.0) UPROUTER.ONLINE — The {count} entries, plan prices, bundled-credit values, access types and verification dates
About & methodology UPROUTER.ONLINE — How plan price + bundled allowance are normalized to USD and what _est._ marks

// top free allowances

Top free allowances in the Subscription router category

ranked by data, never sponsored

The largest free allowances in the Subscription router category, ranked by normalized free-credit value — a data sort, never sponsored. Values are USD estimates derived from each provider's published signup bonuses, monthly quotas and usage allowances at pay-as-you-go rates; where a figure required an assumption it carries an est. marker.

Up to eight AI API routers with the largest tracked free allowances, ranked by normalized free-credit value
#	Provider	Category	Free credits	Access	Status
1	Kimi	Subscription router	$2.10est	API key	up· 726 ms
2	Notion AI Web (Unofficial/Experimental)	Subscription router	$0.01	Web cookie	unknown
3	Qoder	Subscription router	$0.01	OAuth	unknown
4	Cursor API	Subscription router	$0	API key	unknown
5	Devin Desktop	Subscription router	$0	OAuth	unknown
6	GitHub Copilot	Subscription router	$0	OAuth	unknown
7	GitLab Duo PAT	Subscription router	$0	API key	unknown
8	Amazon Q	Subscription router	not quantified	OAuth	unknown

Free tiers change without notice — confirm current API limits on the provider's official pricing page before you rely on them.

See the full filtered directory →

// free vs. paid

Free AI API key vs. paid AI API: which one do you need?

how to choose

A free AI API key is the right starting point for prototypes, hobby projects, model evaluations and low-volume production — you test models and integration paths with $0 of your own spend. A paid API key buys headroom: higher rate limits, priority capacity, SLAs and first access to new models.

Comparison of free AI API keys, paid AI API keys and the UPROUTER directory as a decision tool across cost, limits, model access, failure mode and best use
Dimension	Free AI key	Paid AI key	Uprouter directory
Cost	$0 until the allowance runs out	Per-token or per-plan billing	$0 — the directory itself
Limits	Quotas, API rate limits, expiry	Vendor SLA & priority capacity	Shows each provider’s current limits
Models	Free subset of the catalog	Full catalog	The whole catalog, cross-searchable
Failure mode	429 when the quota is dry	Downtime	Live probes flag dead endpoints
Best for	Prototypes, evals, low volume	Production at scale	Choosing which key to use

The hybrid pattern works well in practice — and it's exactly what this index is for: compare a free allowance against the paid headroom for the same models, check the live status before you commit, and see the break-even point in writing. Every entry records both the free tier and the paid pricing, so the free-versus-paid decision is data, not guesswork.

// one key, every provider

Keep every free AI key working

live status, on every entry

The problem with five free AI keys is not the cost — it's the drift: allowances change, rate limits tighten, and endpoints go quiet without any notice. The index tracks all of it: every entry records the current free tier, its credit value, the paid fallback price, and a live status probe that runs on a schedule so a dead endpoint is flagged before it costs you an afternoon.

That is how a stack of free keys stays useful: you know which allowance expires next, which endpoint just started failing, and what the paid price looks like when you outgrow the free tier — on one screen, with no login required.

status — live board

$ open /status

→ live uptime board, no account needed

# every endpoint probed on a schedule —

# up / degraded / down with the last-seen time,

# plus a per-entry board on each router page

// this page — liverecomputed on every request

routers

free tiers

free credit value

$2.12

live now

Recomputed from the live AI provider directory on every request — counts shift as providers change their tiers and pricing.

// tldr

TL;DR

the short version

42 entries whose primary billing contract is a flat plan — a monthly price for a bundle of access: API credits, generation allowances, or a usage cap. The directory records the plan price and the bundled value separately, both normalized to USD.
The core question is breakeven: a flat plan wins when your predictable usage exceeds the point where per-use rates cost the same as the subscription — and loses badly when usage is spiky, because flat pricing pays for capacity you did not use.
Two plan shapes dominate: credits inside a plan (e.g. Mistral Pro at $14.99/mo with $15–25.50 of API credits — the breakeven is arithmetic) and capped access (a flat price for a usage ceiling).
Caveat: plan terms — rollover, per-seat rules, behavior at the cap — are per-provider contracts. The entries carry the documented shape; the provider's page outranks this one.

// the subscription-router guide

What a subscription router is (and why it is its own category)

The category is defined by the billing contract: time, not usage. The 42 entries here charge a flat plan price — monthly, usually — in exchange for a bundle: a quantified API-credit allowance, a generation quota, or a capped rate of access. That is a different risk profile from per-use metering (where cost tracks tokens exactly) and from one-time free grants (where the budget stops at zero). Subscriptions exist because some buyers would rather pay for predictability: a fixed invoice, a known ceiling, and — in creative products — a simpler consumer relationship than a meter.

Two plan shapes do most of the work. Credits-inside: the plan purchases an API-credit allowance that is then consumed at the provider's published per-use rates — Mistral's Pro plan is the clearest documented example, $14.99 per month with $15–25.50 of API credits included. Capped access: the plan is a usage ceiling itself — a daily generation allowance on a creative product, a monthly quota on a developer platform — where the "credits" column on the entry is the quantified value of that ceiling at the provider's own published rates. Both shapes are tracked; the entry's credit note says which one applies.

The breakeven math, worked with real published numbers

The decision is arithmetic once you have three numbers: the plan price, the per-use rates, and your predictable monthly usage. Worked on verified published figures (checked 2026-10-12): Mistral Pro at $14.99 per month includes $15–25.50 of API credits; the same provider's Large model is priced at $0.50 per 1M input and $1.50 per 1M output. The bundled allowance therefore buys the equivalent of roughly 30M input tokens, 10M output tokens, or a mix between them — so a predictable workload that would spend $15–25 of per-use tokens a month at the same model quality is cheaper on the plan, and a workload spending less is more expensive. The spread between $15 and $25.50 is itself information: the plan's value is a range until the provider fixes the bundle, and the entry records the documented shape.

Two other documented shapes complete the picture. Modal's pricing page documents plan tiers with monthly free compute (its Starter tier includes $30 of compute per month) — the subscription buys capacity that is then consumed like any metered resource. Hugging Face's inference-providers documentation describes a PRO subscription with monthly credits for partner inference at "no extra markup" — the platform subscription unlocks metered access to multiple providers through one key. Common thread: the plan is a purchase of consumption headroom, and the breakeven is your usage against that headroom's value.

What flat pricing buys you — and what it quietly takes

Flat pricing buys a predictable invoice, usually higher rate allowances than the bare per-use key, bundled access to a model roster, and simpler key setup. It quietly takes three things, and all three are terms questions rather than data questions. First, you pay for the ceiling, not the use: an idle month bills the same as a full one, which is fine for a steady service and expensive for a seasonal or experimental workload. Second, unused-allowance handling varies — some plans let credits roll over, some expire them at the period boundary, and "not documented" should be budgeted as "expires". Third, per-seat and per-key rules: team plans price seats, and using one key across many independent services collides with provider policies (the key-sharing question in the FAQ) before it collides with anything else.

The cap behavior is where flat plans differ more than their list prices do. A hard stop (an error at the limit), an overage (per-use billing beyond the plan, where documented), and a soft throttle (slower queue at the limit) are three different products wearing the same monthly price — and the one your users feel is whichever the provider implements. The entry notes carry the documented behavior where the provider publishes it; the free tier or the first cycle of the smallest plan is how you verify the rest.

Free plans are plans too

Several entries in the category run a $0 tier, and 28 carry a quantified allowance. The clearest documented shape is a capped developer plan: GitHub Copilot's Free tier is $0 with a monthly allowance of 2,000 completions on smaller models, and its paid tiers (Pro $10, Pro+ $39, Max $100 per user per month) add pooled API credits — $15, $70 and $200 respectively — on top of the seat price, per the plans page cited below. "Free" here is a plan with caps, and the cap is the product: it defines who the tier is for (individuals, prototypes) and who it is not for (a service account calling it continuously). Reading the cap, not the price, is what makes the free row on this page useful.

Choosing a subscription plan: the criteria that separate them

Three numbers decide it. One, your predictable monthly usage in tokens or generations — from logs, not from hope. Two, the plan price against that usage at per-use rates: the breakeven line; a plan cheaper than your predictable per-use spend at the same model quality wins on cost, and the worked example above shows the arithmetic on published figures. Three, the cap shape — hard stop, overage, or throttle — because the limit behavior is the plan's actual contract and it varies more between providers than the list price does. Then the terms: rollover, seat rules, commercial-use rights, cancellation — carried on the entry where the provider publishes it, and checked at the provider's page before you commit.

What this page does not decide: whether your volume is genuinely predictable (only your history says), whether the plan's model roster covers your task (the entry's tracked model list is the current answer), or whether a hybrid per-use + subscription split is permitted (the provider's terms are the source). It does decide the smaller questions: which entries document a bundled allowance, what the plan prices were on the verification date, and how the free tiers in the category are capped.

How to evaluate a subscription before you pay for a month

1.Measure a month (or a week, scaled) of your real usage: input tokens, output tokens, or generations, on the models you would actually use. The breakeven math is only as good as this number.
2.Compute the per-use cost of that usage at the provider's published rates — the entry links the pricing page. If the plan price is lower than that number at the same quality, the plan is a cost win for the baseline; if higher, it is paying for convenience or headroom, which is a decision, not a mistake.
3.Read the cap behavior: hard stop, overage billing, or throttle. Then verify it deliberately near the limit on a free tier where one exists — the limit behavior is what your users will feel.
4.Check the allowance terms: rollover or expiry, per-seat or per-key rules, commercial-use rights. The entry notes carry the documented shape; the provider's terms are the contract, and "not documented" budgets as "expires".
5.Verify the key-sharing policy before any team use: major providers' policies exclude sharing access across unaffiliated services (OpenAI's usage policies, cited below) — team access belongs in the provider's team or organization features, not a pasted key.
6.Start on the smallest tier, run the real workload for one full cycle, compare the invoice against your per-use estimate, then size up. Downgrading mid-cycle is a terms question — check before you need it, not after.

// how this page is built

How this list is built

last verified 2026-10-12 — dataset + cited sources checked on this date

predicate: Inclusion: published, non-internal entries categorized subscription-router — endpoints and products whose primary billing contract is a flat plan (monthly price for bundled credits, generation allowances or capped access) rather than per-use metering. 42 entries matched at last check.

sort: Bundled allowance value (creditValueUsd) descending, quantified at the provider's published rates; entries without a quantified bundle sort last, ties alphabetical — the shared category-page sort. Plan prices are compared in the table and the breakeven section, not the sort.

freshness: Per-entry last-verified dates; plan prices and bundles are re-checked on the dataset refresh cycle with changes recorded. Provider plan pages in the sources were fetched on the verification date.

limitations: We do not verify rollover, seat or cancellation terms beyond published documentation, do not measure per-plan rate limits under real load, and treat breakeven examples as arithmetic on published numbers at the verification date — recompute at current prices before you commit a month.

Full methodology, probe cadence and the correction pathway: about & methodology · raw data: public dataset (CC BY 4.0) · pricing and status on every row are measurements with dates, not guarantees.

Written by Mike Fleming — Founder & Editor. He runs the directory, writes the entry research and reviews every page here; corrections go to the contact page.

// faq

Frequently asked questions

What counts as a "subscription router" in this directory?

A flat-time billing contract: a plan price (usually monthly) for a bundle — API credits, a generation allowance, or capped access — where the plan, not the meter, is the primary payment shape. The 42 entries here are that category; entries whose primary contract is per-use metering sit in the paid-api category instead, and one-time grants without a recurring plan sit in the free categories. An entry can have both shapes; the category records the primary one.

How do I calculate the breakeven between a subscription and per-use pricing?

Three numbers: the plan price, the per-use rates, and your predictable monthly usage. Multiply usage by rates (input and output separately — they are priced separately) to get the per-use cost of the same work, and compare it to the plan price. The worked example on this page does it with Mistral's published figures: $14.99/mo against $15–25.50 of bundled credits at $0.50/$1.50 per 1M. For spiky workloads use your P95 month, not the average — the plan pays the same in an idle month.

Do unused subscription credits roll over to next month?

It is provider- and plan-specific, and the entry notes carry it where the provider documents it. Where it is not documented, budget as if the allowance expires at the period boundary — that assumption costs you nothing when rollover exists and protects you when it does not. This is a terms question, not a data question: the directory records what is published, and the provider's terms page is the final authority.

Can I share a subscription API key with my team or other projects?

The major providers' policies say no to sharing and reselling access — OpenAI's usage policies are cited in the sources — and sharing a key also destroys per-key rate limits, spend tracking and revocation. Team access belongs in the provider's team, organization or seat-based plan features, where each member has their own credentials. For unaffiliated projects, separate accounts and separate keys; a shared key is a compliance and an operational problem at once.

Is a free plan in this category really free?

It is a $0 plan with caps — GitHub Copilot's Free tier, for example, is $0 with 2,000 completions per month on smaller models, while its paid tiers add pooled API credits on top of the seat price. The dataset records the free shape separately from the premium context, and the allowance value on the entry is the quantified free side. The cap, not the price, defines who the tier is for: individuals and prototypes, not continuous service traffic. Treat the free plan as a plan you pay for with usage discipline rather than money.

What happens when I hit a plan limit?

One of three documented shapes: a hard stop (an error at the limit), overage (per-use billing beyond the plan, where the provider documents it), or a soft throttle (a slower queue at the limit). The difference matters more than the list price — a throttled queue degrades, a hard stop fails, an overage bills. The entry notes carry the documented behavior where published; the deliberate near-limit test on a free tier or first cycle is how you confirm it for your workload.

Why is this category sorted by bundled allowance value?

One disclosed sort per page is the site rule, and the bundled allowance (quantified at the provider's published rates) is the number every entry in this category has — plan prices are compared in the table's price column and the breakeven section instead. Entries without a quantified bundle sort last and stay visible. The sort answers "who gives the most for a plan"; the article answers "which plan is right for your volume".

Subscription or per-use for an agent that runs continuously?

Agents are baseline-heavy, which is the subscription side of the breakeven: a flat plan covers the predictable churn while per-use billing (where the provider allows the split) picks up bursts. The checks that decide it: your agent's monthly token volume against the allowance value, the provider's policy on automated and continuous traffic (some terms restrict it — the terms page is the source), and the cap behavior when the allowance runs dry mid-run. A continuous agent on a hard-stop plan with no overage is a design bug, whatever the price says.

How does the dataset record plan prices and bundled credits?

The monthly plan price is normalized to USD and shown in the price column; the bundled allowance is converted to USD at the provider's published per-use rates and shown as the credit value, flagged where the conversion assumed a usage shape. Both are visible on the entry with the source link and the last-verified date. Where a bundle cannot be quantified honestly from published rates, the entry says "not quantified" instead of guessing — the credit note describes the bundle in words.

When should I look at enterprise plans instead of these?

When the constraint stops being price and becomes paper: team seats at scale, compliance and data-processing terms, committed volume with reserved pricing, or support above the published standard tier. The enterprise category tracks those contract shapes (five entries at last check) — usually the same models with a different agreement. The breakeven math on this page still applies underneath the enterprise terms; it just stops being the whole conversation.

from the blog

Notes on free AI keys, tokens and credits

All posts →

// by category & list

Browse by category & list

12 live pages

categories — one page each, root-level URLs

data-ranked lists — ordered by data, never sponsored

Every page carries its own live totals (routers, free tiers, free credits, live now) and its own filtered directory — generated from the same dataset as the rest of the index.