Kong is the most-installed open-source API gateway and remains the deepest plugin ecosystem in the category. Kong OSS is fully free; Konnect Plus moved to per-gateway billing in 2025, with roughly $200 monthly per Hybrid control plane as the realistic entry plus per-million-request charges layered on top. The cost flip happens when Konnect's per-gateway math overruns the budget for control planes a team actually needs, when GraphQL Federation has to be a first-class primitive rather than a plugin, when an all-AWS stack makes a separate Kong runtime redundant, or when YAML plugin config no longer fits how engineering wants to ship gateway logic.
Where alternatives win
Tyk treats GraphQL Federation as a first-class part of the gateway core rather than a plugin, with Cloud Starter at $600 monthly covering 10M requests at managed parity with Kong's plugin-based GraphQL story.
Zuplo is the modern code-first pick built on Cloudflare Workers and programmable in TypeScript, with Blockdaemon publicly reporting a roughly two-month switch off Kong and a 70% cost cut.
AWS API Gateway is the cheapest path for all-AWS stacks at HTTP API's roughly $1 per million calls with no monthly subscription and native Lambda, Cognito, and WAF integration.
KrakenD is the OSS specialist for backend-for-frontend aggregation, with managed Cloud at $99 monthly base for teams whose primary need is merging multiple microservices into client-friendly responses.
Apollo Router is the obvious pick if your API is pure GraphQL with federated subgraphs, with an Apache 2 Rust runtime and GraphOS Serverless free up to 10M operations.
By Subrupt EditorialPublished Reviewed
API gateways are the cross-cutting layer between clients and microservices: rate limiting, authentication, routing, response transformation, observability. Kong launched the modern category in 2014 with an NGINX-based open-source gateway and built Kong Inc on top. By 2026 the field has split into traditional OSS-plus-enterprise (Kong, Tyk, KrakenD), cloud-native (AWS API Gateway, Apigee), GraphQL-specific (Apollo Router), and modern code-first (Zuplo). The exit reasons rarely match the marketing pitch.
Kong OSS is fully free for self-hosting on any infrastructure. Konnect's 2025 pricing reshuffle replaced the old flat monthly rate with per-gateway billing at roughly $200 for a Hybrid control plane plus per-million-request charges, which is harder to model in advance than the rate it replaced. The 200+ plugin ecosystem is the genuine moat. The trade is operational responsibility: you manage the runtime, you keep up with plugin upgrades, and you either pay the Konnect markup or run dashboards yourself.
Five exit lanes arrive here. GraphQL Federation built into the gateway core rather than bolted on. Declarative stateless aggregation for backend-for-frontend microservices. AWS-native pay-per-call with no monthly subscription floor at all. TypeScript-programmable gateway logic that lives in your Git repo. Pure GraphQL routing with an OSS Rust runtime that has measurable performance wins on Apollo's own benchmarks.
Quick map by reason to look. First-class GraphQL Federation equals Tyk. Code-as-config at the edge with a named Kong-to-X switch case study equals Zuplo. AWS-native and cheapest at scale equals AWS API Gateway. Declarative aggregation equals KrakenD. Pure GraphQL with federation only equals Apollo Router.
Affiliate disclosure: Subrupt earns a commission when you switch to a service through our recommendation links. This never changes the price you pay. We only recommend services where there's a real cost or feature advantage for you, and our picks are based on the data on this page, not on which programs pay the most.
Quick pick by use case
If you only have thirty seconds, find your situation below and skip to that pick.
Apache 2 Go binary with declarative multi-backend aggregation, Cloud at $99 monthly base for managed deployment.
Skip these picks if: If your team has built custom Kong plugins on OpenResty or your Kuma service mesh is tightly wired into the Kong runtime, none of the picks below port your plugin investment. Stay with Kong OSS and only revisit if Konnect's pricing or a GraphQL-first need pushes you off.
At a glance: Kong alternatives
Quick comparison across pricing floor, best fit, and switching effort. Tap a row to jump to the full pick.
Permanent free tierFree that does not expire after a trial window
✓
✓
~
✓
OSS self-hostableApache 2 or MPL 2 core for free self-hosting
✓
✗
✗
✓
GraphQL Federation built-in
✓
✗
✗
✗
Code-as-config (TypeScript, not YAML)
✗
✓
~
✗
Pay-per-call billingNo monthly subscription floor
✗
✗
✓
✗
Native AWS integrationLambda, Cognito, WAF, VPC without extra glue
~
~
✓
~
Stateless aggregationDeclarative BFF pattern at the gateway
~
✓
✗
✓
Managed entry rate
$600/mo
Free
Pay-per-call
$99/mo
Cost at your volume
Approximate cost per pick at typical API requests/mo.
Pick
Small (1M)1 API requests/mo
Production (10M)10 API requests/mo
Scale (100M)100 API requests/mo
AWS API Gateway
$1/mo
$10/mo
$100/mo
Tyk
$600/mo
$600/mo
$1,800/mo
KrakenD
$199/mo
$1,099/mo
Custom
Zuplo
Free
Custom
Custom
Managed-tier monthly costs only. AWS API Gateway uses HTTP API at roughly $1 per million calls. Tyk uses Cloud Starter (10M cap) then Cloud Launch. KrakenD uses Cloud at $99 base plus $0.10 per 1K requests. Zuplo Free covers 1M; above that, Pro base plus per-1K overage applies until Business is negotiated. Self-hosted OSS is a separate, often cheaper, lane for Tyk and KrakenD.
Tyk is MPL 2 licensed, Go-based, with GraphQL Federation built into the gateway core. Kong supports GraphQL through plugins; Tyk treats it as native, which matters for teams whose API surface mixes REST and federated GraphQL on a single gateway.
The trade: smaller plugin ecosystem (around 50 vs Kong's 200+), smaller community, and Cloud Starter applies per region if you want managed multi-region rather than self-hosting it yourself.
The upside: Tyk OSS is fully free under MPL 2, the Go single-binary runtime is fast and operationally simple, and Cloud Starter at $600 monthly now covers 10M requests after the 2025 tier refresh (up from 5M at the same rate). For a team running both REST and federated GraphQL today on separate gateways, consolidating to Tyk eliminates one moving part.
Strengths
+GraphQL Federation built into the gateway core, not a plugin
+Go single-binary runtime is fast and operationally simple
+Cloud Starter covers 10M requests at the same flat rate after the 2025 refresh
+MPL 2 OSS, fully free for self-hosting
Trade-offs
−Smaller plugin ecosystem than Kong
−Smaller community than Kong
−Managed Cloud pricing is per-region if you need multi-region
OSS
MPL 2, Go-based
Cloud Starter
$600/mo, 10M requests, 5 APIs
Cloud Launch
$1,800/mo, higher caps
Enterprise
Custom self-hosted
Pricing verified
2026-05-11
Migration steps
Self-host Tyk OSS via Docker, or sign up for the Cloud Starter free trial.
Map Kong routes and plugins to Tyk equivalents; most cross-cutting concerns (rate limiting, JWT auth, OAuth2) translate cleanly.
If GraphQL is in scope, migrate federation config to Tyk's native Federation support rather than a plugin layer.
Run Tyk in parallel for one week of real traffic, then cut over and cancel Kong once observability matches.
Not for: Tyk is the wrong fit for teams whose value driver is Kong's specific plugin ecosystem (especially custom OpenResty plugins); Kong OSS fits that better.
KrakenD is Apache 2, Go-based, with stateless aggregation at the center of the product. The config is declarative: name which backends to call, how to merge responses, what shape to return to the client. Single-binary deployment, no state to manage at runtime.
The trade: smaller community than Kong, less mature dashboard UX, and the plugin breadth is narrower than Kong's marketplace.
The upside: the aggregation depth is the genuine differentiator and it beats Kong's plugin-driven approach for backend-for-frontend patterns. OSS is fully free under Apache 2; managed Cloud at $99 monthly base plus per-thousand-request usage is among the cheapest managed tiers in the category, and the runtime aggregates multiple microservice calls into one client response without imperative glue code.
Strengths
+Stateless aggregation built into the core, not bolted on
+Apache 2 OSS, single Go binary deployment
+Cloud at $99 monthly base is the cheapest managed entry on this page
+Strong fit for backend-for-frontend (BFF) patterns
Trade-offs
−Smaller community than Kong
−Less mature dashboard and management UI
−Less plugin breadth than Kong
OSS
Apache 2, Go single binary
Cloud
$99/mo + $0.10 per 1K req
Enterprise
Custom (~$36K+/yr self-hosted)
Aggregation
Declarative multi-backend
Pricing verified
2026-05-11
Migration steps
Self-host KrakenD via Docker, or download the single binary from krakend.io.
Translate Kong routes to KrakenD declarative config (krakend.json).
Build aggregation rules for any backend-for-frontend endpoints you previously chained with Kong plugins.
Run KrakenD in parallel for one week of real traffic, then cut over and cancel Kong.
Not for: KrakenD is the wrong fit for teams needing Kong's plugin breadth or complex auth flows; Kong or Tyk fit those better.
AWS API Gateway is pay-per-call: HTTP API at roughly $1 per million calls, REST API around 3.5x that rate with caching extra, WebSocket on a similar shape. The first 12 months on new AWS accounts include 1M free calls per month, which covers most hobby projects at zero.
The trade: the value depends almost entirely on whether your stack is already AWS-native. Native integration with Lambda, Cognito, VPC, and AWS WAF means everything wires up without extra glue; cross-account or multi-cloud setups lose that benefit and pick up coordination overhead.
The upside: for AWS-native teams the marginal cost is essentially the per-call rate with no monthly subscription floor. At 100M requests per month the bill on HTTP API is roughly two orders of magnitude lower than Konnect Plus plus the compute to run Kong nodes, and the runtime is operated by AWS so nothing extra needs to be on-call.
+HTTP API is the cheapest pick on this page at high volume
+1M free calls per month for the first 12 months on new AWS accounts
Trade-offs
−Best fit only for AWS-native stacks
−Smaller plugin and customization story than Kong
−REST API is roughly 3.5x HTTP API and adds up at high volume
Free tier
1M API calls/mo for first 12 mo
HTTP API
~$1 per 1M calls
REST API
~$3.50 per 1M calls + caching extra
WebSocket
~$1 per 1M messages + connection minutes
Pricing verified
2026-05-11
Migration steps
Provision API Gateway endpoints matching your Kong routes (HTTP API for most paths, REST API only where you need caching or built-in request validation).
Migrate Lambda integrations or other origins, and move auth to Cognito or a Lambda authorizer.
Update DNS to point at API Gateway custom domains.
Cancel Kong Konnect once traffic is fully cut over and observability matches.
Not for: AWS API Gateway is the wrong fit for non-AWS or multi-cloud stacks, or teams that depend on Kong's plugin ecosystem; Kong, Tyk, or KrakenD fit those better.
Zuplo is built on Cloudflare Workers under the hood and programmable in TypeScript. Free covers 1M API calls per month always; Pro adds a custom domain and standard support; Business adds dedicated infrastructure and SAML. The differentiator is programmability: instead of Kong's YAML plugin config, gateway logic lives in TypeScript files in your Git repo, code-reviewed and version-controlled like any other service.
The trade: smaller plugin marketplace than Kong, less battle-tested at billion-call scale, and the Pro per-thousand-call overage rate can escalate quickly if traffic outpaces the included quota before you negotiate Business.
The upside: for engineering teams that want gateway logic to live in code rather than YAML, Zuplo's shape removes Kong's config-management overhead. Blockdaemon is the publicly named Kong-to-Zuplo case study, with their Senior Director stating the switch took roughly two months for mission-critical systems and cut costs by roughly 70%. That is a real attributed switch story rather than a Zuplo-side estimate.
“The move to Zuplo from our existing API Management vendor was easy, taking just over 2 months to switch mission critical systems, and we're saving over 70% on costs.”
Strengths
+TypeScript programmable, code in your Git repo and reviewed like any service
+Edge-deployed via Cloudflare Workers (multi-region without extra setup)
+Free 1M API calls per month with no time limit
+Named public case study (Blockdaemon) with a roughly two-month Kong migration and 70% reported cost cut
Trade-offs
−Smaller plugin marketplace than Kong
−Pro per-1K-call overage rate can escalate quickly above quota
−Less battle-tested at billion-call scale than Kong or AWS
Free
1M API calls/mo always
Pro
$250/mo + $0.50 per 1K calls above quota
Business
Custom + dedicated infra + SAML
Runtime
Cloudflare Workers (TypeScript)
Pricing verified
2026-05-11
Migration steps
Sign up at zuplo.com on the Free tier (no card required).
Translate Kong routes to Zuplo TypeScript handlers; one file per route is the typical shape.
Configure custom auth, rate limiting, and request transformation in code rather than YAML.
Run Zuplo in parallel for one week of real traffic, then cut DNS over and cancel Kong.
Not for: Zuplo is the wrong fit for teams who prefer config-driven gateway management or rely on Kong's specific plugin ecosystem; Kong or Tyk fit those better.
Apollo Router is the Rust-based successor to Apollo Server Gateway, Apache 2 licensed for self-hosting. GraphOS Serverless is free up to 10M operations per month with a cloud-hosted router and schema registry; Cloud Pro at $250 monthly layers on a custom domain and an operation overage rate above the included quota.
The trade: GraphQL-only routing, no REST support. The narrower scope is the design point, not a limitation, if your API is GraphQL-first.
The upside: for teams whose API is pure GraphQL with federated subgraphs, Apollo Router is the canonical pick. Apollo's own internal migration from Apollo Server Gateway to the Rust router reported CPU consumption dropping to roughly 60% and memory to roughly 13% of the prior gateway, with measurable latency cuts on top. That is rare hard data for a runtime migration, and Tyk's GraphQL Federation (while real) does not match Apollo Router's depth on pure-GraphQL federation.
“Apollo's router CPU consumption is approximately 60% that of the gateway. Router memory consumption is approximately 13% of the gateway.”
Strengths
+Apache 2 Rust runtime, fully OSS self-hostable
+GraphOS Serverless free up to 10M operations per month
+First-party GraphQL Federation 2 support, the deepest in the category
+Apollo's own migration data: roughly 60% CPU and 13% memory of the prior gateway
Trade-offs
−GraphQL-only, no REST routing
−GraphOS Cloud Pro can escalate with operation volume above quota
−Specialized community (smaller than Kong's general-purpose ecosystem)
OSS
Apache 2, Rust runtime
Serverless
Free up to 10M ops/mo
Cloud Pro
$250/mo + per-million-operation overage
Enterprise
Custom + self-hosted runtime + SAML
Pricing verified
2026-05-11
Migration steps
If you are on Apollo Server Gateway, migrate to Apollo Router using Apollo's gateway migration guide (config compatibility is high).
If you are on Kong, define subgraphs and federation schema in Apollo Router config.
Sign up for GraphOS Serverless for managed schema registry, or self-host the OSS router for full control.
Cut traffic over and cancel Kong once stable, assuming your APIs are fully GraphQL.
Not for: Apollo Router is the wrong fit for REST or mixed REST/GraphQL stacks; Kong, Tyk, or AWS API Gateway fit those better.
Paid plans from $250.00/mo
When to stay with Kong
Stay with Kong if your stack leans on the 200+ plugin ecosystem, your team has built custom plugins on the OpenResty or NGINX runtime, or your Kuma service mesh is wired into the Kong gateway. The picks below address GraphQL Federation, declarative aggregation, AWS-native pay-per-call, code-as-config at the edge, and pure GraphQL routing.
API gateway alternatives split along three vectors: hosting model (managed-only vs OSS self-hosted vs hybrid), pricing model (per-call vs per-region vs per-gateway), and protocol focus (general REST vs GraphQL-specific vs aggregation-focused). Picks above address each combination relevant to a Kong reader's exit reasons.
Pricing was pulled from each vendor's site on the review date. We score on cost-at-volume for a representative API at three traffic levels (1M, 10M, 100M requests per month), plugin and programmability flexibility, and operational complexity. We weight pricing predictability heavily because per-call and per-gateway models surprise teams more than flat per-month models on growth.
Update history2 updates
Initial published version with 5 picks.
Backfilled to Stage 2 schema with structured verdict and deep-links, Quick Verdict (4 entries plus skipIf), Feature Matrix (8 dimensions across 4 picks), Usage Cost Table (3 traffic levels at managed-tier rates), 2 sourced testimonials (Blockdaemon switch case for Zuplo, Apollo's own internal migration data for Apollo Router), per-pick author ratings, and a 4-paragraph scannable intro. Catalog refresh: Kong Konnect Plus moved to per-gateway billing in 2025 (Hybrid runs roughly $200 per control plane monthly, with Serverless and Dedicated tiers cheaper and pricier respectively) plus per-million-request charges on top. Tyk Cloud Starter now covers 10M requests (up from 5M) at the same monthly rate.
Frequently asked questions about Kong alternatives
What's the difference between Kong OSS and Konnect?
Kong OSS is the self-hosted gateway runtime: deploy on your own infrastructure, manage upgrades and config yourself, free forever under Apache 2. Konnect is Kong's SaaS control plane: a hosted dashboard for managing Kong nodes, plus enterprise features (RBAC, audit log, advanced analytics). The runtime is identical; the management surface differs. For teams comfortable with self-managed infrastructure, OSS is enough; for teams wanting hosted management, Konnect Plus moved to per-gateway billing in 2025 (Hybrid runs roughly $200 per control plane monthly plus per-million-request charges) which is harder to model in advance than the old flat rate.
Is AWS API Gateway really cheaper than Kong at high volume?
Often by a wide margin for AWS-native workloads. At 100M monthly calls, AWS HTTP API runs roughly $100 plus origin compute, while Kong Konnect Plus at the new per-gateway model lands several-fold higher per month for the control planes plus the EC2 cost of running Kong nodes; HTTP API typically wins by 2-5x at this scale. At 1B+ calls per month the math flips because AWS API Gateway pricing scales linearly while a small EC2 fleet running Kong scales sub-linearly. Model the actual numbers against your real traffic and origin shape rather than relying on either vendor's marketing.
Should I use a service mesh (Istio, Linkerd) instead of an API gateway?
They solve different problems. API gateways handle north-south traffic (external clients into your services); service meshes handle east-west (service-to-service inside the cluster). Most production stacks need both: an API gateway for ingress plus a service mesh for internal mTLS and traffic policies. Kong Mesh, Istio, and Linkerd all integrate with API gateways for the combined story. They are not substitutes.
Is Apollo Router really faster than Apollo Server Gateway?
Yes, with hard data published by Apollo themselves: in their internal migration the router used roughly 60% the CPU and 13% the memory of the prior gateway, plus measurable latency cuts on top. The migration path is straightforward because config compatibility with Apollo Server Gateway is high. Teams running Apollo Server Gateway in production should plan a migration; the performance gap is large enough to justify the bounded engineering work.
Can Zuplo handle production traffic at high volume?
Yes for moderate scale via Cloudflare Workers underneath. Workers handle billions of requests across the Cloudflare network without operator intervention. Pro covers most production workloads up to a point; the per-1K-call overage rate above quota is the practical ceiling, not the runtime itself. For 10B+ calls per month, Zuplo Business or Enterprise with dedicated infrastructure fits. For typical production APIs in the 1M-100M monthly range, Pro is right-sized, and the named Blockdaemon switch case validates the production posture.
Ready to switch?
Our top Kong alternative: Tyk
Tyk treats GraphQL Federation as a first-class part of the gateway core rather than a plugin, with Cloud Starter at $600 monthly covering 10M requests at managed parity with Kong's plugin-based GraphQL story.
The team behind subrupt.com. We track subscriptions, surface cheaper alternatives, and publish comparisons where the score formula is on the page so you can recompute it yourself. We do not claim 30,000 hours of testing. What we claim is live pricing from our database, a transparent composite score, and honest savings math against a category baseline.
Get notified of price drops for Kong
We'll email you when Kong or its alternatives lower their prices.
Track Kong and find more savings
Add Kong to your dashboard to monitor spending and discover even more alternatives.