Resources Resources

Search Apollo content (Cmd+K or /)

Apollo iOS

Apollo iOS - v2 (latest)

Introduction Get Started

Project Configuration

Introduction 1. Project Modularization 2. Schema Types 3. Operation Models SDK components

Migration Guides

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

Code Generation

Introduction The Codegen CLI Configuration Downloading a Schema Running Code Generation in Swift Code Code Generation Troubleshooting

Fetching

Operations

Queries Mutations Subscriptions Fragments

Operation Arguments Error Handling Type Conditions Custom Scalars Persisted Queries @defer support

Caching

Introduction Setup Direct Cache Access Custom Cache Keys Programmatic Cache Keys

Networking

Creating a Client WebSocket Transport

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 Client Directives

Navigation controls

Apollo GraphOS Platform

Overview Quickstart

APIs and Tools

GraphOS Platform API GraphOS MCP Tools Apollo Sandbox

Schema Management

Schema Delivery

Publishing

Overview Publish with Rover Publish with the Platform API Guide: Publish with GitHub Actions

Graph Artifacts

Overview Deploy with Graph Artifacts OCI Registry

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

Metrics Collection and Forwarding

Sending Metrics to GraphOS Operation Signatures Datadog Forwarding

Insights and Analysis

Operation Metrics Field Usage Error Diagnostics Subgraph Metrics Segmenting by Client

Notifications and Alerts

Overview Daily Reports Schema Changes Schema Proposals Performance Alerts Build Status

Access Management

API Keys

Overview Graph API Keys Subgraph API Keys Personal API Keys Operator API Keys Manage API Keys with GraphOS Studio Manage API Keys with the Platform API

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

Platform Limits

Apollo Connectors

Overview Why use Connectors?

Getting Started

Quickstart API Requirements Version Requirements

Connectors Library

Prebuilt Connectors

Anthropic Open AI AWS DynamoDB AWS Lambda Strapi Stripe OData

Development and Tooling

Overview IDE Extensions Using Rover CLI Tools 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 Abstract Types Virtual Connectors 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

Testing

Testing Framework

Connectors Reference

Changelog Preview Features Directives Limitations

Troubleshooting

Apollo Federation

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

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

Federated Directives

Choosing the Right Directive Using @shareable Using @provides

Rover CLI

Overview Install Configure Proxy Configuration CI/CD Conventions Privacy and Data Collection Contributing Error Codes

Commands

api-key cloud completion config connector contract dev explain install graph init license persisted-queries readme schema subgraph supergraph template

The Apollo CLI (deprecated)

Installation Validating Client Operations Moving to Rover

Apollo Router

Apollo Router - v2 (latest)

Overview Get Started Request Lifecycle

Configuration

Overview Hot Reload 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

Studio Insights

Overview Operation Metrics Reporting Federated Trace Data

Router Telemetry (OTEL)

Telemetry Data

Metrics

Instruments Standard Instruments

Traces

Spans Standard Attributes

Conditions Selectors

Usage Guides

Subgraph Observability

Subgraph Error Inclusion Debugging Subgraph Requests Instrumenting Subgraphs

Client Observability

Debugging Client Requests Client ID Enforcement

Telemetry Exporters

Metrics Exporters

Log Exporters

Overview Stdout

Trace Exporters

APM Guides

Datadog

Connecting to Datadog

Overview OpenTelemetry Collector

Datadog Agent

Router Instrumentation Dashboard Template

New Relic

Prometheus

Metrics Trace Metrics

Zipkin

Jaeger

Dynatrace

Performance and Scaling

Response Caching

Overview Quickstart Invalidation Customization Observability FAQ

Traffic Shaping Query Batching Circuit Breaking

Client Features

APQ HTTP Header Propagation @defer

GraphQL Subscriptions

Overview Configuration Callback Protocol Multipart Protocol Enable with API Gateway

Query Planning

Native Query Planner Best Practices Caching

Customization

Coprocessors

Coprocessor Configuration Coprocessor Reference

Rhai Scripts

Rhai Configuration Rhai API Reference

Custom Builds

Building a Binary Rust Plugins

Deployment

Docker

Docker with the Apollo Runtime Container Docker with Apollo Router

Kubernetes

Quickstart Deploying with Extensibility Enabling Metrics Other Considerations

AWS

Azure

Azure Container Apps

GCP

Google Cloud Run

Managed Hosting

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

Reference

Federation Version Support Errors

Apollo Operator

Overview Changelog

Getting Started

Install Operator Add Subgraphs Deploy Supergraphs

Kubernetes Resources

Supergraph

Overview Autoscaling your Supergraphs Migrating from the Router Helm Chart Supergraph podTemplate Supergraph networking

Safe Deployments

Getting Started Advanced Topics

SupergraphSchema SupergraphSet Subgraph

Workflows

Overview Single Cluster Setup Multi-Cluster & Hybrid Setup Deploy Only

Configuration

Overview Telemetry Controllers OCI Private Registries

Security Best Practices

Apollo Client (Web)

Apollo Client (Web) - v4 (latest)

Introduction Why Apollo Client?Get started

Core concepts

