DEV Community: Michael Lee

The State of LLM API Pricing: July 2026

Michael Lee — Sun, 05 Jul 2026 14:17:05 +0000

Originally published on the TierUp blog.

If you last looked at a model price sheet a year ago, the single most important thing that changed isn't any one number. It's the spread. As of this month, published per-token prices run from about $0.075 per million input tokens at the bottom (Gemini 2.5 Flash-Lite, per APIpulse's June 2026 survey) to $30 input / $180 output at the top (OpenAI's GPT-5.5 Pro tier, confirmed across APIpulse, CloudZero, and CostGoat).

That's roughly a 400x spread on input and a 600x spread on output. Two API calls that look identical in your code can differ in cost by more than two orders of magnitude depending on one string: the model name.

The landscape in one table

Prices below are per million tokens, cross-checked against three trackers updated between May 11 and July 5, 2026. Prices move; verify against the provider's page before committing budget.

Model	Input $/M	Output $/M
GPT-5.5 Pro	$30.00	$180.00
Claude Opus 4.7	$5.00	$25.00
GPT-5.5	$5.00	$30.00
Claude Sonnet 4.6	$3.00	$15.00
Gemini 3.1 Pro (≤200K context)	$2.00	$12.00
Claude Haiku 4.5	$1.00	$5.00
Gemini 3 Flash	$0.50	$3.00
Gemini 2.5 Flash-Lite	$0.075	$0.30

A few footnotes that matter more than they look:

Long context costs extra. Gemini 3.1 Pro doubles its input rate (to $4/M) and raises output to $18/M once you cross 200K tokens of context, per CloudZero's data.
Naming churn is real. CloudZero's May snapshot listed the $30/$180 OpenAI tier as "GPT-5.4 Pro"; APIpulse and CostGoat now list "GPT-5.5 Pro" at the identical price. The tier is stable even when the model name isn't — plan around tiers, not names.
Open-weight-hosted models anchor the floor. DeepSeek's models are listed at $0.27/$1.10 (V3.2, CloudZero) down to $0.14/$0.28 for newer flash variants (APIpulse). The budget floor is crowded and keeps dropping.

What the spread actually means for you

The middle tier is where most production work belongs. Claude Sonnet 4.6 ($3/$15) and GPT-5.4 ($2.50/$15) are the consensus workhorses in every tracker we checked — frontier-adjacent quality at roughly 1/12th the cost of the Pro tiers. The $30/$180 tier buys measurably better performance on hard reasoning, but at 12x the price of models that handle the large majority of real workloads fine.

Output pricing is the quiet killer. Every model in the table charges 4–6x more for output than input. If your workload is generation-heavy (long answers, code, reports), the output column is the one to optimize — a topic big enough that we wrote a separate post on hidden cost multipliers.

Discounts are large and underused. Batch APIs run 50% off and prompt caching discounts cached input by up to 90% at the major providers, per CloudZero. If you're paying rack rate on repetitive prefixes, you're overpaying by design.

The uncomfortable implication

A 400–600x price spread means model selection is now a bigger cost lever than any infrastructure decision most teams will make this year. Hardcoding a flagship model name into every call path was defensible when the spread was 10x. At 600x, it's a budget decision being made by a config file nobody has reviewed since March.

The practical move: classify your workloads by the quality they actually need, route each class to the cheapest tier that clears the bar, and re-check quarterly — because as the naming churn above shows, the map gets redrawn every few months. That's the exact problem TierUp's tier-based routing exists to automate — disclosure: I'm the founder, and the tier-1 free playground at tierup.ai/try needs no signup if you want to see it.

Sources

Tiers, not models: designing an LLM router on Cloudflare Workers

Michael Lee — Sun, 05 Jul 2026 09:40:32 +0000

Every LLM app I've shipped had the same shelf life: pick the best model, hardcode it, and watch it become the second-best model within a month. The fix I keep seeing is a config file full of model strings and a quarterly migration chore. I wanted the abstraction one level up: "how smart does this request need to be?" — so I built a router around performance tiers instead of model names.

The tier contract

Four tiers: Speed / Balance / Intelligence / Reasoning. The API is OpenAI-compatible; model: "tier-2" is the only change a client makes:

from openai import OpenAI

