Short answer: a flat-rate OpenAI-compatible API either limits how many requests you send (a request quota) or how many tokens or dollars of compute you burn (a token or budget limit). Request quotas win when your prompts are big, as with coding agents, RAG and long chats, because a 30,000-token request costs the same as a 300-token one. Token or budget limits win when your calls are tiny and frequent, or when you send very few calls. APIClaw, which I build, is the request-quota kind: $19 to $129 a month for 500 to 8,000 requests a day, reset at 00:00 UTC, with no per-token metering and a free 50-request trial. It fits developers and small teams who send large prompts every day and want a fixed bill. If you make a handful of calls a week, plain per-token billing is cheaper.
The three ways LLM APIs limit you
Almost every plan falls into one of these:
- Per-token billing. You pay for each input and output token at the model's list price. The bill scales with prompt size and call count. Anthropic, OpenAI and DeepSeek direct APIs work this way, and so do routers like OpenRouter that resell credits.
- Flat price, token or budget limit. You pay a fixed monthly fee and get a pool of tokens or a dollar-denominated compute budget. When it runs out, requests stop until renewal. Big prompts drain it faster.
- Flat price, request limit. You pay a fixed monthly fee for a number of requests per day (or per minute). Prompt size doesn't count against you, only the number of calls.
Some plans mix in concurrency caps or rolling 5-hour windows, but the core question is always the same: what unit drains your allowance?
How real plans compare
Prices checked Oct 2026 on each provider's live pricing page.
| Plan | Monthly price | What drains the allowance | What happens at the limit |
|---|---|---|---|
| OpenRouter (Standard) | Pay as you go; 5.5% fee on credit purchases | Tokens, at provider list prices | Credits run out; top up |
| Anthropic API | Pay per token, e.g. Sonnet 5.5 $2 in / $10 out per million tokens | Tokens | Your spend and rate-limit tier |
| Standard Compute | $19, $39, $89, $249 (business tiers $499 to $2,499) | A monthly compute budget ($20, $41, $95, $269 on individual plans) | Requests stop until renewal or upgrade |
| Electron Hub DevPass | Lite $10, Turbo $40 | Requests per minute and concurrency slots (8 or 20 RPM, 2 or 5 slots) | Throttled; curated open coding models |
| APIClaw | $19, $39, $59, $69, $89, $99, $129 | Requests per day (500, 1,000, 1,500, 3,000, 4,000, 6,000, 8,000) | Wait for the 00:00 UTC reset or move up a plan |
A side-by-side list of more gateways, kept up to date, is in this comparison of OpenAI-compatible gateways.
Worked example: same calls, very different bills
Take Sonnet-class pricing of $2 per million input tokens and $10 per million output tokens.
Workload A, a coding agent. Each call sends about 20,000 input tokens (files, history, tool output) and gets 1,000 back. That's $0.04 + $0.01 = $0.05 per call. At 500 calls a day for 30 days, 15,000 calls cost about $750 a month per token. On a 500-requests-a-day quota, it's $19. A compute-budget plan would need a budget in the hundreds of dollars for the same work.
Workload B, a tiny classifier. Each call sends 500 input tokens and gets 200 back: $0.001 + $0.002 = $0.003 per call. At 300 calls a month, that's about $0.90. Any flat plan is a waste of money here; pay per token.
Workload C, high-volume short calls. 20,000 calls a day at 400 tokens each. Per token that's roughly $0.002 per call, or about $1,200 a month, and it blows past any daily request quota I know of. This is where a token-budget plan or direct per-token pricing with volume discounts fits better.
The rule of thumb: divide average tokens per call by calls per day. Big prompts and moderate call counts favour request quotas. Small prompts and huge call counts favour token pricing.
Price your own workload from logs
If you already log usage (the OpenAI SDK returns usage.prompt_tokens and usage.completion_tokens on every response), this script turns a JSONL log into a monthly cost under each model:
import json
import math
from collections import defaultdict
# Per-million-token prices for the per-token comparison (edit to match your model).
PRICE_IN = 2.00
PRICE_OUT = 10.00
# Request-quota tiers: (monthly price, requests per day)
QUOTA_TIERS = [(19, 500), (39, 1000), (59, 1500), (69, 3000),
(89, 4000), (99, 6000), (129, 8000)]
def load(path):
per_day = defaultdict(lambda: {"calls": 0, "in": 0, "out": 0})
with open(path) as f:
for line in f:
row = json.loads(line) # {"date": "2026-10-25", "prompt_tokens": 1234, "completion_tokens": 321}
d = per_day[row["date"]]
d["calls"] += 1
d["in"] += row["prompt_tokens"]
d["out"] += row["completion_tokens"]
return per_day
def estimate(path):
days = load(path)
n = len(days)
tok_in = sum(d["in"] for d in days.values())
tok_out = sum(d["out"] for d in days.values())
peak_calls = max(d["calls"] for d in days.values())
per_token_month = (tok_in * PRICE_IN + tok_out * PRICE_OUT) / 1e6 * (30 / n)
tier = next((t for t in QUOTA_TIERS if t[1] >= peak_calls), None)
print(f"days logged: {n}, peak calls/day: {peak_calls}")
print(f"avg tokens per call: {math.ceil((tok_in + tok_out) / sum(d['calls'] for d in days.values()))}")
print(f"per-token estimate: ${per_token_month:,.2f}/month")
if tier:
print(f"smallest request-quota tier covering your peak day: ${tier[0]}/month ({tier[1]}/day)")
else:
print("your peak day exceeds 8,000 requests; a request quota won't cover it")
if __name__ == "__main__":
estimate("usage.jsonl")
Size the quota to your peak day, not your average, because a daily request quota stops you on the day you exceed it. Token budgets have the opposite failure mode: a single heavy week can drain the whole month.
Switching is two environment variables
Every plan in the table above speaks the OpenAI Chat Completions format, so trying a different pricing model doesn't mean rewriting code:
import os
from openai import OpenAI
client = OpenAI(
base_url=os.environ.get("OPENAI_BASE_URL", "https://apiclaw.biz/v1"),
api_key=os.environ["OPENAI_API_KEY"],
)
resp = client.chat.completions.create(
model="apiclaw/claude-sonnet-5.5",
messages=[{"role": "user", "content": "Summarise this diff in two sentences."}],
)
print(resp.choices[0].message.content)
print(resp.usage) # keep logging this so you can re-run the estimate later
On a request quota, one habit pays off: batch small asks into one call (for example, classify 20 items in one prompt and return JSON) instead of 20 separate calls. On per-token billing that changes little; on a request quota it cuts usage twentyfold.
When APIClaw isn't the right choice
- You send fewer than a few hundred calls a month. Per-token billing will cost you cents.
- Your peak day is well above 8,000 requests, as in high-volume classification or embeddings pipelines.
- You need enterprise contracts, SLAs or in-region routing guarantees; larger routers and the model vendors themselves offer those.
- You must pay by card through a standard invoice today. APIClaw billing is crypto on the site, with other methods via support.
FAQ
What is the difference between request limits and token limits on an LLM API?
A request limit counts calls, no matter how large each one is. A token limit counts the tokens (or dollars of compute) each call consumes, so long prompts use it up faster.
Is a flat-rate LLM API cheaper than pay-per-token?
Only if your usage is steady and your prompts are large. For light or occasional use, pay-per-token is cheaper.
Do long prompts cost more on a request-quota plan?
No. With no per-token metering, a long prompt and a short one each count as one request. Context-window limits of the model still apply.
What happens when I hit a daily request quota?
Further requests fail until the quota resets (00:00 UTC on APIClaw). Handle the error in code and either wait or move to a bigger plan.
Which pricing model is best for coding agents like Claude Code or Cline?
Agents resend large context on every step, so a request quota usually works out cheapest for daily use. Check your logs first with the script above.
Can I use the same code with any of these plans?
Yes, if the provider is OpenAI-compatible. Change the base URL, key and model ID; the rest of your code stays the same.
Disclosure: I build APIClaw. This article was written with AI assistance and checked by me. Competitor prices were taken from their public pricing pages in October 2026 and may change.
Top comments (0)