---
title: "API Gateway Pricing Compared (2026): How Kong, Apigee, AWS, Azure, MuleSoft, and Zuplo Charge"
description: "Compare API gateway pricing across Kong, Apigee, AWS, Azure, MuleSoft, Tyk, Gravitee, and Zuplo. Understand per-call, per-environment, and flat-rate pricing models and the hidden costs buyers miss."
canonicalUrl: "https://zuplo.com/learning-center/api-gateway-pricing-comparison-2026"
pageType: "learning-center"
authors: "nate"
tags: "API Gateway"
image: "https://zuplo.com/og?text=API%20Gateway%20Pricing%20Compared%20(2026)"
---
API gateway pricing is one of the most confusing parts of choosing an API
management platform. Every vendor uses a different billing model — per-call,
per-environment, per-core, per-tier — and the sticker price rarely tells the
full story. Hidden costs like data egress, developer portal licensing, and SSO
upcharges can double or triple what you expected to pay.

This guide breaks down exactly how the major API gateways charge in 2026, what's
included at each tier, and which hidden costs catch buyers off guard. Whether
you are evaluating platforms for the first time or replatforming from a legacy
gateway, this comparison gives you the pricing clarity you need to make an
informed decision.

## The four pricing patterns API gateways use

Before diving into individual vendors, it helps to understand the four
fundamental pricing models that API gateways follow. Most vendors combine
multiple models, which is what makes comparison so difficult.

**Per-call (usage-based)**: You pay for every API request that passes through
the gateway. AWS API Gateway and Apigee's pay-as-you-go model use this approach.
It's simple to understand but costs become unpredictable at scale.

**Per-environment**: You pay for each environment (staging, production, DR) you
deploy. Apigee and Azure API Management use environment-based pricing. Running
staging and production in two regions means paying for four separate environment
instances.

**Per-service or per-gateway**: You pay for each API service or gateway
instance. Kong Konnect charges per gateway service. This model penalizes teams
with many microservices or API endpoints.

**Flat-rate subscription**: You pay a predictable monthly or annual fee that
bundles capacity and features together. Zuplo's Enterprise tier and some
MuleSoft contracts follow this approach. Budget predictability is the primary
advantage.

Most vendors in practice combine two or more of these models — for example,
Apigee charges both per-environment _and_ per-call — which is why the total cost
of ownership is so much harder to calculate than the headline price suggests.

## Kong pricing

