Apigee

Overview

Apigee is a full-lifecycle API management platform acquired by Google in 2016. It provides tools for organizations to design, secure, deploy, operate, and scale APIs. The platform is engineered for enterprise-scale API programs, supporting complex use cases such as integrating legacy systems, managing hybrid and multi-cloud API deployments, and enabling API monetization strategies. Apigee's architecture facilitates abstracting backend services from frontend applications, allowing developers to create API proxies that enforce policies, manage traffic, and provide security layers without altering backend code.

Key components include an API gateway for traffic management, a developer portal for API discovery and consumption, and advanced analytics for monitoring API performance and user engagement. Apigee supports various deployment models, including Apigee X for cloud-native deployments on Google Cloud, Apigee Hybrid for distributed deployments across on-premises data centers and multiple clouds, and Apigee Edge for specific legacy requirements. This flexibility allows enterprises to manage their APIs where their data and applications reside, addressing data residency and compliance needs.

The platform is designed to cater to large organizations with extensive API portfolios, requiring granular control over API access, versioning, and policy enforcement. For instance, Apigee can implement advanced security policies like OAuth 2.0 and SAML for API authentication, and provide threat protection against common API attacks. Its analytics capabilities offer insights into API usage patterns, error rates, and latency, which are critical for optimizing API performance and understanding business impact. The platform also includes monetization features, allowing businesses to create pricing plans and manage billing for their API products. This comprehensive approach makes Apigee suitable for companies with strategic API initiatives, aiming to create new revenue streams or enhance ecosystem engagement through APIs.

Key features

• API Proxy Management: Create API proxies to add a management layer over backend services, enabling policy enforcement, traffic management, and security. Information about proxy creation is available in the Apigee documentation on API proxies.
• Traffic Management: Implement policies for spike arrest, quotas, caching, and rate limiting to control API traffic flow and ensure stability.
• API Security: Secure APIs with OAuth 2.0, API key verification, JSON Web Token (JWT) policies, and threat protection against SQL injection and other vulnerabilities. Details on security can be found in the Apigee API security overview.
• Analytics and Monitoring: Gain insights into API usage, performance, and operational health through customizable dashboards and reports.
• Developer Portal: Provide a self-service portal for third-party developers to discover, register for, and test APIs, fostering API adoption.
• API Monetization: Configure flexible pricing models, generate billing reports, and manage developer revenue streams for API products.
• Hybrid and Multi-Cloud Deployment: Deploy and manage APIs consistently across Google Cloud, on-premises data centers, and other cloud providers using Apigee Hybrid. The Apigee Hybrid documentation provides architectural details.
• Policy Enforcement Engine: Apply pre-built and custom policies for transformation, mediation, security, and governance to API requests and responses.
• API Versioning: Manage different versions of APIs to allow for iterative development while maintaining backward compatibility.

Pricing

Apigee offers an evaluation program for users to explore the platform. Paid tiers are structured primarily around Apigee X, with custom pricing for Apigee Hybrid. Pricing typically scales with the number of API calls, environment instances, and included features.

As of 2026-05-08

For detailed and up-to-date pricing information, refer to the official Apigee pricing page.

Common integrations

• Google Cloud Services: Integrates with various Google Cloud services like Cloud Identity and Access Management (IAM) for authentication, Cloud Logging for audit trails, and Cloud Monitoring for operational visibility. Refer to Apigee IAM documentation.
• Identity Providers: Connects with external identity providers (IdPs) such as Okta, Auth0, and Microsoft Azure Active Directory for user authentication and authorization.
• CI/CD Pipelines: Can be integrated into continuous integration and continuous deployment pipelines using tools like Jenkins, GitLab CI, or GitHub Actions for automated API deployment.
• Monitoring Tools: Exports metrics and logs to third-party monitoring solutions like Splunk or Datadog for centralized observability.
• Security Gateways: Works with Web Application Firewalls (WAFs) and other security appliances to provide additional layers of protection for APIs.
• Service Meshes: Can be deployed alongside service mesh technologies like Istio for advanced traffic management and policy enforcement, as described in Apigee's Istio integration guide.