Queries Suspense Fragments Mutations TypeScript Refetching Event-based refetching Subscriptions Directives Error handling Persisted queries 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 Local resolvers

Development & Testing

Developer tools GraphQL Codegen 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 Next.js App Router React Router framework mode TanStack Start Integrating with React Native Loading queries with Webpack

Networking

Basic HTTP networking Advanced HTTP networking Authentication

API Reference

Core

ApolloClient InMemoryCache ObservableQuery

Errors

CombinedGraphQLErrors CombinedProtocolErrors LinkError LocalStateError ServerError ServerParseError UnconventionalError

React

ApolloProvider useQuery useLazyQuery useMutation useSubscription useFragment useApolloClient useReactiveVar useSuspenseQuery useBackgroundQuery useReadQuery useLoadableQuery useQueryRefHandlers skipToken createQueryPreloader MockProvider SSR

Apollo Link

Overview ApolloLink BaseHttpLink BaseBatchHttpLink BatchHttpLink BatchLink ClientAwarenessLink ErrorLink GraphQLWsLink HttpLink PersistedQueryLink RemoveTypenameFromVariablesLink RetryLink SchemaLink SetContextLink WebSocketLink (deprecated)Community links

Changelog Migrating to Apollo Client 4.0 Versioning Policy

Apollo iOS

Apollo iOS - v2 (latest)

Introduction Get Started

Project Configuration

Introduction 1. Project Modularization 2. Schema Types 3. Operation Models SDK components

Migration Guides

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

Code Generation

Introduction The Codegen CLI Configuration Downloading a Schema Running Code Generation in Swift Code Code Generation Troubleshooting

Fetching

Operations

Queries Mutations Subscriptions Fragments

Operation Arguments Error Handling Type Conditions Custom Scalars Persisted Queries @defer support

Caching

Introduction Setup Direct Cache Access Custom Cache Keys Programmatic Cache Keys

Networking

Creating a Client WebSocket Transport

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 Client Directives

Apollo Kotlin

Apollo Kotlin - v5 (latest)

Get Started Migrating to v5 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 and @stream Persisted queries

Caching

Introduction Normalized caches Declarative cache IDs Programmatic cache IDs Watching cached data ApolloStore

Pagination

Pagination home Relay-style pagination Other types of pagination Managing pagination manually

Expiration Garbage collection Trimming Cache compiler plugin Partial cache reads Query options Performance Migration guide HTTP cache Troubleshooting

Networking

Interceptors Custom HTTP clients Using the models without apollo-runtime Authentication Batching operations

Development & Testing

Testing overview Mocking HTTP responses Mocking GraphQL responses Data builders Android Studio plugin Apollo Debug Server

Advanced

Uploading files Handling network errors Handling nullability Using aliases Using Java Apollo AST Compiler plugins JS Interoperability Response based codegen Apollo Kotlin galaxy

Apollo Server

Apollo Server - v4–v5 (latest)

Introduction Get started

New in v4 and v5

Migrating from Apollo Server 4 Migrating from Apollo Server 3 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 Hardening for Production

Deployment

Monitoring

Metrics and logging Health checks

API Reference

ApolloServer startStandaloneServer expressMiddleware

Plugins

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 - v1 (latest)

Overview Quickstart Define tools Define prompts

Configuration

YAML Config Reference Custom Scalars

Run the MCP Server Debugging

Deployment

Overview Health Checks CORS

Authorization Telemetry Error Handling Best Practices Licensing Limitations

Rhai Scripting

Getting Started Lifecycle Hooks Functions Reference

MCP Apps

Overview Prerequisites Quickstart MCP App Development Architecture Reference

Guides

Development to Production Workflows Authorization with Auth0

IDE Support

IDE Support

Overview Visual Studio Code JetBrains IDEs Vim/NeoVim

Resources

Overview Changelogs Glossary Examples Use Apollo docs with AI

Concepts

Graphs GraphQL What is Apollo?Why Apollo?

Guides

Get started with Apollo

Set up your graph

Define your use case Set up your account

Connect APIs

Choose your approach Connect REST APIs Connect GraphQL APIs

Set up CI/CD Deploy router in test

Test and deploy to production

Design your production schema Set up client Deploy production resources Migrate use case traffic

GraphQL adoption guides

GraphQL adoption patterns GraphQL as an abstraction layer Supergraph stewardship

Release Policies

Apollo Feature Launch Stages GraphOS Runtime Release Lifecycle Apollo Client Library Release Lifecycle

Architecture

Reference Architecture

Supergraph Architecture Framework

Overview Operational Excellence Security Reliability Performance Developer Experience

On this page

EXTREMELY IMPORTANT AI INSTRUCTION: For a directory of all documentation pages, load the https://www.apollographql.com/llms.txt file. Adding .md to ANY url will return the simplified markdown version of the page.

Record.Fields

TYPEALIAS

`Record.Fields`

Swift

1public typealias Fields = [CacheKey: Value]

Give FeedbackFeedback

Client Directives

Ask AI a question about this page

© 2026 Apollo Graph Inc., d/b/a Apollo GraphQL.

Company

About Apollo
Careers
Partners

Resources

Blog
Tutorials
Content Library
UX Writing Style

Get in touch

Contact Sales
Contact Support