You can learn a lot about a product from what it bills for. Portkey bills for recorded logs — $49/month buys you 100k of them (as of July 2026), with observability, guardrails, semantic caching, and prompt management attached. Tokens still flow to providers you chose, at prices those providers set. Portkey is the control panel around your model decisions, and by the standards of that category it's a strong one: an open-source gateway core, 1,600+ models routable, 50+ guardrail checks, fallbacks and load balancing, an enterprise tier with VPC deployment and SOC2/HIPAA.
TierUp bills for tokens, because with us there's nothing else to bill for. You call tier-1 through tier-4 — Speed, Balance, Intelligence, Reasoning — and we route each request to what we judge the best-value model in that class. You never see which one; responses strip model and provider names so your code can't quietly couple to a checkpoint. The decision Portkey helps you observe, configure, and guard is the decision TierUp removes.
That framing cuts both ways, and we'll be precise about it. Portkey assumes model choice is yours and makes you excellent at managing it. TierUp assumes model choice is a chore and takes it off your plate — which means giving up visibility and control that Portkey users would rightly consider table stakes. Neither assumption is wrong. They're for different teams.
Full disclosure before the table, same as on every page like this: TierUp routes through OpenRouter today, we're in public beta with ~zero production users, and our below-retail pricing is a subsidy we fund on purpose. Details below.
| TierUp | Portkey | |
|---|---|---|
| Core abstraction | 4 performance tiers; model choice delegated to us and hidden from responses | AI gateway over 1,600+ models; you choose models, Portkey manages the calls |
| Who owns the model decision | We do — tier-to-model mappings are versioned server-side and re-evaluated as models ship | You do; Portkey gives you routing configs, conditional routing, fallbacks, and load balancing to execute it |
| Observability | Per-request usage logging and spend visibility. That's the honest extent of it | A core strength: logs, traces, metadata, filters, alerts, cost analytics across providers |
| Guardrails | Spend guardrails (daily cap, prepaid wallet). No content guardrails | 50+ checks — PII, prompt injection, custom hooks — plus partner integrations |
| Prompt management | None | Templates, versioning, playground, variables |
| Caching | None exposed | Simple and semantic caching on paid plans |
| Pricing (platform) | No platform fee | Free dev tier (10k logs/mo, 3-day retention); Production $49/mo for 100k logs, +$9 per additional 100k; Enterprise custom (as of July 2026) |
| Pricing (tokens) | Flat per-tier, ~50% under retail of the underlying models (tier 2: $1.50/$7.50 per 1M in/out vs ~$3/$15 retail Sonnet-class). Transparently subsidized during PMF; tier 1 currently free | You pay your providers directly at their retail rates; Portkey doesn't resell tokens |
| Deployment | Hosted only (we route via OpenRouter) | Hosted, open-source self-hosted core, or VPC/private cloud on Enterprise |
| Maturity & compliance | Public beta, built solo, ~zero users, no compliance certifications. If that ends the conversation, it should | Established platform; SOC2 Type 2, HIPAA, GDPR options at the Enterprise tier |
Use Portkey if:
Use TierUp if:
Or stack them. Portkey proxies OpenAI-compatible endpoints, and TierUp is one. A tier behind Portkey gets you their observability and guardrails on top of our routing — you'd give back some of our price advantage in Portkey's log fees, but if you need their tooling, that trade can be worth it. We're relaxed about being one target among many in your config.
Portkey's pricing is straightforward SaaS: you pay for the platform, your providers bill you for tokens, and the whole arrangement is sustainable in the boring, reassuring sense. Ours isn't yet, and we'd rather say so here than have you find out later: TierUp prices tiers ~50% below the retail cost of the models behind them, and we currently absorb the gap — deliberately, capped by a daily spend guardrail — to answer one question: will developers hand the model decision to a router? If yes, margin comes later from volume pricing and smarter routing. If no, we'll have bought the answer cheaply. Plan accordingly.
No, and the distance is large. You get per-request usage logs and spend tracking — enough to know what you used and what it cost, nowhere near Portkey's traces, alerts, and analytics. If observability is a requirement rather than a nice-to-have, Portkey is the better tool, and you can even put a TierUp tier behind it.
Only for money. A prepaid wallet and a daily spend guardrail cap the damage a runaway loop can do to your balance. Content guardrails — PII detection, prompt-injection checks, moderation hooks — we don't have. Portkey ships 50+ of them.
Because we subsidize it. Portkey passes provider retail through untouched and charges for its platform; we charge no platform fee and sell tiers below the retail cost of the models behind them, eating the difference during product–market-fit testing. It's disclosed everywhere, capped daily, and not guaranteed to last forever.
We won't tell you — responses strip model and provider details so nothing in your code can pin a checkpoint. The commitment is the class: tier 1 speed, tier 2 balance (Sonnet-class economics), tier 3 intelligence, tier 4 reasoning. If your workflow needs named models with configurable routing between them, that's Portkey's home turf, not ours.
Also see: TierUp vs OpenRouter · LLM API cost calculator
The fastest way to judge a tier is to send it a hard prompt.
The playground at tierup.ai/try needs no signup; if it earns a second look, signup comes with $25 in credit and no card.