Alternatives

• Kong: An open-source API gateway and service mesh platform, offering a high-performance solution for microservices and APIs.
• Azure API Management: Microsoft's fully managed service for publishing, securing, transforming, maintaining, and monitoring APIs.
• AWS API Gateway: A fully managed service that helps developers create, publish, maintain, monitor, and secure APIs at any scale.

Getting started

To begin with Apigee, new users typically start with the evaluation program. This process involves setting up an Apigee X evaluation instance within the Google Cloud console. Once the environment is provisioned, you can start creating API proxies and applying policies. The following Node.js example demonstrates a basic API proxy configuration to a target endpoint. This example assumes you have an Apigee environment set up and are using the Apigee command-line interface (CLI) or the Apigee UI to deploy the proxy.

First, ensure you have the Apigee CLI installed and authenticated to your Google Cloud project.

Here’s an example of a simple API proxy configuration in Apigee, often defined in XML files. This proxy would forward requests to a public test API.

<!-- proxy.xml: Defines the API proxy endpoint -->
<APIProxy name="my-first-proxy" revision="1"
    startPath="/v1/myapi"
    xmlns="http://apigee.com/apigee-internal-2006-05-01.xsd">

    <Description>My first Apigee proxy</Description>
    <ConfigurationVersion major="4" minor="0"/>
    <TargetEndpoints>
        <TargetEndpoint>default</TargetEndpoint>
    </TargetEndpoints>
    <ProxyEndpoints>
        <ProxyEndpoint>default</ProxyEndpoint>
    </ProxyEndpoints>

</APIProxy>

<!-- default.xml (ProxyEndpoint): Defines the inbound request path -->
<ProxyEndpoint name="default">
    <PreFlow name="PreFlow"/>
    <PostFlow name="PostFlow"/>
    <Flows/>
    <HTTPProxyConnection>
        <BasePath>/v1/myapi</BasePath>
        <VirtualHost>default</VirtualHost>
    </HTTPProxyConnection>
    <RouteRule name="default">
        <TargetEndpoint>default</TargetEndpoint>
    </RouteRule>
</ProxyEndpoint>

<!-- default.xml (TargetEndpoint): Defines the backend service to call -->
<TargetEndpoint name="default">
    <PreFlow name="PreFlow"/>
    <PostFlow name="PostFlow"/>
    <Flows/>
    <HTTPTargetConnection>
        <URL>https://httpbin.org/get</URL>
    </HTTPTargetConnection>
</TargetEndpoint>

To deploy this proxy using the Apigee CLI:

# Assuming your proxy files are in a directory named 'myproxy'
# and you have set your gcloud project and Apigee organization details

# Configure the Apigee environment variable (replace with your actual organization and environment)
export APIGEE_ORG="your-apigee-org-name"
export APIGEE_ENV="your-apigee-env-name"

# Deploy the API proxy
gcloud apigee apis deploy --api my-first-proxy --apigee-organization $APIGEE_ORG --file myproxy/ --environment $APIGEE_ENV

# Or, using the Apigee runtime API directly (requires API key or OAuth)
# curl -X POST -H "Authorization: Bearer $(gcloud auth print-access-token)" \
#   -H "Content-Type: application/octet-stream" \
#   "https://apigee.googleapis.com/v1/organizations/$APIGEE_ORG/apis?action=import&name=my-first-proxy" \
#   --data-binary "@myproxy.zip"

After deployment, the API would be accessible via your Apigee proxy endpoint, for example: https://YOUR_APIGEE_HOSTNAME/v1/myapi. For a comprehensive guide on setting up your first proxy, refer to the Apigee quickstart tutorial for creating an API proxy.