client = OpenAI(
    base_url="https://api.tierup.ai/v1",
    api_key="...",
)

resp = client.chat.completions.create(
    model="tier-2",  # 1=speed, 2=balance, 3=intelligence, 4=reasoning
    messages=[{"role": "user", "content": "..."}],
)

Each tier maps to the current best-value model in its class — that mapping is my problem, versioned server-side, so an upgrade reaches every client with zero code changes on their side.

The stack, concretely

One Cloudflare Worker (Hono) fronts everything: auth (API key or Supabase JWT), a D1 database for users/wallets/request logs, KV for rate limits, and OpenRouter as the upstream aggregator. The Worker validates the request, checks the wallet, rewrites tier-N to the mapped model, proxies (streaming or not), then strips provider/model details from the response so the tier abstraction doesn't leak. Usage and cost are logged per request in D1; billing deducts from a prepaid wallet.

What was genuinely hard

Streaming + billing: you can't know the cost until the last SSE chunk, so billing runs in waitUntil after the stream closes — and you have to trust (and verify) the usage block in the final chunk.
Error compatibility: OpenAI-SDK clients break on nonstandard error bodies; every upstream failure has to be reshaped into the OpenAI error schema.
Health vs function: our /health returned 200 while auth was down (paused upstream DB) and, separately, while completions were broken (a corrupted API-key secret). Reachability lies. We now run a synthetic probe every 6h that signs up a disposable user, logs in, runs a tier-1 completion, and deletes itself — that's the only health check we trust.

The economics (disclosure)

This runs on top of OpenRouter and is priced ~50% under retail while we find out whether tier-routing is a thing people want — a subsidized PMF experiment, stated plainly on the site. Tier 1 is currently free. If you want to poke at it: tierup.ai (playground with no signup at tierup.ai/try, $25 credit, no card). I'm more interested in critique of the tier abstraction than in signups — comments very welcome.

The 1% Problem: Why Nobody Answers Cold Email Anymore (and What Actually Works in 2026)

Michael Lee — Sun, 14 Jun 2026 06:37:39 +0000

Originally published on the DonaTalk blog.

If you send cold emails for a living, you already feel it: reply rates that were 8–10% a decade ago now hover around 1–3% — and "positive reply" rates are a fraction of that. Industry studies from Backlinko, Gong, and Belkins all converge on the same uncomfortable picture: the average cold email campaign needs 100+ sends to produce a single interested response.

Why cold outreach keeps getting worse

Volume exploded. AI writing tools made it free to send "personalized" email at infinite scale — so every decision-maker's inbox became a wall of lookalike sequences.
Filters got smarter. Google and Microsoft now route bulk-pattern mail to spam or "Promotions" before a human ever sees it.
Trust collapsed. When everything is "personalized," nothing is. Recipients assume automation and delete on sight.

The math is brutal. At a 1% reply rate, a salesperson sending 50 emails a day generates roughly one conversation every two days — before qualification. The cost per actual meeting from cold email, fully loaded with SDR time and tooling, routinely exceeds $300–$800.

The signal problem, not a copy problem

Most "fix your cold email" advice optimizes subject lines and CTAs. But the core issue isn't copy — it's that email costs the sender nothing, so it carries no signal. A busy executive can't tell the difference between a rep who spent an hour researching them and a robot that scraped their LinkedIn. Both messages look identical, so both get ignored.

Economists call this a signaling failure. The fix isn't better words; it's attaching a cost to the ask that proves you're serious.

What attaching real skin-in-the-game looks like

That's the idea behind DonaTalk: instead of sending email #101 into the void, you commit a $10+ donation to the recipient's favorite charity in exchange for a 15-minute meeting. The donation only goes through if they accept — no acceptance, no charge.

For the seller, $10–$25 per accepted meeting is dramatically cheaper than the fully-loaded cost of cold-email meetings — and it filters for prospects willing to actually engage.
For the recipient, an unwanted interruption becomes funding for a cause they chose. Saying yes does good, literally.
For the charity, business development becomes a new donation stream.

Cold email isn't dead — but it's drowning in its own volume. The next decade of outreach belongs to channels where the ask costs something. Try DonaTalk and turn your next 100 unanswered emails into one meeting that funds a charity.