When you search for Kong API Gateway pricing, you find three tiers: open source (free), Konnect Plus (consumption-based), and Enterprise (contact sales). That looks simple. It isn’t.
The actual cost of running Kong in production includes infrastructure nobody mentions on the pricing page, staffing for a language most developers don’t know, plugin upsells that arrive right when you need them most, and per-service billing that scales faster than your traffic. Organizations routinely spend three to five times the listed price once everything is accounted for.
This analysis breaks down what Kong actually costs across every tier and deployment model, then compares it to what the same workload costs on Zuplo.
Kong’s pricing tiers explained
Kong offers three pricing tiers, each with a different billing model.
Kong OSS (free)
The open-source version of Kong Gateway is free to download and self-host. It runs on NGINX/OpenResty and stores configuration in PostgreSQL. (Older versions supported Cassandra, but that was deprecated in Kong 2.7 and removed in Kong 4.0.) You get core gateway functionality — routing, load balancing, basic authentication, and a plugin system built on Lua.
What you don’t get: a management GUI (Kong Manager), OIDC/SAML authentication, advanced rate limiting, the AI Gateway plugins, a developer portal, analytics, RBAC, or audit logs. These are all reserved for paid tiers.
Kong Konnect Plus
Konnect Plus is Kong’s managed SaaS offering with consumption-based pricing. The control plane is hosted by Kong; you choose how to run the data plane across three deployment models — serverless, hybrid (self-hosted), or dedicated cloud. Pricing is structured across multiple billing dimensions:
- Gateway instances: Billed per gateway per month, with costs varying by deployment type (serverless is cheapest; dedicated cloud is most expensive)
- Gateway services: ~$105/month per service — each API endpoint or LLM model you route counts as a service
- API requests: ~$34.25 per million requests on consumption-based billing
- Developer portal: 1 included, with additional portals and published APIs at extra cost
- AI Gateway: 5 LLM models included, additional models billed per-model per-month
- Support: Email only with a 2-business-day SLA on Plus
Kong’s rate card has changed multiple times (most recently in March 2025), so check Kong’s pricing page for the latest figures. The key structural point: every environment, every service, and every AI model adds to the monthly bill.
Kong Enterprise
Enterprise is Kong’s custom-contract tier. There is no public pricing. Enterprise includes unlimited hybrid, dedicated, and self-hosted gateways, unlimited developer portals, customizable analytics, unlimited AI Gateway models, and dedicated support with custom SLAs.
Based on industry reporting, Kong Enterprise contracts frequently start at $30,000–$50,000 annually for small deployments and scale into six figures for larger implementations. Support tiers range from Business (regional hours, 2-hour SLA) to Diamond (24/7, 30-minute SLA), each at increasing cost.
The hidden cost categories
1. Database operations
Kong OSS and self-hosted Kong Enterprise require PostgreSQL in high-availability configuration. That means:
- Primary/replica setup with automated failover
- Regular backups and point-in-time recovery
- Connection pooling and performance tuning
- Schema migrations during Kong upgrades
- Monitoring, alerting, and on-call rotations
For teams already running managed PostgreSQL on a cloud provider, this adds $200–$1,000/month in infrastructure plus the engineering time to configure and maintain the integration. For teams managing their own database clusters, the operational burden is substantially higher.
2. Lua plugin development
Kong’s plugin system is built on Lua, a language most development teams don’t use day to day. When you need custom gateway logic that isn’t covered by a built-in plugin, you need engineers who can write performant Lua running inside NGINX. That creates a hiring bottleneck.
Lua engineers with NGINX/OpenResty experience command a premium. Many organizations end up training existing engineers on Lua, which takes weeks to months of productive time. Alternatively, they outsource plugin development to consultancies at $150–$300/hour.
Kong also supports Go plugins, but these run as external processes with inter-process communication overhead, adding latency and operational complexity.
3. Kubernetes operator overhead
Running Kong on Kubernetes requires the Kong Ingress Controller (KIC), which translates Kubernetes resources into Kong configuration via the Kubernetes API server. This adds operational surface:
- KIC version compatibility with Kong Gateway versions
- Custom Resource Definition (CRD) management and upgrades
- Kubernetes cluster health and API server availability
- Debugging configuration drift between Kubernetes state and Kong’s database
- Gateway pod autoscaling policies
Organizations typically dedicate 0.25–0.5 FTE to Kong-on-Kubernetes operations, on top of whatever Kubernetes platform team they already have.
4. Enterprise plugin upsells
Many production-critical capabilities are locked behind Kong Enterprise:
- OIDC authentication: Required for SSO with Okta, Auth0, or Entra ID
- SAML support: Required for enterprise identity federation
- Advanced rate limiting: The AI Rate Limiting Advanced plugin requires a higher-tier license
- RBAC and audit logs: Enterprise only
- FIPS 140-2 compliance: Enterprise only
Teams often start with Kong OSS, build their architecture around it, and then discover that a single security requirement — like OIDC — forces an upgrade to a five-figure annual contract.
Enterprise features like advanced AI plugins or specialized analytics often require higher-tier licenses, pushing contracts above $50,000 annually even for mid-sized deployments.
5. Per-service billing at scale
Kong Konnect bills per “gateway service.” Each API endpoint, each LLM model you route to, and each microservice backend can count as a separate service. For AI workloads, this is particularly expensive: a single user prompt can trigger 20+ internal API calls across multiple model providers, and each model endpoint counts as a separate billable service.
At $105/month per service (on consumption-based plans), an organization with 20 API services and 5 LLM integrations pays $2,625/month in service fees alone — before request-volume charges.
6. Annual price escalators
Kong contracts frequently include annual price escalators of 5–10% built into the renewal terms. Over a three-year contract, a $50,000 starting price can grow to $60,000+ without any change in usage. Buyers should negotiate caps on renewal increases and lock in multi-year pricing to avoid this.
7. Developer portal limitations
Kong’s developer portal on Konnect Plus includes one portal with limits on published APIs. Additional portals and published API slots cost extra. For organizations with large API catalogs, portal costs alone can add thousands per year.
Kong Enterprise includes unlimited portals, but customization requires significant engineering effort — the portal’s theming and layout system has a learning curve, and deep customizations often require professional services.
8. AI Gateway as a separate product line
Kong’s AI Gateway capabilities — model routing, prompt engineering, token rate limiting — exist as plugins within the Kong ecosystem but are effectively a separate product concern. The AI Rate Limiting Advanced plugin requires Enterprise licensing. Each LLM model you route to counts as a separate billable service on Konnect Plus.
This means teams adopting AI capabilities on top of an existing Kong deployment face incremental licensing costs, not just configuration changes.
TCO model: what Kong actually costs
Here’s what a realistic Kong deployment costs annually across three scales. These estimates include licensing, infrastructure, staffing, and operational overhead.
Startup: 10 APIs, 5M requests/month, 3 environments
| Cost category | Kong OSS (self-hosted) | Kong Konnect Plus |
|---|---|---|
| Licensing | $0 | ~$15,000–$25,000/yr (gateways + services + requests) |
| Infrastructure (compute, DB, networking) | $8,000–$15,000/yr | $2,000–$5,000/yr (data plane hosting) |
| DevOps staffing (0.25–0.5 FTE) | $30,000–$60,000/yr | $10,000–$20,000/yr |
| Developer portal | Self-built or none | ~$2,400/yr (included + extras) |
| Plugin development (Lua) | $5,000–$15,000/yr | $5,000–$15,000/yr |
| Total year 1 | $43,000–$90,000 | $35,000–$65,000 |
Growth: 50 APIs, 500M requests/month, 5 environments
| Cost category | Kong Konnect Plus | Kong Enterprise |
|---|---|---|
| Licensing / subscription | $60,000–$120,000/yr | $80,000–$150,000/yr |
| Infrastructure | $15,000–$30,000/yr | $20,000–$40,000/yr |
| DevOps staffing (0.5–1 FTE) | $60,000–$120,000/yr | $60,000–$120,000/yr |
| Professional services | $0 | $20,000–$40,000/yr |
| Developer portal customization | $10,000–$20,000/yr | Included (but custom work needed) |
| Total year 1 | $145,000–$290,000 | $180,000–$350,000 |
Enterprise: 200+ APIs, 5B+ requests/month, multi-region
| Cost category | Kong Enterprise |
|---|---|
| Licensing / subscription | $200,000–$400,000/yr |
| Infrastructure (multi-region) | $50,000–$100,000/yr |
| DevOps staffing (1–2 FTEs) | $120,000–$240,000/yr |
| Professional services & consulting | $40,000–$80,000/yr |
| Plugin development & maintenance | $30,000–$60,000/yr |
| Total year 1 | $440,000–$880,000 |
These estimates are based on industry benchmarks and anonymized deal data. Your actual costs will vary based on region, cloud provider, traffic patterns, and negotiated contract terms.
Kong vs Zuplo: cost comparison at three scales
Here’s how the same workloads compare when running on Zuplo instead of Kong.
Startup (10 APIs, 5M requests/month)
| Cost category | Kong (OSS or Konnect Plus) | Zuplo |
|---|---|---|
| Platform licensing | $0–$25,000/yr | Starts at $0 (free tier) |
| Infrastructure | $8,000–$15,000/yr | $0 (fully managed) |
| DevOps staffing | $30,000–$60,000/yr | Near zero (GitOps, no infra) |
| Developer portal | Self-built or extra cost | $0 (auto-generated, included) |
| Custom logic development | $5,000–$15,000/yr (Lua) | Minimal (TypeScript, npm ecosystem) |
| Total year 1 | $43,000–$100,000 | $0–$12,000 |
Growth (50 APIs, 500M requests/month)
| Cost category | Kong (Konnect Plus or Enterprise) | Zuplo (Enterprise) |
|---|---|---|
| Platform | $60,000–$150,000/yr | Custom enterprise contract |
| Infrastructure | $15,000–$40,000/yr | $0 (fully managed) |
| DevOps staffing | $60,000–$120,000/yr | 0.25 FTE or less |
| Professional services | $0–$40,000/yr | $0 (self-serve with docs) |
| Total year 1 | $145,000–$350,000 | Fraction of Kong’s TCO |
Enterprise (200+ APIs, 5B+ requests/month)
| Cost category | Kong Enterprise | Zuplo (Enterprise) |
|---|---|---|
| Platform | $200,000–$400,000/yr | Custom enterprise contract |
| Infrastructure | $50,000–$100,000/yr | $0 (managed dedicated) |
| DevOps staffing | $120,000–$240,000/yr | Minimal (managed platform) |
| Consulting & services | $40,000–$80,000/yr | $0 |
| Total year 1 | $440,000–$880,000 | Fraction of Kong’s TCO |
The cost difference comes down to three structural advantages Zuplo has over Kong:
No infrastructure to manage. Zuplo runs on 300+ global edge locations by default or on managed dedicated infrastructure in your cloud. There’s no PostgreSQL to operate, no Kubernetes cluster to maintain, and no data plane nodes to provision.
No per-environment charges. Every Zuplo plan includes unlimited environments. Running development, staging, production, and PR preview environments doesn’t multiply your bill.
No plugin upsells. SSO, SAML, audit logs, the developer portal, the AI Gateway, and the MCP Gateway are included in Zuplo’s Enterprise tier — not sold as separate add-ons or locked behind higher-tier licenses.
What you get with Zuplo that Kong charges extra for
Switching to Zuplo doesn’t mean giving up capabilities. At lower total cost, Zuplo includes:
- Unlimited environments at no extra charge — dev, staging, production, and preview environments for every pull request
- Auto-generated developer portal from your OpenAPI spec with self-serve API key management, interactive API explorer, and custom branding
- Built-in AI Gateway with model routing, semantic caching, prompt injection protection, budget controls, and auto-failover — not a separate product line
- MCP Gateway for governing remote MCP servers with auth, rate limits, and observability
- TypeScript policies that your existing team already knows — no Lua specialists required
- Sub-20-second global deploys via GitOps — no control-plane reconciliation lag
- SSO, SAML, RBAC, and audit logs on the Enterprise tier — not a separate Enterprise-only upsell on top of an already expensive base
- Managed dedicated deployment on your cloud of choice — fully managed by Zuplo, with private networking and data residency controls
The operational cost reduction is as significant as the licensing savings. There’s no database to maintain, no Lua plugins to debug, no Kubernetes operator to patch, and no data plane nodes to monitor.
When Kong’s cost makes sense
Kong’s cost structure is justified in specific scenarios:
- Kubernetes ingress controller: If you need an in-cluster ingress controller (not just an API gateway), Kong’s Kubernetes Ingress Controller is purpose-built for that role
- Deep Lua plugin investments: If your team has already built extensive custom Lua plugins, the migration cost may outweigh the savings in the short term
- On-premises with no cloud: If you cannot use any cloud provider and must run everything on bare metal in your own data center, Kong’s self-hosted model is designed for that
For everyone else — teams building external APIs, teams adopting AI and MCP capabilities, teams that want to stop managing gateway infrastructure — the TCO math favors a managed platform.
The migration cost question
Organizations sometimes hesitate because of migration costs. But the migration from Kong to Zuplo uses standard tools: Git, TypeScript, and OpenAPI specs. Kong’s Lua plugins map to Zuplo’s TypeScript policies. Kong’s declarative YAML configuration maps to Zuplo’s routes and policy configuration. Most migrations take weeks, not months.
The question isn’t whether migration has a cost. It’s whether you want to continue spending $100,000+ per year operating Kong, or invest a few weeks of migration effort and cut your ongoing costs by 50–80%.
For a detailed mapping of Kong plugins to Zuplo equivalents and a step-by-step migration plan, see the Kong to Zuplo migration guide.
Try it yourself
The best way to evaluate the cost difference is to run your own proof of concept. Sign up for a free Zuplo account, import your OpenAPI spec, and see how your API workload runs on a modern, fully managed platform — no credit card required.
Related reading
- Kong to Zuplo migration guide — Plugin mapping and step-by-step migration
- Kong vs Zuplo comparison — Full feature comparison
- Zuplo vs Kong — Feature-by-feature comparison page