[Kong](https://zuplo.com/api-gateways/kong-alternative-zuplo) offers three tiers
through its Konnect platform, plus a free open-source gateway.

**Open Source (Free)**: The Kong Gateway OSS is free to download and self-host.
However, it lacks the management UI (Kong Manager), advanced analytics, OIDC
authentication, and enterprise plugins. The real cost here is operational — you
need a team to manage, patch, and scale the infrastructure yourself.

**Konnect Plus (~$105/month per gateway service)**: This is Kong's entry-level
managed offering. One million requests are included per service; every
additional million costs $200. A high-volume API handling 50 million calls per
month can trigger nearly $10,000 in monthly overage charges on traffic alone.
Additional charges apply for advanced analytics, extra developer portals, and
Mesh Manager zones.

**Konnect Enterprise (custom pricing)**: Required for SSO, audit logs, custom
SLAs, and dedicated support. Enterprise contracts are negotiated individually.
Industry benchmarks place mid-sized deployments at $50,000–$120,000/year and
larger multi-region deployments at $150,000–$300,000+/year.

**What to watch for**: Kong's pricing model has multiple billing dimensions —
gateway services, API requests, bandwidth, analytics, and mesh zones. SSO and
audit logs are locked behind the Enterprise tier. Self-hosting the OSS version
eliminates license fees but introduces significant infrastructure and DevOps
costs that many teams underestimate.

## Apigee pricing

[Apigee](https://zuplo.com/api-gateways/apigee-alternative-zuplo), Google
Cloud's API management platform, offers both pay-as-you-go and subscription
pricing models.

**Pay-as-you-go**: Standard API proxy calls cost $20 per million. Extensible API
proxy calls (using JavaScript, Python, or Java callouts) cost $100 per million —
5× the standard rate. On top of the per-call charges, you pay for each
environment per region:

- **Base environment**: ~$365/month
- **Intermediate environment**: ~$1,460/month
- **Comprehensive environment**: ~$3,431/month

**Subscription tiers**: Apigee offers Standard (starting at ~$500/month),
Enterprise, and Enterprise Plus tiers. These bundle a set volume of API calls
and environments but exact pricing is negotiated. Large enterprises typically
pay $8,000–$25,000/month depending on included call volume and features.

**What to watch for**: The jump from Standard to Extensible proxy pricing is
binary — if a proxy uses _any_ extensible policy, every call to that proxy is
billed at the higher rate. Advanced API Security adds $350 per million calls.
Advanced Analytics adds $20 per million analytics API calls. GCP data egress
fees apply on top of the Apigee charges. For a detailed breakdown, see our
[Apigee total cost of ownership analysis](/learning-center/the-true-cost-of-apigee-tco-analysis).

## AWS API Gateway pricing

[AWS API Gateway](https://zuplo.com/api-gateways/aws-api-gateway-alternative-zuplo)
is a fully managed, pay-per-request service tightly integrated with the AWS
ecosystem.

**HTTP APIs**: $1.00 per million requests. This is the lowest per-call price
among the major gateways and supports Lambda proxies, JWT authorizers, and CORS.

**REST APIs**: $3.50 per million requests. REST APIs include additional features
like request/response transformation, API keys with usage plans, and per-stage
caching. Caching adds an hourly charge based on cache size.

**WebSocket APIs**: $1.00 per million messages plus $0.25 per million connection
minutes.

**Free tier**: 1 million REST API calls, 1 million HTTP API calls, and 1 million
WebSocket messages per month for the first 12 months.

**What to watch for**: The per-request model is transparent at low volumes but
costs add up fast. At 100 million monthly REST API requests, you are paying $350
in API calls alone — before data transfer, CloudWatch logging, Lambda execution,
or WAF charges. There is no built-in developer portal, so you need to build or
buy one separately. API key management is basic, and there is no native API
monetization. Each additional AWS service (CloudWatch, X-Ray, WAF, Cognito) adds
to the bill. For teams that need more than simple routing, the total cost of
ownership extends well beyond the per-call price.

## Azure API Management pricing

[Azure API Management](https://zuplo.com/api-gateways/azure-api-management-alternative-zuplo)
uses a tier-based model with per-unit pricing.

**Consumption tier**: ~$3.50 per million calls with no base fee. Suitable for
dev/test environments and variable workloads averaging under 1 million daily
calls.

**Developer tier**: ~$36/month with unlimited API calls. Designed for
pre-production environments with no SLA.

**Basic v2**: ~$145/month base cost. Includes 100,000 calls; additional calls
cost ~$1.44 per 10,000.

**Standard v2**: Higher capacity with VNET integration support. Pricing scales
with capacity units.

**Premium v2**: ~$2,800/month per unit. Required for full VNet injection,
multi-region deployment, and self-hosted gateways.

**What to watch for**: Azure APIM has eight pricing tiers (from Consumption to
Premium v2), making it one of the most complex pricing structures in the
category. Each additional region and VNet integration multiplies the base cost.
Multi-region HA in Premium can easily exceed $10,000/month. The developer portal
is included, but advanced analytics, custom domain SSL, and built-in caching
vary by tier. There is no native API monetization.

## MuleSoft pricing

[MuleSoft](https://zuplo.com/api-gateways/mulesoft-alternative-zuplo) Anypoint
Platform is an enterprise integration platform with API management bundled in.
Pricing is not publicly listed and varies significantly by contract.

**Pricing model**: MuleSoft uses a vCore-based subscription model. Each vCore
represents a unit of compute capacity for running integration flows and API
proxies. The Gold tier starts at approximately $1,250/month per vCore.

**Typical costs**: A Platinum contract with 4 vCores across 3 environments has
been reported at $210,000/year. First-year total costs (including
implementation, training, and customization) are often 2–3× the base
subscription for typical mid-market deployments.

**Recent changes**: MuleSoft has introduced usage-based pricing for newer
packages (MuleSoft Integration Starter and Advanced), measured by Mule Flows and
Mule Messages rather than vCores.

**What to watch for**: MuleSoft is positioned as a full integration platform,
not just an API gateway. If you only need API gateway capabilities, you are
paying for an entire iPaaS. Pricing is highly negotiable but opaque — expect a
lengthy procurement process. Additional costs for premium connectors, API
analytics, and dedicated environments add up quickly.

## Tyk pricing

[Tyk](https://zuplo.com/api-gateways/tyk-api-management-alternative-zuplo)
offers an open-source gateway plus managed cloud and self-hosted commercial
products.

**Open Source (Free)**: The Tyk Gateway is free and open-source under MPL 2.0.
Like Kong OSS, the real cost is infrastructure and operations.

**Core tier (usage-based)**: Flexible consumption-based pricing for Cloud,
Self-managed, or Hybrid deployments. Exact pricing is not publicly listed.

**Professional tier (flat-rate)**: A fixed-rate option with no consumption
limits for teams operating at scale. Reported pricing ranges from $0 to
$3,800/month depending on configuration.

**Enterprise tier (custom pricing)**: Designed for high-traffic, multi-region
deployments. Pricing is negotiated individually.

**What to watch for**: Tyk's pricing is more transparent than some competitors,
but SSO and SAML are limited to higher tiers. The dashboard and developer portal
are only available in the commercial product, not the open-source gateway. Tyk
also offers a separate AI Studio product for AI gateway capabilities, which is
not included in the base API gateway price.

## Gravitee pricing

[Gravitee](https://zuplo.com/api-gateways/gravitee-alternative-zuplo) offers an
open-source API gateway with commercial cloud and enterprise options.

**Community Edition (Free)**: Gravitee's open-source APIM is free to self-host.
Infrastructure costs for production workloads (compute, networking, monitoring)
typically run $500–$2,000/month.

**Cloud (managed)**: Gravitee Cloud provides a managed deployment with
per-gateway pricing. There are no per-call charges, which simplifies budgeting.
Exact pricing is not publicly listed.

**Enterprise (custom pricing)**: Includes dedicated onboarding, a customer
success manager, and enterprise features. Like most vendors, exact pricing
requires a sales conversation.

**What to watch for**: Gravitee's open-source edition requires a JVM-based stack
plus MongoDB and Elasticsearch — a non-trivial operational commitment. The
Enterprise Edition is required for SSO, hybrid deployment, alerting, and async
API gateway features. Per-gateway pricing is easier to predict than per-call,
but multi-gateway deployments still scale linearly.

## How Zuplo prices

[Zuplo](https://zuplo.com/pricing) takes a different approach to API gateway
pricing. Instead of billing per-call, per-environment, or per-core, Zuplo offers
three transparent tiers designed to minimize surprise costs.

**Free ($0/month)**: Includes 100,000 requests/month, unlimited environments,
unlimited API keys, a developer portal, and deployment to 300+ global edge
locations. Ideal for prototyping and small-scale APIs.

**Builder ($25/month)**: Includes 100,000 requests with additional capacity at
$100 per 100,000 requests (up to 1 million/month). Adds custom domains and
community support.

**Enterprise (starting at $1,000/month on an annual contract)**: The Enterprise
tier is where Zuplo's pricing model diverges most from competitors. The base
Enterprise package includes an entry-level SLA and 1 million requests, with
volume discounts available. Beyond the base, Enterprise customers can add
capabilities through a single contract rather than purchasing separate products:

- Custom request volumes with volume discounts
- AI Gateway and MCP Gateway
- SAML SSO and SCIM provisioning
- Audit logs
- SOC 2 Type II compliance
- Managed dedicated deployment on AWS, Azure, GCP, Akamai, or other providers
- Premium support with up to 30-minute response SLAs
- SLAs up to 99.999%

The developer portal is included on every tier, including Free. The key
difference from competitors is that all of these capabilities are available
through a single vendor contract — competitors typically require separate
products, separate procurement cycles, or restrict features to much higher price
points.

Zuplo also offers a self-hosted option on Kubernetes for organizations with
strict data sovereignty requirements.

For teams evaluating Zuplo against other platforms, the key differentiator is
budget predictability. You can forecast annual costs without modeling traffic
spikes, environment count, or feature unlock scenarios — because those variables
don't change the price.

## Hidden cost categories every buyer misses

The base license or per-call price is never the whole story. Here are the hidden
costs that inflate API gateway bills:

**Data egress.** Cloud providers charge for data leaving their network. If your
APIs serve mobile apps, third-party partners, or on-premise systems, every
gigabyte of outbound data costs money. On AWS and GCP, egress fees can rival the
gateway license cost for data-heavy APIs. Zuplo's edge-native architecture
minimizes egress by serving responses from 300+ locations close to the consumer.

**Developer portal.** Many gateways either don't include a developer portal (AWS
API Gateway) or charge extra for it (Kong, Tyk commercial editions). Zuplo
includes an auto-generated, OpenAPI-driven developer portal with self-serve API
key management on every tier — including Free.

**SSO and SAML.** Single sign-on is table stakes for enterprise security, but
several vendors treat it as a premium add-on. Kong locks SSO behind Konnect
Enterprise. Tyk restricts SAML to higher tiers. Azure APIM requires Standard v2
or above for certain identity integrations. Zuplo makes SAML SSO and SCIM
provisioning available as an Enterprise add-on.

**Observability and analytics.** Advanced analytics, OpenTelemetry tracing, and
third-party logging integrations (Datadog, Splunk, CloudWatch) are frequently
add-ons. Apigee charges $20 per million analytics API calls. Azure APIM varies
analytics capabilities by tier. Evaluate what's included versus what requires a
separate contract.

**Premium support.** Standard support on most platforms means community forums
or slow-response tickets. Production-grade support with SLAs (24×7, 30-minute
response) is almost always an extra charge — sometimes calculated as a
percentage of total spend.

**Multi-region deployment.** Running an API gateway in multiple regions is
critical for availability, but most pricing models charge per-region. Apigee
charges per environment _per region_. Azure APIM Premium multiplies per unit per
region. Zuplo's managed edge deploys globally to 300+ locations on every tier
without per-region surcharges.

**AI gateway capabilities.** With AI APIs becoming central to modern
architectures, many teams need an AI gateway for model routing, token metering,
semantic caching, and budget controls. Most API gateways either lack these
capabilities entirely, offer them as a separate product (Tyk AI Studio), or
require custom development. Zuplo includes a purpose-built
[AI Gateway](https://zuplo.com/ai-gateway) and
[MCP Gateway](https://zuplo.com/mcp-gateway) as part of the Enterprise tier.

## Decision framework: matching pricing to your API program

Not every pricing model is equally bad or good — it depends on your API
program's shape. Here's how to match the right pricing pattern to your
situation.

**Low-volume, unpredictable traffic** — Best fit: Pay-per-call (AWS API Gateway
HTTP APIs). If you are running a handful of internal APIs with sporadic traffic,
per-call pricing at $1/million requests is hard to beat. The risk is that costs
become unpredictable if traffic grows.

**High-volume external APIs** — Best fit: Flat-rate subscription (Zuplo
Enterprise, MuleSoft contract). When you are serving millions of requests to
external developers and partners, predictable costs matter more than low unit
prices. A $350 monthly AWS REST API bill at 100 million requests is just the
beginning once you add egress, WAF, logging, and developer portal costs.

**Enterprise with compliance requirements** — Best fit: Bundled enterprise
(Zuplo Enterprise, Apigee Enterprise Plus). If you need SOC 2, SSO, audit logs,
and dedicated infrastructure, look for platforms that consolidate these into a
single contract rather than charging for each as a separate add-on. The
procurement and renewal process is dramatically simpler.

**Kubernetes-native teams** — Best fit: Self-managed open source (Kong OSS, Tyk
OSS) or managed (Zuplo managed dedicated). If your team already operates
Kubernetes clusters and has the DevOps expertise, self-hosting an open-source
gateway can minimize licensing costs — but be honest about the operational
overhead. Zuplo's managed dedicated option provides deployment without the
operational burden.

**AI-first API programs** — Best fit: AI-native gateway (Zuplo Enterprise with
AI Gateway). If you are building products around LLM APIs and need model
routing, token metering, prompt injection protection, and per-customer budgets,
choose a platform with native AI gateway capabilities rather than bolting on a
separate tool. Zuplo's [AI Gateway](https://zuplo.com/ai-gateway) handles these
use cases natively.

## How to evaluate total cost of ownership

When comparing API gateway pricing, build a total-cost model that includes these
categories:

1. **Base license or subscription**: The headline price from the vendor's
   pricing page
2. **Usage-based charges**: Per-call, per-environment, or per-service fees at
   your projected traffic levels
3. **Infrastructure costs**: Cloud compute, networking, and storage for
   self-hosted options
4. **Feature add-ons**: Developer portal, analytics, SSO, WAF, AI gateway, and
   premium support
5. **Operational overhead**: Staff time to manage, patch, scale, and
   troubleshoot the gateway — especially relevant for self-hosted open-source
   options
6. **Egress and data transfer**: Outbound data charges from your cloud provider
7. **Multi-region multipliers**: How the cost changes when you need HA across 2+
   regions

Model your costs at current traffic, 3× traffic, and 10× traffic. Per-call
pricing that looks cheap today can become the largest line item on your cloud
bill as your API program scales.

## Get predictable API gateway pricing

If you are tired of modeling per-call, per-environment, and per-region costs,
[see Zuplo's pricing](https://zuplo.com/pricing) or
[talk to an API architect](https://zuplo.com/meeting) to get an Enterprise quote
that consolidates the gateway, developer portal, AI Gateway, SSO, and audit logs
into a single contract.

## Further reading

- [Best API Management Platforms (2026)](/learning-center/best-api-management-platforms-2026)
  — a comprehensive feature comparison across all major platforms
- [Best API Gateways in 2026](/learning-center/best-api-gateways-2026) — a
  developer's guide to choosing the right API gateway
- [The True Cost of Apigee: TCO Analysis](/learning-center/the-true-cost-of-apigee-tco-analysis)
  — a deep dive into Apigee's real-world costs
- [8 Types of API Pricing Models](/blog/8-types-of-api-pricing-models) — covers
  pricing models for monetizing your own APIs (not gateway vendor pricing)
- [API Management Buyer's Guide](/learning-center/api-management-buyers-guide) —
  a framework for evaluating API management platforms beyond just price