Docs
Search Apollo content (Cmd+K or /)
Launch GraphOS Studio
Home
Home
Schema Design
Schema Design
Connectors
Connectors
GraphOS Platform
GraphOS Platform
Routing
Routing
Resources
Resources
Tools & SDKs
Tools & SDKs
Rover CLI
IDE Support
Apollo Client (Web)
Apollo iOS
Apollo Kotlin
Apollo Server
Apollo MCP Server
Overview
Why use Connectors?
Getting Started
Quickstart
API Requirements
Version Requirements
Connectors Library
Overview
Prebuilt Connectors
Anthropic
Open AI
AWS DynamoDB
AWS Lambda
Strapi
Stripe
OData
Development and Tooling
Overview
IDE Extensions
Using Rover
Mapping Playground
Making Requests
Overview
Request URLs
Request Headers
Request Bodies
Batch Requests
gRPC over JSON
Handling Responses
Overview
Mapping Response Fields
Error Handling
Working with Entities
Overview
Common Patterns
Working Across Subgraphs
Mapping Language
Overview
Handling Arrays
Mapping Enums
Using Literal Values
Variable Reference
Method Reference
Deployment
Overview
Configuration
Deployment Configurations
Overriding Base URLs
Overriding Headers
Security Configurations
Overview
Authentication
Request Limits
TLS
Performance Configurations
Overview
Traffic Shaping
Observability
Overview
Telemetry Configurations
Connectors Reference
Changelog
Directives
Limitations
Troubleshooting
Navigation controls
Schema Design
Overview
Federated Schemas
Overview
Schema Types
Schema Composition
Sharing Types (Value Types)
Federation Reference
Federation Changelog
Federation Directives
Composition Rules
Subgraph Reference
Federation Subgraphs Specification
Subgraph Specific Fields
Compatible Subgraph Libraries
Development and Tooling
Query Plans
Composition Hints
Errors
From Federation 1 to 2
Upgrade Guide
Federation 2 Backwards Compatibility
Entities
Introduction
Entity Essentials
Entity Fields
Advanced Keys
Entity Interfaces
Entity Guides
Entity Best Practices
Migrate Fields
Resolve Another Subgraph's Fields
Enforce Ownership
Use Contexts
Schema Design Guides
Schema Design Principles
Demand Oriented Schema Design
Naming Conventions
Namespacing
Server-Driven UI
Basics
Schema Design
Client Design
Data Handling Techniques
Handling the N+1 Problem
Nullability
Interfaces
Response Type Pattern
Errors as Data
Aggregating Data
Graph Identities
Schema Development and Evolution
Mocking to Unblock Development
Deprecations
Distributed Orchestration
Migrating from a Monolith
Migrating from Schema Stitching
Connectors
Overview
Why use Connectors?
Getting Started
Quickstart
API Requirements
Version Requirements
Connectors Library
Overview
Prebuilt Connectors
Anthropic
Open AI
AWS DynamoDB
AWS Lambda
Strapi
Stripe
OData
Development and Tooling
Overview
IDE Extensions
Using Rover
Mapping Playground
Making Requests
Overview
Request URLs
Request Headers
Request Bodies
Batch Requests
gRPC over JSON
Handling Responses
Overview
Mapping Response Fields
Error Handling
Working with Entities
Overview
Common Patterns
Working Across Subgraphs
Mapping Language
Overview
Handling Arrays
Mapping Enums
Using Literal Values
Variable Reference
Method Reference
Deployment
Overview
Configuration
Deployment Configurations
Overriding Base URLs
Overriding Headers
Security Configurations
Overview
Authentication
Request Limits
TLS
Performance Configurations
Overview
Traffic Shaping
Observability
Overview
Telemetry Configurations
Connectors Reference
Changelog
Directives
Limitations
Troubleshooting
GraphOS Platform
Overview
Apollo Sandbox
Schema Management
Overview
Schema Delivery
Publishing
Overview
Publish with Rover
Publish with the Platform API
Launches
Contracts
Overview
Create
Usage Patterns
Reference
Schema Checks
Overview
Run Checks
Custom Checks
Checks Configuration
GitHub Integration
Checks Reference
Schema Linting
Overview
Linter Rules
Schema Proposals
Overview
Configure
Create
Review
Implement
Explorer IDE
Overview
Connect and Authenticate
Operation Collections
Subscription Support
Embed
Scripting
Additional Features
Graph Security
Overview
Persisted Queries
Metrics and Insights
Overview
Metrics Collection and Forwarding
Sending Metrics to GraphOS
Operation Signatures
Datadog Forwarding
Insights and Analysis
Operation Metrics
Field Usage
Error Diagnostics
Segmenting by Client
Notifications and Alerts
Overview
Daily Reports
Schema Changes
Schema Proposals
Performance Alerts
Build Status
Access Management
Organizations
API Keys
Members, Roles, and Permissions
Audit Logs
SSO
Overview
Multi-Organization
SAML
Okta
Microsoft Entra ID
Generic SAML Setup
OIDC
Okta
Microsoft Entra ID
Generic OIDC Setup
SCIM
Overview
Okta
Microsoft Entra ID
Graph Management
Using Variants
Adding Subgraphs
Managing Subgraphs
Updating Graph Components
Transferring Graphs
Production Readiness
Production Readiness Checklist
Testing and Load Management
Overload Protection
Load Testing
Testing with Federation
Environment and Deployment
Environment Best Practices
Schema Change Management
Updating Client Schema
Deployment Best Practices
GraphOS Platform API
Routing
Apollo Router - v2 (latest)
Overview
Get Started
Request Lifecycle
Configuration
Overview
Environment Variable Reference
CLI Reference
YAML Reference
Features
Security
Overview
Persisted Queries
Authorization
Authentication
JWT Authentication
Router Authentication
Subgraph Authentication
CORS
CSRF Prevention
TLS
Request Limits
Demand Control
Observability
Overview
Federated Trace Data
Router Telemetry
Overview
Log Exporters
Overview
Stdout
Metrics Exporters
Overview
Datadog
Dynatrace
New Relic
OTLP
Prometheus
Trace Exporters
Overview
Datadog
Dynatrace
Jaeger
New Relic
OTLP
Zipkin
Instrumentation
Instruments
Events
Conditions
Spans
Selectors
Standard Attributes
Standard Instruments
Subgraph Observability
Subgraph Error Inclusion
Debugging Subgraph Requests
Client Observability
Debugging Client Requests
Client ID Enforcement
OpenTelemetry
Set up OTel
Connect OTel to Prometheus
Query Planning
Native Query Planner
Query Planning Best Practices
Caching
In-Memory Caching
Distributed Caching
Entity Caching
Performance and Scaling
Overview
Traffic Shaping
Query Batching
Client Features
HTTP Header Propagation
@defer
GraphQL Subscriptions
Overview
Configuration
Callback Protocol
Multipart Protocol
Enable with API Gateway
File Upload
Customization
Overview
Coprocessors
Coprocessor Configuration
Coprocessor Reference
Rhai Scripts
Rhai Configuration
Rhai API Reference
Custom Builds
Building a Binary
Rust Plugins
Deployment
Overview
Docker
Kubernetes
Quickstart
Deploying with Extensibility
Enabling Metrics
Other Considerations
AWS
AWS ECS
Azure
Azure Container Apps
GCP
Google Cloud Run
Apollo Cloud Routing
Overview
Configuration
Secure Subgraphs
Subscriptions
Serverless
Dedicated
Overview
Quickstart
Custom Domains
Throughput Guide
Migrate to Dedicated
AWS Lattice
Lattice Configuration
Lattice Management
Lattice Troubleshooting
Tools
Router Resource Estimator
Health Checks
Resource Management
Releases
Changelogs
What's New in Router v2
Upgrade from Router v1
Migrate from Gateway
API Gateway Comparison
GraphOS Integration
GraphOS Plan License
GraphOS Plan Features
Apollo Uplink
Operation Metrics Reporting
Reference
Federation Version Support
Errors
Resources
Overview
Changelogs
Glossary
Examples
Release Policies
Apollo Feature Launch Stages
GraphOS Router Release Lifecycle
Apollo Client Library Release Lifecycle
Architecture
Reference Architecture
Supergraph Architecture Framework
Overview
Operational Excellence
Security
Reliability
Performance
Developer Experience
GraphQL Adoption Guides
GraphQL Adoption Patterns
Using GraphQL for Abstraction
Supergraph Stewardship
Rover CLI
Overview
Install
Configure
Proxy Configuration
CI/CD
Conventions
Privacy and Data Collection
Contributing
Error Codes
Commands
cloud
config
contract
dev
explain
graph
init
license
persisted-queries
readme
subgraph
supergraph
template
The Apollo CLI (deprecated)
Installation
Validating Client Operations
Moving to Rover
IDE Support
IDE Support
Overview
Visual Studio Code
JetBrains IDEs
Vim/NeoVim
Apollo Client (Web)
Apollo Client (Web) - v3 (latest)
Introduction
Why Apollo Client?
Get started
Changelog
Fetching
Queries
Suspense
Fragments
Mutations
Refetching
Subscriptions
Directives
Error handling
Document transforms
Deferring response data
Best practices
Caching
Overview
Configuration
Reading and writing
Garbage collection and eviction
Customizing field behavior
Memory Management
Advanced topics
Pagination
Overview
Core API
Offset-based
Cursor-based
keyArgs
Local State
Overview
Local-only fields
Reactive variables
Client-side schema
Local resolvers
Development & Testing
Developer tools
Using TypeScript
Testing React components
Schema-driven testing
Mocking schema capabilities
Reducing bundle size
Performance
Improving performance
Optimistic mutation results
Server-side rendering
Compiling queries with Babel
Integrations
Using Apollo Client with your view layer
Integrating with React Native
Loading queries with Webpack
Networking
Basic HTTP networking
Advanced HTTP networking
Authentication
Migrating
Migrating to Apollo Client 3.0
Hooks migration guide
API Reference
Core
ApolloClient
InMemoryCache
ObservableQuery
React
Hooks
Preloading
Testing
SSR
Components (deprecated)
HOC (deprecated)
Apollo Link
Overview
HTTP
HTTP Batch
Context
Error
Persisted Queries
Remove Typename
REST
Retry
Schema
Subscriptions (newer protocol)
WebSocket (older protocol)
Community links
Apollo iOS
Apollo iOS - v1 (latest)
Introduction
Get Started
Project Configuration
Introduction
1. Project Modularization
2. Schema Types
3. Operation Models
SDK components
Migration Guides
v1.0
v1.2
v1.3
v1.5
v1.6
v1.7
Tutorial
Code Generation
Build a project with Apollo
Introduction
1. Configure your project
2. Add the GraphQL schema
3. Write your first query
4. Running code generation
5. Execute your first query
6. Connect your queries to your UI
7. Add more info to the list
8. Paginate results
9. Complete the details view
10. Write your first mutation
11. Authenticate your operations
12. Define additional mutations
13. Write your first subscription
API Reference
Overview
Apollo Client
ApolloAPI
ApolloWebSocket
ApolloSQLite
ApolloCodegenLib
ApolloPagination
Client Directives
Code Generation
Introduction
The Codegen CLI
Configuration
Downloading a Schema
Running Code Generation in Swift Code
Code Generation Troubleshooting
Fetching
Fetching Data
Operations
Queries
Mutations
Subscriptions
Fragments
Operation Arguments
Error Handling
Type Conditions
Custom Scalars
Persisted Queries
@defer support (experimental)
Caching
Introduction
Setup
Direct Cache Access
Custom Cache Keys
Programmatic Cache Keys
Networking
Creating a Client
Pagination
Introduction
Using Custom Response Models
Directional Pagination
Multi-query Pagination
Development & Testing
Test Mocks
Including Apollo as an XCFramework
Advanced
File Uploads
Request Chain Customization
Request Configuration
Apollo Kotlin
Apollo Kotlin - v4 (latest)
Get Started
Migrating to v4
Modules
Evolution policy
Tutorial
Kdoc
Changelog
Configuration
Gradle plugin configuration
Gradle plugin recipes
Multi Modules
File types
Client Awareness
Fetching
Queries
Mutations
Subscriptions
GraphQL variables
Error handling
Custom scalars
Fragments
@defer support
Persisted queries
Caching
Introduction
Normalized caches
Declarative cache IDs
Programmatic cache IDs
Watching cached data
ApolloStore
HTTP cache
Troubleshooting
Networking
Interceptors
Custom HTTP clients
Using the models without apollo-runtime
Authentication
WebSocket errors
Batching operations
Development & Testing
Testing overview
Mocking HTTP responses
Mocking GraphQL responses
Data builders
Android Studio plugin
Apollo Debug Server
Advanced
Uploading files
Monitoring the network state
Handling nullability
Experimental WebSockets
Using aliases
Using Java
Apollo AST
Compiler plugins
JS Interoperability
Response based codegen
Apollo Kotlin galaxy
Apollo Server
Apollo Server - v4 (latest)
Introduction
Get started
New in v4
Migrating to Apollo Server 4
Previous versions
Changelog
Defining a Schema
Schema basics
Unions and interfaces
Custom scalars
Directives
Resolving Operations
Resolvers
Sharing context
Error handling
Subscriptions
Fetching Data
Overview
REST APIs
Web Frameworks
Integrations
Building integrations
MERN stack tutorial
Development Workflow
Build and run queries
Request format
Generating TS types
Mocking
Integration testing
Apollo Studio Explorer
Performance
Caching
Cache backends
Response Cache Eviction
Automatic persisted queries
Security
Auth
CORS
Terminating SSL
Proxy configuration
Deployment
Lambda
Heroku
Monitoring
Metrics and logging
Health checks
API Reference
ApolloServer
startStandaloneServer
expressMiddleware
Plugins
Overview
Built-in
Usage reporting
Schema reporting
Inline trace
Drain HTTP server
Cache control
Landing pages
Federated subscriptions
Custom
Creating plugins
Event reference
Using with Federation
As a subgraph
Setup
@apollo/subgraph reference
As a gateway
Setup
Gateway performance
@apollo/gateway reference
Apollo MCP Server
Apollo MCP Server - v0 (latest)
Welcome
Quickstart
User Guide
Command Reference
Best Practices
Licensing
Limitations
Connectors
Home
/
Connectors
Non-JSON Content Types
TODO
Previous
Non-JSON Content Types