Pick the wrong API gateway and the bill shows up fast. A mid-size team running 500 million calls a month can pay roughly $480 on AWS API Gateway’s HTTP tier, tens of thousands of dollars on a Kong Konnect Plus subscription, or well past $400,000 a year on Google Apigee’s pay-as-you-go rates once environment fees stack up. The three platforms solve the same problem — routing, authenticating, and rate-limiting traffic in front of your services — but they land in completely different price brackets and architecture philosophies. This comparison breaks down Kong, AWS API Gateway, and Google Cloud Apigee on pricing, throughput, protocol support, and real deployment patterns as of August 23, 2026, so you can pick the one that fits your traffic instead of your vendor’s sales deck.
Don't miss new tech stories on Google
Add Tech Insider once in the Google app and our stories appear in your news suggestions.
What Kong, AWS API Gateway, and Apigee Actually Do
All three products sit in the same conceptual slot: a proxy layer between clients and backend services that handles routing, authentication, rate limiting, and observability. Past that, they diverge sharply. Kong Gateway is an open-source proxy built on NGINX and OpenResty’s LuaJIT runtime, distributed either as a free self-hosted binary or as Kong Konnect, the managed SaaS control plane. Kong Inc. moved to a yearly LTS release cadence starting in March 2025 — Gateway 3.10 LTS shipped March 27, 2025, with four minor versions released annually on top of it — and support timelines follow accordingly: Enterprise branch 3.8 reached end-of-life in September 2025, and 3.4 entered its 12-month EOL sunset window on August 31, 2026. AWS API Gateway is a fully managed AWS service with no self-hosted option — you either use it inside AWS or you don’t use it at all. Google Cloud Apigee sits at the enterprise end of the spectrum, built for organizations that need monetization, deep analytics, and governance layered on top of routing, either as the fully managed Apigee X or the hybrid model where the runtime plane lives on your own Kubernetes cluster.
The practical difference shows up the moment you scope a project. If you’re already deep in AWS and building serverless functions behind Lambda, API Gateway is the path of least resistance — it’s billed per million calls with no infrastructure to manage. If you need gRPC, GraphQL, Kafka, or raw TCP/UDP traffic behind one gateway, or you’re running a multi-cloud Kubernetes fleet, Kong’s plugin architecture and Kubernetes Ingress Controller are built for exactly that. If you’re a bank or hospital system that needs to expose APIs to external partners with usage-based monetization and audit trails, Apigee’s policy engine and analytics stack is what enterprise architects reach for — at a price that reflects it.
Why This Comparison Matters in 2026
API gateways stopped being a niche infrastructure decision the moment microservices and AI-agent traffic became the default architecture rather than the exception. Every LLM call routed through a backend, every mobile app talking to a partner API, and every internal service mesh eventually needs something standing between clients and compute to handle authentication, throttling, and observability. That’s exactly why the API gateway component of the broader API management market is projected to hold 38.2% share of a $10.32 billion market in 2026 alone. Choosing the wrong platform early doesn’t just cost money later — it locks a team into a protocol ceiling (no gRPC on API Gateway), an operational burden (self-hosting Kong without the staff to run it), or a governance gap (skipping Apigee’s audit trail when compliance eventually demands one).
Kong vs AWS API Gateway vs Apigee: Full Specs Table
| Category | Kong Gateway / Konnect | AWS API Gateway | Google Cloud Apigee |
|---|---|---|---|
| Deployment model | Self-hosted OSS, hybrid, or managed SaaS (Konnect) | Fully managed only, AWS-native | Apigee X (managed) or Apigee hybrid (customer-run runtime) |
| Open source option | Yes — Kong Gateway OSS, free, self-hosted | No | No |
| Free tier | 30-day full-platform trial on Konnect; OSS is permanently free | 1M REST + 1M HTTP + 1M WebSocket messages/month for 12 months | 60-day free Evaluation plan, no permanent free production tier |
| Base request pricing | ~$105/month per Gateway Service (Konnect Plus), 1M calls included | HTTP API: $1.00/million (first 300M), REST API: $3.50/million (first 333M) | Standard proxy: $20/million up to 50M, dropping to $13/million above 500M |
| Enterprise annual cost (mid-size) | $50,000–$120,000/year | Scales linearly with call volume, no fixed enterprise floor | $420,000–$600,000/year at ~500M calls/month across two environments |
| Peak throughput (benchmark) | Up to 137,850 RPS on basic proxy config (Kong internal benchmark) | Not published as RPS; overhead measured in latency instead | Max ~1,750 RPS under strict latency/error constraints (GigaOm) |
| Typical added latency | 3.82 ms at p95 (basic config, Kong benchmark) | ~50–200 ms overhead reported in real-world tests | Varies heavily by policy chain; no fixed published figure |
| Native gRPC support | Yes | No — requires ALB/NLB translation | Yes |
| GraphQL support | Yes, native plugin | No native support | Yes |
| WebSocket support | Yes | Yes, dedicated WebSocket API type | Limited, via HTTP/S policies |
| Kubernetes integration | Kong Ingress Controller (KIC), full Gateway API v1.3 support | Indirect, via ALB + VPC Lattice or VPC Links to EKS | Apigee Operator for Kubernetes, GKE Inference Gateway integration |
| mTLS support | Yes, via plugins | Yes, on custom domains | Yes, on Apigee X/hybrid endpoints |
| Best suited for | Multi-cloud, Kubernetes-first, high-protocol-variety teams | AWS-native serverless and Lambda-backed architectures | Large enterprises needing monetization, governance, analytics |
Pricing Breakdown: What You Actually Pay
Pricing is where these three platforms diverge the most, and it’s worth walking through each model separately because none of them price the same variable the same way.
AWS API Gateway: Per-Million-Call Simplicity
AWS publishes flat, tiered per-call pricing and nothing else beyond data transfer and optional caching, detailed on the official AWS API Gateway pricing page. HTTP APIs (the newer, leaner API type) cost $1.00 per million calls for the first 300 million requests a month, dropping to $0.90 per million above that. REST APIs, the older and more feature-rich type, cost $3.50 per million for the first 333 million calls, stepping down to $2.80 per million for the next 667 million, $2.38 per million up to 20 billion, and $1.51 per million beyond that. WebSocket APIs bill separately by message count and connection-minutes. There’s no per-gateway subscription fee, no environment charge, and no separate license — you pay for what you send through it, plus AWS’s standard data transfer-out rates. AWS’s pricing page, updated October 8, 2026, advertises tiered request pricing as low as $0.90 per million requests at the highest tier and describes the service as usage-based, with no minimum fees or upfront commitments.
Kong: Free Core, Paid Convenience
Kong’s pricing structure has two distinct tracks. Kong Gateway OSS is free to self-host indefinitely — you pay only for the compute you run it on. Kong Konnect, the managed SaaS control plane, charges per Gateway Service at roughly $105 a month, with 1 million requests included and overages billed around $200 per additional million on the Plus tier. Kong’s own pricing page confirms a 30-day full-platform trial with no credit card required, after which teams either move to Plus or negotiate an Enterprise contract. Enterprise deals for mid-size deployments run $50,000–$120,000 a year; large, multi-region enterprise contracts land between $150,000 and $300,000-plus annually. Dedicated cloud data planes add roughly $720/month in base infrastructure cost on top of the service and request fees.
Apigee: The Most Expensive, Most Governed Option
Apigee’s pricing has three layers stacked on top of each other, which is why enterprise buyers usually need a spreadsheet before signing. First, per-call pricing splits into Standard API Proxies ($20 per million up to 50 million calls, dropping to $13 per million above 500 million) and Extensible API Proxies, which support advanced transformations and shared flows, at $100 per million dropping to $64 per million at scale — five times the Standard rate. Second, every region requires a monthly environment fee: $365/month for a Base environment (up to 50 QPS, 99% SLA), $1,460/month for Intermediate, and $3,431/month for Comprehensive environments with autoscaled QPS and multi-region 99.99% SLA. Third, subscription buyers negotiate annual contracts, with mid-size deployments (roughly 500 million calls/month across two environments) landing at $420,000–$600,000 a year, and very large deployments exceeding 5 billion calls/month running $1.5 million to $3 million-plus annually. You can review the current tiers directly on Google Cloud’s Apigee pricing page.
Pricing Comparison at Different Traffic Volumes
| Monthly volume | Kong Konnect Plus | AWS API Gateway (HTTP) | Apigee (Standard proxy, PAYG) |
|---|---|---|---|
| 1 million calls | Included in base $105/month service fee | ~$1.00 total | ~$20 + $365 environment fee = ~$385 |
| 50 million calls | ~$105 + ~$9,800 overage ≈ $9,900 | ~$50 | ~$1,000 + $365 environment = ~$1,365 |
| 300 million calls | ~$105 + ~$59,800 overage ≈ $59,900 | ~$300 | ~$5,225 (blended tier) + $1,460 env = ~$6,685 |
| 1 billion calls | Enterprise custom contract, ~$150K–$300K/year | ~$930 (blended HTTP tiers) | ~$16,000 + $3,431 env ≈ $19,400/month |
The gap is stark at scale. At 1 billion calls a month, AWS API Gateway’s HTTP tier costs roughly $930, while Apigee’s Standard proxy pricing plus a Comprehensive environment fee runs closer to $19,400 a month — a difference of more than $18,000 monthly for equivalent call volume, before factoring in Apigee’s richer policy engine and governance tooling that AWS doesn’t offer at any price. Kong’s Konnect Plus overage pricing becomes uncompetitive fast at high volume too, which is exactly why heavy-traffic Kong users move to self-hosted OSS or negotiate flat-rate Enterprise contracts instead of staying on consumption billing.
Performance Benchmarks: RPS and Latency
Throughput numbers are the hardest to compare directly because each vendor and third party measures differently, but the pattern across multiple 2025-2026 benchmarks is consistent. Kong’s own engineering team publishes internal benchmarks showing 137,850 requests per second on a basic proxy configuration with 3.82 ms of added latency at the 95th percentile. Add rate limiting and key authentication across 100 routes and 100 consumers, and throughput drops to a still-substantial 96,289 RPS.
A third-party GigaOm benchmark comparing multiple API and microservices gateways under identical latency and error-rate constraints (sub-30 ms max latency, zero 5xx or 429 responses) found Kong sustaining a maximum of 54,250 RPS, while Apigee X topped out at 1,750 RPS under the same conditions — roughly a 31x gap. That’s not a knock on Apigee’s engineering; it reflects a deliberate trade-off, since Apigee’s policy chains run richer analytics, quota enforcement, and transformation logic on every request, which costs throughput in exchange for governance depth that a bare proxy doesn’t attempt to replicate.
AWS doesn’t publish a comparable RPS ceiling because API Gateway scales elastically behind the scenes rather than running on fixed capacity you benchmark directly. Instead, the relevant number is added latency. Independent testing from Serverless Inquisitor measuring real client-to-backend round trips found average latency around 48 ms from Stockholm to a nearby AWS region (including Lambda execution time), with 95th percentile under 59 ms for same-region calls. Separately, a 2026 engineering analysis estimated API Gateway can add 50–200 ms of overhead per request depending on payload size, request transformations, and whether custom Lambda authorizers are in the chain — meaningfully more overhead than a lean self-hosted Kong instance, but with zero infrastructure management required to hit those numbers.
Real-World Use Cases: Who’s Actually Running What
Production deployments make the positioning differences concrete.
- Kong at GCash: The Philippines-based mobile wallet reports saving $70,000 a month after standardizing its API platform on Kong, driven by consolidating multiple point solutions into one gateway layer.
- Kong at Vanguard and Cigna: Both financial and healthcare enterprises use Kong to standardize API operations across hybrid infrastructure, with Cigna specifically deploying it as connective infrastructure for AI-ready API traffic.
- AWS API Gateway at the UK’s DVLA: The Driver and Vehicle Licensing Agency uses API Gateway to serve more than 47 million driver records, handling billions of transactions a month across public and partner-facing endpoints.
- AWS API Gateway at Tapestry: The parent company of Coach and Kate Spade runs roughly 500,000 API calls a day through API Gateway in steady state, scaling to 1.5 million calls a day and 10,000 calls a minute during holiday traffic spikes.
- Apigee at Wells Fargo: The bank uses Apigee to manage generative-AI-driven APIs, leaning on the platform’s security and reusability controls for internal and partner-facing AI services.
- Apigee at UNOS: The United Network for Organ Sharing runs Apigee to support API connectivity across more than 300 healthcare organizations coordinating organ donor-recipient matching.
Protocol Support Compared
If your traffic is pure REST/HTTP, all three gateways handle it competently and this section barely matters. The differences show up the moment you need something beyond REST. Kong is the clear leader on protocol breadth, with native support for REST, gRPC, GraphQL, WebSocket, TCP/UDP, SOAP, and even Kafka behind one gateway, built on its NGINX/OpenResty foundation with per-protocol plugins. Apigee supports REST, SOAP, GraphQL, and gRPC natively, though it stays within the HTTP/S family rather than handling raw TCP or UDP traffic. AWS API Gateway is the most limited of the three: REST, HTTP, and WebSocket APIs are natively supported, but there’s no native gRPC — teams needing gRPC on AWS typically front it with an Application Load Balancer or Network Load Balancer instead, or run a REST-to-gRPC translation layer like grpc-gateway.
That gap matters more than it looks on a feature checklist. Teams building internal microservices on gRPC for performance reasons, or supporting real-time GraphQL subscriptions, will hit a wall on API Gateway that Kong and Apigee simply don’t have.
Kubernetes and Cloud-Native Integration
For teams running Kubernetes as their primary deployment target, the integration story differs sharply between the three. Kong’s Kubernetes Ingress Controller (KIC) configures the gateway entirely through Kubernetes CRDs and, as of KIC 3.5, fully supports Gateway API v1.3 including GatewayClass, Gateway, HTTPRoute, and GRPCRoute resources, with older Ingress-style CRDs being deprecated in favor of the Gateway API standard. Kong Operator, the separate controller for lifecycle-managing Gateway deployments themselves, jumped to version 2.0.0 on September 9, 2025, a major bump that further formalized declarative, CRD-driven management of Kong infrastructure on Kubernetes, and Kong then announced Kong Operator 2.3 on September 25, 2026. This makes Kong a natural fit for teams already standardizing on Kubernetes-native routing, and Kong documents its deployment topologies including control-plane and data-plane separation on its developer documentation site.
AWS API Gateway doesn’t run inside Kubernetes at all — it’s an external, fully managed front door that connects to EKS clusters via VPC Links or through an Application Load Balancer paired with Amazon VPC Lattice. AWS is increasingly steering EKS users toward the Gateway API standard through its Load Balancer Controller rather than positioning API Gateway itself as the in-cluster ingress layer. Apigee’s hybrid model runs its management plane in Google Cloud while the runtime plane installs directly on customer-managed Kubernetes, most commonly GKE, as documented in Google Cloud’s Apigee hybrid overview, with the Apigee Operator for Kubernetes managing configuration through CRDs and Helm — including a 2025-2026 integration with GKE Inference Gateway that extends Apigee’s policy engine (API keys, quotas, rate limiting) to AI inference workloads specifically.
Recent Updates: What Shipped in the Last Few Months
All three vendors have shipped meaningful updates recently. Kong API Gateway 3.15 launched July 14, 2026 with GA Conditional Policy Execution, with the prior 3.14 beta formally deprecated August 1, 2026, while on the open-source side Gateway 3.9.3 landed June 17, 2026 as the 147th release in the OSS repository’s history. Kong Konnect also expanded GraphQL support and secure automation tooling alongside those releases. Kong’s AI Gateway benchmarking, published in 2025 and still the most current public data, claims Konnect data planes run roughly 228% faster than Portkey and 859% faster than LiteLLM in AI-traffic scenarios, with 65-86% lower latency at fixed CPU allocation — relevant for any team routing LLM API calls through a gateway layer.
Apigee has been the most active of the three on release cadence: Apigee hybrid shipped v1.15.7 on July 31, 2026 and v1.16.9 on August 11, 2026, while Apigee X pushed 1-18-0-apigee-1 on July 15 and 1-18-0-apigee-2 on July 27, 2026, including a security fix hardening the Script policy against SSRF attacks targeting link-local addresses. AWS’s most notable recent addition is dynamic routing for REST APIs via custom domains, letting teams route based on headers and base paths for cleaner A/B testing and API versioning without standing up separate gateway instances.
Observability and Analytics: Seeing What’s Actually Happening
A gateway that routes traffic without giving you visibility into what’s flowing through it is only half a solution, and this is another area where the three platforms take noticeably different approaches. AWS API Gateway integrates natively with CloudWatch, exposing metrics like Latency (total time at the gateway) and IntegrationLatency (time spent waiting on the backend) so teams can isolate whether slowness originates in the gateway layer or downstream. That split is genuinely useful for debugging, but it requires stitching together CloudWatch dashboards, alarms, and log groups yourself — there’s no unified analytics UI purpose-built for API traffic the way the other two platforms offer.
Kong ships with built-in analytics through Konnect, including request-level tracing with support for distributed tracing headers like B3 propagation and Datadog integration, which matters for teams running microservices where a single client request fans out across a dozen backend calls. Self-hosted Kong Gateway OSS doesn’t include the same analytics depth out of the box — teams typically pair it with Prometheus and Grafana, which adds setup work but keeps the stack fully open source and avoids another vendor dependency.
Apigee is built around analytics in a way the other two aren’t. Its dashboards track API product usage, developer app activity, error rates by proxy, and monetization metrics out of the box, because Apigee was designed from day one for organizations that expose APIs externally to partners and need to bill or report on usage. That depth is exactly why banks and healthcare systems lean on it — the audit trail and usage reporting aren’t an add-on, they’re core to the product. For a team that just needs to know if requests are succeeding and how fast, that depth is overkill. For a team that needs to prove compliance to an external auditor or bill a partner by API call volume, it’s close to mandatory.
AI Gateway Features: Routing LLM Traffic
2026 has pushed all three vendors to add explicit support for routing traffic to large language model APIs, since LLM calls behave differently from typical REST traffic — they’re slower per request, more expensive per call, and often need fallback routing between providers when one model is rate-limited or down. Kong has invested the most visibly here: AI Gateway 3.10 shipped back on April 2, 2025 with automated RAG pipelines and PII sanitization across 12 languages, and the product line has moved fast since — AI Gateway 2.0 entered private beta on July 16, 2026, with a 2.1 release that had been slated for August, before reaching general availability in Konnect on September 1, 2026 with production-supported MCP bundling, and AI Gateway 2.2 launched on September 30, 2026, adding MCP governance and cost tracking. Kong also publishes benchmarks claiming its AI Gateway runs roughly 228% faster than Portkey and 859% faster than LiteLLM in AI-traffic scenarios, with 65-86% lower latency at fixed CPU allocation, according to its own 2025-2026 testing. The AI Gateway sits on top of the same plugin architecture as the rest of Kong, so teams already running Kong Gateway for standard API traffic can add LLM routing, token-based rate limiting, and prompt-level observability without introducing a separate tool.
Apigee’s approach runs through its integration with GKE Inference Gateway, extending the existing policy engine — API keys, quotas, rate limiting, response caching — to AI inference workloads specifically, which lets enterprises apply the same governance model to LLM traffic that they already use for conventional APIs. AWS doesn’t offer a dedicated “AI gateway” product distinct from API Gateway itself; teams building LLM-backed applications on AWS typically route through API Gateway to Lambda, then call out to Bedrock or a third-party model provider from within the function, which works but doesn’t give the same request-level LLM observability that Kong and Apigee are building in as a first-class feature. For teams whose primary traffic is now LLM calls rather than traditional REST endpoints, that gap is worth weighing heavily, since retrofitting AI-specific rate limiting and fallback routing onto a generic REST gateway is more engineering work than using a platform where it’s already built in.
How Kong Is Extending AI Governance Beyond Routing
Kong’s September 2026 announcements put more weight on governance than on routing alone. On September 30, 2026, Kong announced expanded AI Gateway cost-management capabilities, including pricing, attribution, planning, consumption controls, and optimization across models, applications, teams, and agents. The same day, Kong announced Kong Catalog, described as an inventory for APIs and AI interfaces, and published an enterprise AI-governance roadmap, with CEO and co-founder Augusto Marietti quoted in the announcement. For teams that already struggle to explain an LLM bill, attribution by model, application, team, and agent is the capability worth testing first in a trial.
Security work followed in October. Kong announced Bot Detector for Dedicated Cloud Gateways on October 7, 2026, targeting automated traffic such as scanners, credential-stuffing activity, and AI-training crawlers. On October 6, 2026, Kong’s product-release material identified Kong Gateway Enterprise 3.12.x.x as reaching end of life, so any team still running that branch should plan an upgrade instead of waiting. On October 8, 2026, Kong said it had been named a Leader in the 2026 Gartner Magic Quadrant for API Management for the seventh consecutive year.
In practice, the choice comes down to whether LLM spend and agent traffic already show up as a budget line. If they do, ask each vendor to demonstrate cost attribution and bot protection against your own traffic before signing, and treat analyst recognition as one input rather than a substitute for a proof of concept on your workloads.
Total Cost of Ownership Over Three Years
Sticker price on a pricing page rarely reflects what a team actually spends once engineering time, infrastructure, and support contracts are factored in. For a mid-size company processing roughly 300 million API calls a month, a rough three-year TCO comparison looks like this: AWS API Gateway’s direct usage cost stays close to $10,800 over three years at that volume on the HTTP tier, but teams still need engineering time to build CloudWatch dashboards, manage IAM policies, and handle the lack of native gRPC if that protocol becomes a requirement later. Kong Konnect Plus at the same volume runs closer to $2.1 million over three years on pure consumption pricing before any enterprise discount, which is precisely why high-volume Kong users almost always negotiate a flat-rate Enterprise contract instead — landing in the $150,000–$900,000 range over three years depending on scale, plus the cost of whatever infrastructure or platform team manages the deployment if self-hosted. Apigee at the same 300-million-call volume, running a Comprehensive environment for reliability, lands around $240,000 a year in direct platform costs — about $720,000 over three years — before factoring in the specialized staff most Apigee deployments require to manage its policy configuration and monetization setup.
The takeaway isn’t that AWS API Gateway is always cheapest — it’s that direct usage pricing tells an incomplete story. A five-person platform team spending 20% of its time maintaining a self-hosted Kong cluster has a real cost even though Kong OSS itself is free. An enterprise paying Apigee’s premium but avoiding a compliance failure that would have cost millions in fines has arguably gotten a bargain. Model the full cost, not just the invoice.
Migration Guide: Moving Between API Gateways
Migrating a production API gateway is rarely a weekend project, but the path is manageable if you break it into stages rather than attempting a big-bang cutover.
- Inventory existing routes and policies. Export every route, authentication scheme, rate limit, and transformation rule from your current gateway before touching anything else. Missed edge cases here are the single biggest cause of migration outages.
- Map policy equivalents. Kong plugins, AWS Lambda authorizers, and Apigee policies don’t map one-to-one. Build an explicit translation table — for example, an AWS Cognito authorizer typically becomes a Kong OIDC plugin or an Apigee OAuth2 policy.
- Stand up the new gateway in parallel. Deploy the target platform alongside the existing one rather than replacing it in place. Kong and Apigee hybrid both support this cleanly since they don’t require you to abandon existing infrastructure immediately.
- Route a canary slice of traffic. Start with 1-5% of non-critical traffic through the new gateway using DNS weighting or a load balancer split, and watch latency and error rates for at least 48 hours before increasing the split.
- Validate authentication end-to-end. Test every auth path — API keys, OAuth2, JWT, mTLS — against real client credentials, not just synthetic test tokens, since token validation logic is where most silent failures hide.
- Migrate rate limits and quotas last. Copy rate-limiting rules only after routing and auth are stable; changing multiple variables at once makes it far harder to isolate the source of any regression.
- Cut over with a rollback plan ready. Once the new gateway has run at 100% of traffic for at least a week with clean metrics, deprecate the old gateway — but keep its configuration exportable for 30 days in case you need to roll back.
Security and Authentication Features
Security capabilities are broadly comparable across all three, though the delivery mechanism differs. Kong handles OAuth2, JWT verification, mTLS, API key auth, HMAC, LDAP, and OpenID Connect entirely through its plugin system, which means adding a new auth method rarely requires a platform upgrade. AWS API Gateway leans on native AWS identity primitives — SigV4 request signing, IAM authorization, Cognito user pools for token-based auth, and Lambda authorizers for custom logic — plus mTLS support on custom domains and AWS WAF integration for request filtering. Apigee’s policy engine covers OAuth2 and OIDC authorization servers, JWT verification, API key validation, and mTLS on Apigee X/hybrid endpoints, with quota enforcement and spike-arrest policies built in as standard rather than bolted on.
The practical difference is operational: Kong’s plugin model means security logic lives in configuration you version-control alongside your routes. AWS’s approach ties security tightly to the rest of the AWS identity stack, which is a strength if you’re all-in on AWS and a liability if you’re not. Apigee’s policy framework is the most audit-friendly of the three, which is exactly why regulated industries gravitate toward it despite the cost premium.
Market Share and Adoption in 2026
The global API gateway market was valued at roughly $5.21 billion in 2025 and is projected to reach $6.29 billion in 2026, with a 20.8% compound annual growth rate carrying it toward $34.42 billion by 2035. Within the broader API management market — valued at $10.32 billion in 2026 — the gateway component specifically is projected to hold 38.2% share this year. Vendor-level share estimates vary by methodology and source, but the consistent pattern across multiple 2026 analyses puts AWS API Gateway ahead on raw usage share thanks to its dominance in serverless architectures, with Apigee holding a strong position in large regulated enterprises and Kong showing the fastest relative growth among cloud-native and multi-cloud engineering teams, even from a smaller absolute base. A narrower but fast-growing segment worth watching: the AI API gateway market, valued at $0.78 billion in 2025 and projected to reach $2.12 billion by 2034 as more teams route LLM traffic through dedicated gateway policies.
Pros and Cons
Kong Gateway / Konnect
Pros: Free and open-source core with no functional limits when self-hosted; the widest protocol support of the three (REST, gRPC, GraphQL, WebSocket, TCP/UDP, SOAP, Kafka); strongest Kubernetes-native integration via KIC and full Gateway API compliance; benchmarked as the highest-throughput, lowest-latency option among the three.
Cons: Self-hosting requires real operational investment in infrastructure, scaling, and patching; Konnect’s consumption pricing gets expensive fast at high volume; Enterprise contracts require custom negotiation with no public rate card past the Plus tier.
AWS API Gateway
Pros: Zero infrastructure to manage; simplest, most predictable per-million-call pricing of the three; deep native integration with Lambda, IAM, Cognito, and DynamoDB; a genuine 12-month free tier for new accounts.
Cons: No native gRPC support; measurably higher added latency (50-200 ms in real-world tests) than a lean Kong deployment; locked entirely to AWS, so it’s a non-starter for multi-cloud architectures.
Google Cloud Apigee
Pros: The richest policy, analytics, and monetization engine of the three; hybrid deployment model gives enterprises control over where the runtime physically lives; strong track record in regulated industries including healthcare and banking.
Cons: By far the most expensive option at scale, with layered per-call, per-region, and subscription fees; lowest raw throughput of the three in third-party benchmarks; pricing complexity makes accurate budgeting difficult without vendor help.
Use-Case Recommendations
- Serverless apps built entirely on AWS Lambda: AWS API Gateway. The pricing and integration depth beat anything you’d gain from a third-party gateway, and the free tier covers most early-stage projects entirely.
- Multi-cloud or on-prem Kubernetes platform teams: Kong Gateway OSS with the Kubernetes Ingress Controller. Self-hosting avoids vendor lock-in and gives you the broadest protocol support at zero licensing cost.
- Regulated enterprises needing API monetization and audit trails: Apigee X or hybrid. The governance and analytics depth justifies the cost premium when compliance requirements are non-negotiable.
- High-throughput internal microservices using gRPC: Kong Gateway, since AWS API Gateway lacks native gRPC and Apigee’s throughput ceiling is meaningfully lower under load.
- Startups prototyping an MVP with uncertain traffic: AWS API Gateway’s HTTP API type, for the free tier and the ability to scale from zero without provisioning anything in advance.
- Teams routing LLM/AI API traffic through a gateway layer: Kong’s AI Gateway, given its benchmarked latency and throughput advantage over dedicated AI-routing tools like Portkey and LiteLLM in Kong’s own 2025-2026 testing.
The Verdict
There’s no single winner here because the three platforms aren’t really competing for the same buyer. If cost predictability and zero operational overhead matter most and you’re already committed to AWS, API Gateway’s per-million-call pricing is difficult to beat — at 1 billion calls a month it costs roughly $630 versus tens of thousands of dollars on the other two options. If you need protocol flexibility, Kubernetes-native routing, and control over your infrastructure, Kong’s open-source core delivers the best throughput-per-dollar of the three, provided your team can operate it. And if you’re running a regulated business that needs API monetization, granular governance, and audit-grade policy enforcement, Apigee’s price premium buys capabilities the other two simply don’t offer, even if it means paying 30 times more per request at scale.
The one mistake to avoid is picking based on brand recognition alone. A team defaulting to AWS API Gateway because “it’s AWS” will hit a wall the moment they need gRPC. A team choosing Apigee because it sounds enterprise-grade will overpay by six figures a year if their actual need is simple REST routing. Match the platform to your protocol requirements and traffic volume first, and let the pricing model follow from that decision rather than the other way around.
Frequently Asked Questions
Is Kong Gateway really free?
Yes, Kong Gateway OSS is free and open-source with no functional limits when self-hosted. You only pay for the compute infrastructure you run it on. The paid tiers — Konnect Plus and Konnect Enterprise — are for teams that want Kong to manage the control plane, dedicated infrastructure, or advanced support rather than operating it themselves.
Does AWS API Gateway support gRPC?
No, AWS API Gateway has no native gRPC support. Teams needing gRPC on AWS typically front their services with an Application Load Balancer or Network Load Balancer instead, or run a translation layer such as grpc-gateway to convert REST calls to gRPC on the backend.
Which API gateway is cheapest for high-volume traffic?
AWS API Gateway’s HTTP API tier is the cheapest per-call option at scale, dropping to $0.90 per million requests above 300 million calls a month. Kong OSS can be cheaper still if you’re willing to absorb the infrastructure and operational cost of self-hosting, since there’s no per-call fee at all. Apigee is consistently the most expensive of the three once you factor in per-region environment fees on top of per-call pricing.
Can I run Apigee outside of Google Cloud?
Partially. Apigee hybrid lets you run the runtime plane on your own Kubernetes cluster, on-premises or in another cloud, while the management plane still lives in Google Cloud. Apigee X, by contrast, is fully managed and runs entirely within Google’s infrastructure.
How much added latency does each gateway introduce?
Kong’s own benchmarks show 3.82 ms of added latency at the 95th percentile on a basic proxy configuration. AWS API Gateway has been measured adding roughly 50-200 ms of overhead in real-world tests, depending on payload size and authorizer complexity. Apigee doesn’t publish a fixed overhead figure since it varies heavily with the number of policies attached to each proxy, but third-party benchmarks suggest it trades throughput for its richer policy execution.
Which gateway is best for a Kubernetes-native architecture?
Kong, via its Kubernetes Ingress Controller, which fully supports the Kubernetes Gateway API standard (v1.3) including HTTPRoute and GRPCRoute resources configured entirely through CRDs. AWS API Gateway sits outside the cluster and connects to EKS through VPC Links or VPC Lattice rather than running natively inside Kubernetes. Apigee hybrid also runs its runtime plane on Kubernetes, most commonly GKE, via the Apigee Operator for Kubernetes.
Do these gateways support rate limiting out of the box?
Yes, all three support rate limiting natively. Kong implements it as a configurable plugin, AWS API Gateway offers per-stage and per-API throttling limits alongside AWS WAF integration, and Apigee includes quota and spike-arrest policies as standard building blocks in its policy engine.
Which option has the widest protocol support?
Kong, by a clear margin. It natively supports REST, gRPC, GraphQL, WebSocket, TCP/UDP, SOAP, and Kafka behind a single gateway. Apigee covers REST, SOAP, GraphQL, and gRPC but stays within the HTTP/S protocol family. AWS API Gateway is the most limited, covering only REST, HTTP, and WebSocket.
