Docs
Search Apollo content (Cmd+K or /)
Launch GraphOS Studio
Home
Home
Get Started
Get Started
GraphOS Platform
GraphOS Platform
Schema Design
Schema Design
Routing
Routing
Reference
Reference
Apollo Client (Web)
Apollo Client (Web)
Rover CLI
Apollo Sandbox
Apollo Client (Web)
Apollo iOS
Apollo Kotlin
Apollo Server
Apollo Router Core
VS Code Extension
Apollo Client (Web) - v2
Introduction
Why Apollo Client?
Get started
Fetching data
Queries
Mutations
Local state management
Subscriptions
Pagination
Using fragments
Error handling
Caching
Configuring the cache
Interacting with cached data
Development & Testing
Using Apollo with TypeScript
Testing React components
Mocking new schema capabilities
Developer tools
Performance
Improving performance
Optimistic UI
Server-side rendering
Compiling queries with Babel
Integrations
View integrations
Integrating with React Native
Integrating with Meteor
Loading queries with Webpack
Networking
Network layer (Apollo Link)
Authentication
API Reference
class ApolloClient
@apollo/react-hooks
@apollo/react-ssr
@apollo/react-testing
@apollo/react-components
@apollo/react-hoc
@apollo/react-common
Migrating
Hooks migration guide
Apollo Boost migration
Navigation controls
Get Started
Overview
Quickstarts
Start with a GraphQL API
Connect a REST API
Concepts
GraphQL
Graph Types
GraphOS Platform
GraphOS Platform
Overview
Schema Management
Overview
Schema Delivery
Publish
Launch
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
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
Self-Service Migration
Multi-Organization
SAML
Okta
Microsoft Entra ID
Generic SAML Setup
OIDC
Okta
Microsoft Entra ID
Generic OIDC Setup
Graph Management
Using Variants
Adding Subgraphs
Managing Subgraphs
Updating Graph Components
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
Schema Design
Overview
Federated Schemas
Apollo Federation
Schema Types
Schema Composition
Sharing Types (Value Types)
Entities
Introduction
Define Keys
Contribute Fields
Resolve Another Subgraph's Fields
Use Contexts
Interfaces
Migrate Fields
Enforce Ownership
Entity Best Practices
Apollo Connectors
Overview
Common Patterns
Connectors Guides
Making HTTP Requests
Working with Federation
Working with Router
Selection Mapping
Observability
Enabling VS Code Extension
Troubleshooting
Connectors Reference
Directives
Limitations
Changelog
Schema Design Guides
Handling the N+1 Problem
Schema Design Principles
Schema Naming Conventions
Namespacing
Mocking to Unblock Development
Demand Oriented Schema Design
Aggregating Data
Nullability
Errors as Data
Deprecations
Advanced Schema Techniques
Interfaces
Response Type Pattern
Graph Identities
Relay Style Connections and Pagination
Distributed Orchestration
Routing
Overview
About GraphOS Router
Configure Your Router
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
Self-Hosted Deployment
Overview
Router Resource Estimator
Health Checks
Resource Management
Containerization
Overview
Docker
Kubernetes
Optimize Builds
Query Planning
Native Query Planner
Client Features
HTTP Header Propagation
File Upload Support
Real-Time Operations
Overview
Defer Support
Subscription Support
Overview
Callback Protocol
Multipart Protocol
Enable with API Gateway
Security
Overview
Persisted Queries
Authorization
Authentication
JWT Authentication
Router Authentication
Subgraph Authentication
Operations Security
Request Limits
Demand Control
Web Security
CORS
CSRF Prevention
Performance and Scaling
Overview
Traffic Shaping
Query Batching
Query Planner Pools
Caching
In-Memory Caching
Distributed Caching
Entity Caching
Router Customization
Router Request Lifecycle
Rhai Scripts
Rust Plugins
Coprocessors
Custom Binaries
GraphOS Integration
Apollo Uplink
Operation Metrics Reporting
Observability
Overview
Router Telemetry
Federated Trace Data
Subgraph Observability
Subgraph Error Inclusion
Opt-in Error Reporting
Debugging Subgraph Requests
Client Observability
Client ID Enforcement
Client Awareness
OpenTelemetry
Set up OTel
Connect OTel to Prometheus
Guides
API Gateway Comparison
Reference
Overview
Changelogs
Glossary
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
Federation Reference
Federation Versions
Federated Directives
Composition Rules
Subgraph Reference
Federation Subgraphs Specification
Subgraph Specific Fields
Compatible Subgraph Libraries
Development and Debugging
IDE Support
Query Plans
Composition Hints
Errors
Federation v1
Router Reference
Self-Hosted Installation
Configuration
GraphOS Router Features
Rhai API
Federation Version Support
Errors
Router Telemetry
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
Migration Guides
From Router v1.x to v2.x
From Router v0.x to v1.x
From @apollo/gateway to Router
From Federation 1 to 2
Federation 2 Backwards Compatibility
From a Monolith
From Schema Stitching
GraphQL Adoption Guides
GraphQL Adoption Patterns
Using GraphQL for Abstraction
GraphQL and REST together
Supergraph Stewardship
Licensing
GraphOS Data Privacy
Sub-Processors
Rover CLI
Overview
Install
Configure
Proxy Configuration
CI/CD
Conventions
Privacy and Data Collection
Contributing
Error Codes
Commands
cloud
config
contract
dev
explain
graph
license
persisted-queries
readme
subgraph
supergraph
template
The Apollo CLI (deprecated)
Installation
Validating Client Operations
Moving to Rover
Apollo Sandbox
Overview
Apollo Client (Web)
Apollo Client (Web) - v2
Introduction
Why Apollo Client?
Get started
Changelog
Fetching
Queries
Suspense
Fragments
Mutations
Refetching
Subscriptions
Directives
Error handling
Document transforms
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
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
Apollo Kotlin
Apollo Kotlin - v4 (latest)
Get Started
Migrating to v4
Modules
Evolution policy
Kdoc
Changelog
Tutorial
0. Introduction
1. Configure your project
2. Add the GraphQL schema
3. Write your first query
4. Execute your first query
5. Connect your queries to your UI
6. Add more info to the list
7. Paginate results
8. Add a details view
9. Write your first mutation
10. Authenticate your operations
11. Write your first subscription
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
VS Code Extension
Overview
Apollo Client (Web)
You are viewing documentation for a previous version of this software.
Switch to the latest stable version.
Home
/
Apollo Client (Web)
/
Development & Testing
Apollo Client (Web)
Using Apollo with TypeScript