Let's get the awkward part out of the way first, because you'd find it anyway: TierUp routes through OpenRouter today. We're not a secret rival with our own GPU fleet — we're a different abstraction built on top of the same infrastructure. OpenRouter is a good product. If you want to choose your own models, you should probably just use it.
So why does TierUp exist? Because there are two kinds of LLM API users:
With TierUp, you request tier-1 through tier-4 (Speed, Balance, Intelligence, Reasoning) instead of a model string. We route each call to what we assess as the best-value model currently in that class. When a better model ships, your tier upgrades server-side — zero code changes on your end.
| TierUp | OpenRouter | |
|---|---|---|
| Core abstraction | 4 performance tiers (tier-1…tier-4); you never see model names | 400+ named models behind one API; you choose |
| Who picks the model | We do — tier mappings are versioned server-side, and responses strip provider/model details so the abstraction doesn't leak | You do (with optional routing preferences and fallbacks you configure) |
| Who tracks model churn | Us. New model ships, we re-evaluate the tier mapping, your tier upgrades with zero code changes | You. New model ships, you evaluate it and update your model strings/configs |
| Pricing model | Flat per-tier pricing, ~50% under the retail price of the underlying models (e.g. tier 2: $1.50/$7.50 per 1M tokens in/out vs ~$3/$15 retail for Sonnet-class). Transparently subsidized while we test product–market fit. Tier 1 is currently free | Pass-through of each provider's per-model price, plus a 5.5% fee ($0.80 minimum) on credit purchases per their published pricing (July 2026). Sustainable, at scale, proven |
| Streaming | Yes — standard OpenAI-style SSE streaming | Yes |
| SDK compatibility | OpenAI-compatible: change the base URL and set model to a tier | OpenAI-compatible: change the base URL and set model to a model ID |
| Spend controls | Prepaid wallet, per-request usage logging, daily spend guardrail | Prepaid credits, per-key limits, usage dashboards |
| Maturity & track record | Very early. Built solo, launched into public beta this year, ~zero production users. That's the honest state of it | Mature, large-scale, battle-tested by a large developer community. If maturity is your deciding factor, OpenRouter wins, full stop |
| Relationship | Runs on top of OpenRouter today | The upstream aggregator we route through |
Use OpenRouter if:
Use TierUp if:
Use both, honestly: some teams will pin critical paths to specific models via OpenRouter or direct APIs, and route bulk/background work through a tier. That's a reasonable architecture, not a betrayal of either product.
TierUp prices tiers ~50% below the retail price of the models behind them, and we currently eat the difference. This is a deliberate, transparently subsidized experiment to answer one question: will developers hand model choice to a router? If the answer is yes, margin comes later from volume pricing and smarter routing. If the answer is no, we'll have bought that answer cheaply. We'd rather you know that going in than discover it later.
Mechanically, today: yes — requests are routed through OpenRouter, and we say so. The product is the abstraction on top: the tier contract, the server-side model mapping that upgrades without code changes on your side, the flat per-tier pricing, and the wallet/guardrail layer. If the tier abstraction finds its audience, the plumbing underneath can change; the contract you code against won't.
Because we're subsidizing it, on purpose, during product–market-fit discovery — not because of secret efficiency. It's capped by a daily spend guardrail and disclosed everywhere, including here. Long-term margin, if we earn it, comes from volume pricing and routing optimization, not from a discount that quietly disappears.
We don't tell you, by design — responses strip provider and model details so code can't accidentally depend on a specific model. What we commit to is the class: tier 1 is speed-class, tier 2 balance-class (Sonnet-class economics: $1.50/$7.50 per 1M in/out vs ~$3/$15 retail), tier 3 intelligence-class, tier 4 reasoning-class. If "I must know and pin the exact model" is a hard requirement, TierUp is the wrong tool — use OpenRouter or a direct API.
Two strings, if you already use an OpenAI SDK: point the base URL at TierUp and set model to "tier-2" (or whichever tier). Streaming, error shapes, and the rest follow the OpenAI conventions your client already expects.
It works — auth, billing, playground, streaming, docs — and it's early, with ~zero users. We're not going to pretend otherwise. Try it on non-critical traffic first; the free tier and no-card credit exist exactly so that costs you nothing.
For the tier-routing use case, yes: TierUp's per-tier prices run ~50% under the retail cost of the models it routes to, and tier 1 is currently free. The honest caveat is the same one we make everywhere — that discount is a transparent subsidy during our public beta (capped by a daily spend guardrail), not permanent efficiency, and we route through OpenRouter today. If you want to choose and pin specific models yourself, OpenRouter is the better and more mature tool. If you want a cheaper 'pick a tier, we pick the model' abstraction and can live with not seeing the model name, that's the trade TierUp makes.
Also see: TierUp vs LiteLLM · TierUp vs Portkey · TierUp vs direct OpenAI · LLM API cost calculator · LLM router · Best LLM routers in 2026 · OpenRouter alternatives in 2026
Try a tier before you believe any of this.
The playground at tierup.ai/try works without signing up. If you like it, signup gets you $25 in credit, no card required.