LiteLLM vs Portkey vs Kong: LLM Gateway Pricing — June 2026
LiteLLM is free but costs $500–$2,000/mo to self-host. Portkey starts at $49/mo (log-based). Kong at $25/mo per control plane. The real cost of each — with hidden ops and scaling traps.
Your CFO just asked why the team’s LLM bill hit $47,000 last month — and you can’t answer because eight different services call five different providers with zero centralized attribution. You need a gateway. But which one?
We compared the three gateways teams actually evaluate in 2026 — LiteLLM, Portkey, and Kong AI Gateway — across pricing architecture, hidden costs, and what you pay at each scale tier. The short answer: there’s no universally cheap option. The one that looks free has the highest ops tax. The one that looks affordable turns expensive at scale. Here’s the math.
TL;DR: Which Gateway Costs What
| LiteLLM (Self-Hosted) | LiteLLM Cloud | Portkey | Kong AI Gateway | |
|---|---|---|---|---|
| Starting price | $0 (MIT license) | Custom quote | $0 (Dev, 10K logs/mo) | $0 (OSS) / $25/mo (Konnect Plus) |
| Production floor | ~$500–$2,000/mo (ops) | Custom quote | $49/mo (Pro) | ~$500–$2,000/mo (ops + Konnect) |
| Pricing model | Your infra cost | Per-request | Per-log + provider API costs | Per control plane + your infra |
| Scaling pain point | DevOps headcount | Vendor negotiation | Log volume at high throughput | Kong expertise + infra |
| Hidden cost | Running Postgres + Redis + Docker in prod | Monthly minimums | Log-based billing balloons at scale | Requires Kong operational knowledge |
| Best for | Teams with DevOps, cost-sensitive, data sovereignty | Teams wanting managed open-source | Teams wanting turnkey managed + observability | Teams already on Kong |
If you want the architecture-level comparison (fallback chains, routing, caching), read our LLM Gateway Patterns guide. This post is about what each one costs.
LiteLLM: Free Code, Expensive Ops
LiteLLM is an MIT-licensed Python proxy from BerriAI that speaks the OpenAI API and routes to 100+ LLM providers. The code is free. Running it in production is not.
What you’re actually paying for
Infrastructure. At minimum, you’re running:
- LiteLLM proxy (Docker, Kubernetes — stateless, scales horizontally)
- PostgreSQL (spend tracking, virtual keys, user management)
- Redis (caching, rate-limit counters)
- A load balancer in front of the proxy replicas
For a mid-size deployment handling 100–500 RPS, that’s roughly $200–$600/month in cloud compute. At higher throughput, Redis and Postgres sizing becomes non-trivial.
People. The real cost. Someone has to:
- Configure model groups, fallback chains, and routing policies in
litellm-config.yaml - Manage virtual keys, per-team budgets, and RBAC in the admin UI
- Monitor proxy health, latency, and error rates
- Handle Postgres backups and Redis failover
- Debug when a provider changes its API and a route breaks
The ResultantAI comparison estimates $500–$2,000/month in hidden costs for self-hosted LiteLLM when you account for DevOps time. Our experience aligns with the lower end of that range for teams that already run Kubernetes — and the higher end for teams that don’t.
LiteLLM Cloud. BerriAI offers a managed version. Pricing is custom-quote — not published. For teams that want LiteLLM’s provider coverage without the ops burden, but don’t mind the enterprise sales process.
The cost model that matters
# What you DON'T pay: per-request fees, per-log fees, platform tax.
# What you DO pay: compute, storage, and someone's time.
# Typical monthly cost for a team doing ~50K LLM calls/day:
# - K8s pods (3x replicas): $150-300
# - Managed Postgres (small): $50-100
# - Managed Redis (small): $30-60
# - DevOps allocation (20% FTE): $800-2,000
# Total: ~$1,000-2,500/mo
Verdict: Cheap at the code level, predictable at the infra level, expensive in people time. Best when you already have a platform engineering team and data sovereignty matters.
Portkey: Free to Start, Unpredictable to Scale
Portkey is the managed-first option. It combines an AI gateway with observability, prompt management, guardrails, and (new in 2026) an Agent Gateway for governing agent traffic.
The pricing tiers
| Plan | Price | What you get |
|---|---|---|
| Dev | $0/mo | 10K recorded logs/mo. Logs, traces, feedback, custom metadata. Not for production workloads. |
| Pro | $49/mo | Unlimited logs. Full observability suite. Prompt management. Guardrails. Production-ready. |
| Enterprise | Custom | SSO, RBAC, dedicated support, SLA, self-hosted option, audit logs. |
Source: Portkey Pricing, Feature Comparison.
The log-based pricing trap
Portkey’s pricing model charges based on recorded logs — every request-response pair that passes through the gateway. The Pro tier at $49/month includes “unlimited logs,” which sounds generous. But here’s where it gets nuanced:
- The Dev tier caps at 10K logs/month — easy to blow through in a single day of moderate usage
- At enterprise scale, the log-based model creates cost unpredictability. Maxim AI’s analysis notes that for high-throughput applications, log-based pricing creates unpredictable costs as your usage grows
- You’re also paying provider API costs (OpenAI, Anthropic, etc.) on top of the Portkey platform fee
For a team doing 1M requests/month: the $49 Pro plan looks cheap. But if your workload grows to 10M+ requests/month and you need Enterprise features (SSO, RBAC, self-hosting), the pricing shifts to custom negotiation territory.
What you get for the money
Portkey’s managed observability is genuinely good — traces, cost breakdowns, latency analysis, and feedback collection in a polished UI. The prompt management and A/B testing features save engineering time. Guardrails (PII detection, content filtering) come built in.
Verdict: Great for teams that want turnkey managed + observability and are willing to accept vendor pricing risk at scale. The $49 Pro plan is the sweet spot for production teams doing moderate volume. Be cautious if you’re projecting 10x growth.
Kong AI Gateway: Cheap Entry, Heavy Ops
Kong AI Gateway is a plugin for the Kong API Gateway that adds LLM-specific routing, prompt management, and (new) A2A agent traffic governance via Kong Agent Gateway.
The pricing tiers
| Plan | Price | What you get |
|---|---|---|
| OSS (self-hosted) | $0 | Core Kong Gateway + AI plugin. No control plane, no UI, no SSO. |
| Konnect Plus | $25/mo per control plane | Up to 2 hybrid gateway control planes. Dev portal, basic analytics. +$25/mo per additional control plane. |
| Konnect Enterprise | Custom / volume discounts | Unlimited control planes, SSO, RBAC, advanced analytics, dedicated support. |
Source: Kong Pricing.
The full picture
The $25/month Konnect Plus plan is deceptive. That’s just the control plane cost. You still need:
- Gateway data plane nodes — the Kong gateway instances that actually process traffic. These run on your infrastructure.
- PostgreSQL or Cassandra — Kong’s configuration database
- Kong expertise — someone who understands Kong’s plugin architecture,
kong.conf, and declarative config
A realistic minimum for a production Kong AI Gateway deployment:
- Konnect Plus control plane: $25/mo
- 2x data plane nodes (compute): $100-300/mo
- Managed Postgres: $50-100/mo
- Kong ops expertise (10-20% FTE): $400-1,000/mo
Total: ~$575-1,425/mo
Kong’s AI plugin adds LLM-specific features — prompt templating, model routing, response caching, PII redaction — but they’re less mature than LiteLLM’s or Portkey’s dedicated AI feature sets. The win is unification: if you already route all your API traffic through Kong, adding LLM routing to the same gateway avoids introducing a second proxy hop.
TrueFoundry’s 2026 analysis of Kong Gateway pricing confirms: Kong’s AI features are “still maturing compared to dedicated AI gateways,” and the operational complexity is the real barrier for teams not already invested in the Kong ecosystem.
Verdict: Only makes sense if Kong is already your API gateway. The marginal cost of adding AI routing is low in that case. For everyone else, the ops overhead and less mature AI features make LiteLLM or Portkey better starting points.
Cost Comparison at Three Scale Tiers
Tier 1: Prototyping / Early-Stage (up to 10K requests/month)
| Gateway | Monthly Cost | Notes |
|---|---|---|
| LiteLLM (self-hosted) | ~$50–150 | Minimal infra: one Docker container + SQLite. No ops allocation yet. |
| Portkey | $0 | Dev tier (10K logs). Fine for prototyping. Not production-suitable. |
| Kong (OSS) | ~$50–150 | Single-node Kong + Postgres. No control plane cost. |
Pick: LiteLLM or Portkey Dev, depending on whether you want hands-on or hands-off.
Tier 2: Production, Moderate Scale (100K–1M requests/month)
| Gateway | Monthly Cost | Notes |
|---|---|---|
| LiteLLM (self-hosted) | ~$1,000–2,500 | 3+ K8s replicas, managed Postgres/Redis, ~20% DevOps FTE |
| Portkey Pro | $49 + provider API costs | Unlimited logs. No ops overhead. |
| Kong (Konnect Plus) | ~$575–1,425 | Control plane + data plane nodes + Postgres + ops allocation |
Pick: Portkey Pro for managed simplicity. LiteLLM if data sovereignty matters or you’re already running K8s.
Tier 3: Enterprise / High Throughput (10M+ requests/month)
| Gateway | Monthly Cost | Notes |
|---|---|---|
| LiteLLM (self-hosted) | ~$3,000–8,000 | Larger infra + 30-50% DevOps FTE. Plus LiteLLM Cloud if you go managed. |
| Portkey Enterprise | Custom quote | SSO, RBAC, SLA, self-hosted option. Negotiate. |
| Kong (Enterprise) | Custom quote | Volume discounts. Full enterprise feature set. |
Pick: Depends on vendor negotiation, existing infrastructure, and compliance requirements. No clear winner at this tier — it’s a procurement decision.
The Cost Nobody Talks About: Gateway Lock-in
Changing gateways is a migration project. Your applications are coded against the gateway’s endpoint, your observability dashboards are built on its traces, and your team has internalized its configuration model.
- LiteLLM has the lowest lock-in risk: it’s open-source, uses standard OpenAI-compatible APIs, and the code is yours if BerriAI disappears. LiteLLM Cloud adds vendor dependency.
- Portkey has moderate lock-in: the observability UI, prompt management, and guardrails are the value. Migrating off means replacing those.
- Kong has high lock-in if you go all-in on the Kong ecosystem. If Kong is just one plugin in your stack, the risk is lower.
Our Enterprise AI Agent TCO analysis covers the broader cost picture — gateways are one line item in a much larger infrastructure bill.
Our Recommendation
Start with LiteLLM if you have DevOps capacity and care about data sovereignty. The open-source version is battle-tested, costs nothing at the code level, and gives you full control. The ops cost is real but predictable. We’ve deployed this pattern across multiple production stacks — see our LLM Gateway Patterns guide for the reference architecture.
Start with Portkey Pro ($49/mo) if you want managed and don’t want to think about gateway infrastructure. The observability UI alone saves hours of debugging. Just budget for the Enterprise tier if you’re projecting rapid growth — log-based pricing gets expensive at scale, and you’ll want SSO and RBAC sooner than you think.
Use Kong AI Gateway if Kong is already your API gateway. The marginal cost of adding LLM routing to an existing Kong deployment is low. For everyone else, the ops overhead isn’t worth the AI feature gap.
Skip building your own. We covered this in our 2025 gateway patterns post and it’s even truer in 2026: the open-source options are good enough that a custom gateway is an expensive distraction. Every team we’ve seen build one ended up reimplementing 80% of what LiteLLM already does — just with worse documentation.
Sources
- LiteLLM Documentation — provider coverage, virtual keys, RBAC
- Portkey Pricing — plan tiers and feature comparison
- Portkey Feature Comparison — open-source vs Dev/Pro/Enterprise
- Kong Pricing — Konnect plan tiers
- TrueFoundry: Kong Gateway Pricing Analysis 2026 — architecture and cost analysis
- Maxim AI: Best Portkey Alternative 2026 — log-based pricing analysis
- ResultantAI: LiteLLM vs Managed Gateway — self-hosted cost estimates
Related Posts
LLM Gateway Patterns: LiteLLM, Portkey, and Kong AI
LiteLLM vs Portkey vs Kong AI Gateway — retries, fallback, cost attribution, and PII controls. When to use each in a production AI stack.
The Agent Pricing Crisis: Nobody Knows How to Bill for Intelligence
Anthropic paused its Agent SDK billing overhaul on launch day. Salesforce ditched $2/conversation for Flex Credits. Per-seat SaaS is dying, and agent-native pricing remains an unsolved equation. Here's why — and what comes next.
The Great LLM Commoditization of 2026 — and Where the Moat Actually Lives Now
GPT-4 cost $60/M tokens in 2023. GPT-5.4 costs $2.50. Anthropic hit a $30B run rate and filed to go public at $965B. OpenAI followed suit, then immediately signaled deeper price cuts. The clearest signal yet: frontier models are becoming commodities. Here's where the infrastructure moat actually shifts.