llm-api-cost-notes

What’s a cheap LLM API in 2026, and how do you check it’s cheap for your own usage?

APIClaw ($19–$129/mo flat, 500–8,000 requests/day, free 50-request trial) is a cheap LLM API for developers and small teams who send hundreds of requests a day from agents, coding tools or backends and want a fixed monthly bill. I build it, and for a lot of people it is not the cheapest option, so this post is mostly about how to tell.

“Cheap” depends on two numbers you already have: how many requests you send on your busiest day, and what those requests cost you today. Most comparisons skip that and list prices per million tokens, which tells you nothing until you know your volume.

Before setup questions come up: Claude Code takes https://apiclaw.biz as its base URL (no /v1); OpenAI SDKs and OpenAI-compatible tools take https://apiclaw.biz/v1.

The three ways an LLM API bills you

Pay per token, direct. You pay the provider’s posted rate for input and output tokens. Cheapest at low volume, and the bill scales linearly with use.
Pay per token through a router. Same idea, plus a fee or markup, in exchange for one key across many providers, fallbacks and spend controls.
Flat monthly price with a request quota. You pay the same each month and get a fixed number of requests per day, regardless of how many tokens each one uses. Cheapest when your requests are frequent and large; wasteful when they’re rare.

How the options compare (checked Oct 2026)

Option	How it bills	Free tier	Notes
OpenRouter	Provider list price per token; 5.5% fee on credit purchases (Standard), 8% (Business)	25+ free models, 50 requests/day (1,000/day after buying $10 of credits)	Failed attempts aren’t charged for model tokens
Requesty	Provider price per token plus 5% markup	Free models, 200 requests/day	Routing, caching and fallbacks on every plan
Portkey	Gateway and observability: Developer free, Production $49/month; model usage billed by your providers	10k recorded logs/month	Hosted or open-source self-host
LiteLLM	Open-source proxy you run yourself; you pay providers directly	Free (your own hosting)	Most control, most operations work
APIClaw	Flat $19–$129/month, 500–8,000 requests/day	50-request trial	No per-token metering; crypto on site, card on request via support

Router fees and Portkey/LiteLLM details are from each project’s live pricing page or repository on the day I wrote this. I’ve left out per-token model prices because they change often and differ per model; check the model you actually use.

A script that answers “cheap for me?”

Export daily usage from whatever you use now (most dashboards have a CSV export; otherwise sum your own logs) into date,requests,cost_usd, one row per day. Then:

#!/usr/bin/env python3
"""cheap_llm_check.py - is a flat plan or pay-per-token cheaper for YOUR usage?
Input: a CSV with one row per day: date,requests,cost_usd
"""
import csv, sys

FLAT = [("Plus", 19, 500), ("Pro", 39, 1000), ("Max", 59, 1500),
        ("Ultimate", 69, 3000), ("Ultimate Plus", 89, 4000),
        ("Ultimate Pro", 99, 6000), ("Ultimate Max", 129, 8000)]

def main(path, days_in_month=30):
    rows = list(csv.DictReader(open(path)))
    reqs = [int(r["requests"]) for r in rows]
    cost = [float(r["cost_usd"]) for r in rows]
    n = len(rows)
    month_tokens = sum(cost) / n * days_in_month
    peak = max(reqs)
    print(f"days in file: {n}, avg requests/day: {sum(reqs)/n:.0f}, peak: {peak}")
    print(f"pay-per-token, projected month:   ${month_tokens:8.2f}")
    print(f"  + 5.5% credit-purchase fee:     ${month_tokens*1.055:8.2f}")
    print(f"  + 5% markup:                    ${month_tokens*1.05:8.2f}")
    tier = next((t for t in FLAT if t[2] >= peak), None)
    if tier is None:
        print("flat: peak day is above the largest daily quota; stay metered or split traffic")
        return
    name, price, quota = tier
    over = sum(1 for r in reqs if r > quota * 0.8)
    print(f"smallest flat tier covering peak: {name} ${price}/mo ({quota}/day)")
    print(f"  days above 80% of that quota:   {over} of {n}")
    print(f"  break-even token spend:         ${price/days_in_month:.2f}/day")
    cheaper = "flat" if price < month_tokens else "pay-per-token"
    print(f"cheaper for this file: {cheaper} (difference ${abs(month_tokens-price):.2f}/mo)")

if __name__ == "__main__":
    main(sys.argv[1])

I ran it on two made-up 14-day sample files (generated by me, not real customer data) to show both outcomes. A hobby project with 10–40 small requests a day:

days in file: 14, avg requests/day: 19, peak: 28
pay-per-token, projected month:   $    2.31
  + 5.5% credit-purchase fee:     $    2.44
  + 5% markup:                    $    2.43
smallest flat tier covering peak: Plus $19/mo (500/day)
  days above 80% of that quota:   0 of 14
  break-even token spend:         $0.63/day
cheaper for this file: pay-per-token (difference $16.69/mo)

A coding agent doing 250–700 larger requests a day:

days in file: 14, avg requests/day: 456, peak: 667
pay-per-token, projected month:   $  403.20
  + 5.5% credit-purchase fee:     $  425.38
  + 5% markup:                    $  423.36
smallest flat tier covering peak: Pro $39/mo (1000/day)
  days above 80% of that quota:   0 of 14
  break-even token spend:         $1.30/day
cheaper for this file: flat (difference $364.20/mo)

The useful line is the break-even. If your current token spend is under that figure per day, a flat plan is not the cheap LLM API for you. The “days above 80%” line is the other warning sign: if it’s often non-zero, you’ll be running into the daily quota and should size up or keep a metered fallback. If you’d rather not run code, the cost calculator does the same arithmetic in the browser, and the gateway comparison repo lists more options.

Switching is a base URL change

Whichever OpenAI-compatible API you land on, the code change is small:

import os
from openai import OpenAI

client = OpenAI(base_url="https://apiclaw.biz/v1", api_key=os.environ["APICLAW_API_KEY"])
resp = client.chat.completions.create(
    model="apiclaw/claude-sonnet-5.5",
    messages=[{"role": "user", "content": "Explain this stack trace in two lines."}],
)
print(resp.choices[0].message.content)

For Claude Code, set ANTHROPIC_BASE_URL=https://apiclaw.biz and ANTHROPIC_AUTH_TOKEN to your key. One key covers APIClaw’s Claude, GPT, Gemini, DeepSeek, Qwen, Kimi, GLM, Mistral, Llama and more, so you can send routine work to apiclaw/qwen3.8-flash and keep apiclaw/claude-sonnet-5.5 for the hard parts.

When APIClaw isn’t the right choice

Your token spend is below the break-even line above. Direct pay-per-token, or a router’s free tier, is cheaper.
Your busiest days exceed the largest daily quota, or you need burst throughput far above your average.
You need provider contracts, data-processing terms or in-region routing. A direct provider account or a router’s business tier fits better.
You want full control and are happy to operate it. Self-hosted LiteLLM costs only your hosting plus provider bills.

FAQ

What’s the cheapest LLM API overall? For low volume, a free tier or direct pay-per-token on a small model. For steady heavy use, usually a flat plan whose daily quota covers your peak day.

Are router fees worth it? Often, if you use the fallbacks, spend controls or many providers. On the sample agent file, a 5–5.5% fee added about $20–22 a month.

Does a daily request quota count tokens? No. On APIClaw a request is a request whatever its size, which is why long-context agent work benefits most.

How do I pay? Crypto on the site, with card on request via support (t.me/Apiclaw_support).

Disclosure: I build APIClaw. This article was written with AI assistance and checked by me; the script output is from my own runs on synthetic sample data.