Skip to main content

Best GraphQL Federation Platforms 2026

·APIScout Team
graphql federationapollo federationthe guild hivewundergraphcosmographql gatewaysupergraphgraphql api

Why GraphQL Federation Exists

A single GraphQL schema for a large application becomes a maintenance burden: every team's data types and mutations live in one massive schema, every API change requires coordinating across teams, and the single GraphQL server becomes a deployment bottleneck.

GraphQL Federation solves this by composing multiple independent GraphQL subgraph schemas into a single unified supergraph — one API surface, multiple independent services. The users team owns the User type; the products team owns Product; the orders team owns Order. The federation gateway stitches them together automatically.

In 2026, four platforms provide GraphQL federation infrastructure: Apollo Federation (the standard that defined the spec), The Guild's Hive (open-source, MIT-licensed, with strong spec compliance), WunderGraph (visual schema design + managed federation), and Cosmo (open-source router by WunderGraph, composable and fast).

TL;DR

Apollo Federation is the most widely adopted — defined the federation specification that others now implement, largest ecosystem, GraphOS managed service at $99/month. The Guild's Hive is the best open-source alternative — MIT-licensed, Apollo Federation compliant, self-hostable with free cloud tier, and the most active community outside Apollo. WunderGraph provides a visual collaborative schema design experience on top of federation. Cosmo is WunderGraph's high-performance open-source router — a strong self-hosted alternative to Apollo Router.

Key Takeaways

  • Apollo GraphOS starts at $99/month for the Serverless tier (pay-per-operation), with Team plan at $1,700/month. Apollo Router is open-source (Elastic License).
  • GraphQL Hive is MIT-licensed — free to self-host, free cloud tier available, and scores 100% on the Federation audit specification.
  • WunderGraph Cosmo is an open-source (Apache 2.0) federation router with a commercial managed service.
  • Apollo Federation 2 introduced entity interface support, @override directive, and @interfaceObject — significant improvements over Federation 1.
  • Open Federation spec (maintained by The Guild) aims to standardize federation across implementations so routers and subgraphs from different vendors can interoperate.
  • Performance benchmarks (September 2025): Apollo Router and WunderGraph perform similarly at ~900ms average, ~2500ms p95 under load; Hive Gateway is competitive.
  • Self-hosting the router is common — Apollo Router (OSS), Cosmo, and Hive Gateway are all self-hostable, with managed options for the control plane (schema registry, observability).

Pricing Comparison

PlatformFree TierPaid StartingLicense
Apollo GraphOSNo$99/month (Serverless)Router: Elastic
The Guild HiveYes (cloud + self-host)Custom (Enterprise)MIT
WunderGraph CosmoYes (cloud free)Contact salesApache 2.0
Grafbase GatewayYes (self-host)Contact salesOpen-source

Apollo Federation

Best for: Enterprise teams, broadest ecosystem, most mature spec implementation, Apollo Studio analytics

Apollo Federation defined the GraphQL Federation specification — the @key, @extends, @requires, and @external directives that allow subgraphs to share and extend types across services. Apollo Federation 2 (2022+) improved entity resolution, added @interfaceObject, and introduced the @override directive for gradual migration between subgraphs.

Pricing

PlanCostOperations/Month
Serverless$99/month$0.20/million ops
Team$1,700/monthUnlimited
EnterpriseCustomUnlimited + SLAs

Apollo Router (the runtime) is available under the Elastic License — free for internal and non-commercial use, commercial use requires a license.

Subgraph Implementation

// products-subgraph/src/schema.ts
import { buildSubgraphSchema } from "@apollo/subgraph";
import { gql } from "graphql-tag";
import { resolvers } from "./resolvers";

const typeDefs = gql`
  extend schema
    @link(url: "https://specs.apollo.dev/federation/v2.3", import: ["@key", "@external", "@requires", "@provides"])

  type Query {
    product(id: ID!): Product
    products(limit: Int = 20): [Product!]!
  }

  type Product @key(fields: "id") {
    id: ID!
    name: String!
    price: Float!
    description: String
    category: Category!
  }

  type Category {
    id: ID!
    name: String!
    slug: String!
  }
`;

export const schema = buildSubgraphSchema({ typeDefs, resolvers });

// orders-subgraph — extends Product from products-subgraph
const typeDefs = gql`
  extend schema
    @link(url: "https://specs.apollo.dev/federation/v2.3", import: ["@key", "@external"])

  type Order @key(fields: "id") {
    id: ID!
    product: Product!  # Reference to product in products-subgraph
    quantity: Int!
    total: Float!
    status: OrderStatus!
  }

  # Extend the Product type to add order-related data
  type Product @key(fields: "id") {
    id: ID! @external
    orderCount: Int!     # Only orders-subgraph resolves this
  }

  enum OrderStatus {
    PENDING
    PROCESSING
    SHIPPED
    DELIVERED
  }
`;

const resolvers = {
  Product: {
    // This subgraph handles orderCount for Product entities
    __resolveReference: async (reference) => ({
      id: reference.id,
      orderCount: await db.orders.countByProduct(reference.id),
    }),
  },
};

Supergraph Composition

# Rover CLI — compose subgraphs into supergraph
npm install -g @apollo/rover

# rover.yaml
federation_version: =2.3.2
subgraphs:
  products:
    routing_url: https://products-api.example.com/graphql
    schema:
      subgraph_url: https://products-api.example.com/graphql
  orders:
    routing_url: https://orders-api.example.com/graphql
    schema:
      subgraph_url: https://orders-api.example.com/graphql
  users:
    routing_url: https://users-api.example.com/graphql
    schema:
      subgraph_url: https://users-api.example.com/graphql

# Compose supergraph schema
rover supergraph compose --config rover.yaml > supergraph.graphql

# Start Apollo Router with composed supergraph
./router --config router.yaml --supergraph supergraph.graphql

When to Choose Apollo Federation

Organizations with existing Apollo Federation subgraphs, teams that need the most mature and feature-complete federation implementation, or enterprises that want GraphOS managed cloud services (schema registry, metrics, Studio analytics dashboard).

The Guild Hive

Best for: Open-source, MIT license, Apollo Federation compliant, self-hostable, cost-conscious teams

GraphQL Hive is the open-source alternative to Apollo GraphOS — a complete GraphQL management platform with schema registry, versioning, analytics, and the Hive Gateway (federation router). The MIT license means you can self-host without licensing restrictions, and the cloud tier includes a free plan.

Pricing

PlanCostFeatures
Hobby (cloud)Free1M operations/month
Pro (cloud)Contact salesUnlimited + SLA
Self-hostedFreeFull features, your infra
EnterpriseCustomManaged + support

Schema Registry

# Hive CLI — publish subgraph schema
npm install -g @graphql-hive/cli

# Publish from CI/CD
hive schema:publish \
  --token $HIVE_TOKEN \
  --service products \
  --url https://products-api.example.com/graphql \
  products-schema.graphql

# Check before publishing (prevents breaking changes)
hive schema:check \
  --token $HIVE_TOKEN \
  --service orders \
  orders-schema.graphql

Hive Gateway Configuration

# gateway.config.yaml — Hive Gateway
sources:
  - name: products
    type: graphql
    endpoint: https://products-api.example.com/graphql
    timeout: 10000

  - name: orders
    type: graphql
    endpoint: https://orders-api.example.com/graphql
    timeout: 10000

  - name: users
    type: graphql
    endpoint: https://users-api.example.com/graphql
    timeout: 10000

cache:
  max: 1000

logging:
  level: info

Self-Hosting with Docker

# docker-compose.yml — Hive self-hosted
version: "3.8"

services:
  hive-app:
    image: ghcr.io/kamilkisiela/graphql-hive/app:latest
    environment:
      - DATABASE_URL=postgresql://hive:password@postgres:5432/hive
      - REDIS_URL=redis://redis:6379

  hive-gateway:
    image: ghcr.io/kamilkisiela/graphql-hive/gateway:latest
    ports:
      - "4000:4000"
    environment:
      - HIVE_TOKEN=your-token
      - HIVE_APP_URL=http://hive-app:3000

When to Choose The Guild Hive

Teams that want Apollo Federation compliance without Apollo's licensing restrictions, organizations that need to self-host the full platform (schema registry + gateway) for compliance or cost reasons, or teams that are cost-sensitive — Hive's MIT license and free tiers provide significant savings over Apollo GraphOS at scale.

WunderGraph Cosmo

Best for: High-performance router, open-source Apache 2.0, visual schema design, modern stack

WunderGraph Cosmo is the federation router and platform from WunderGraph — an Apache 2.0 licensed alternative to Apollo Router with competitive performance benchmarks. The Cosmo platform includes a visual schema design studio (collaborative canvas), schema registry, and analytics. The router itself is open-source.

Cosmo Router Performance

Based on September 2025 benchmarks by Grafbase:

  • Average response time: ~900ms (comparable to Apollo Router)
  • p95: ~2,500ms under load
  • Throughput: Competitive with Apollo Router

Cosmo CLI Setup

# Install WunderGraph CLI
npm install -g wgc

# Initialize a new federated graph
wgc init my-supergraph

# Publish subgraph schema to Cosmo
wgc subgraph publish products \
  --namespace production \
  --schema products.graphql \
  --routing-url https://products-api.example.com/graphql

# Compose and deploy the supergraph
wgc graph deploy my-supergraph

Router Configuration

# cosmo-router.yaml — Cosmo Router configuration
graph:
  token: "${COSMO_GRAPH_TOKEN}"

engine:
  enable_single_flight: true
  execution_plan_cache_size: 10240

traffic_shaping:
  all:
    request_timeout: 60s

rate_limit:
  enabled: true
  strategy: simple_sliding_window
  rate: 1000
  burst: 2000
  period: 1s

telemetry:
  service_name: cosmo-router
  tracing:
    enabled: true

When to Choose Cosmo

Teams that want an open-source (Apache 2.0) federation router with commercial support available, organizations evaluating Apollo alternatives due to licensing or pricing, or teams that want WunderGraph's visual schema design studio for collaborative API development.

Federation Concepts Reference

# Key federation directives (Apollo Federation 2 compatible)

# @key — marks primary key for an entity
type User @key(fields: "id") {
  id: ID!
  email: String!
}

# @external — field defined in another subgraph
type Product @key(fields: "id") {
  id: ID! @external
  # name comes from products-subgraph, not this one
  name: String! @external
  # This subgraph adds inventory data
  stockCount: Int!
}

# @requires — this field needs other fields from entity
type Product @key(fields: "id") {
  id: ID! @external
  weight: Float! @external
  shippingCost: Float! @requires(fields: "weight")
  # Resolver receives weight from products-subgraph
}

# @override — migrate field ownership between subgraphs
type Order @key(fields: "id") {
  id: ID!
  # Gradually migrate 'status' field from old-service to new-service
  status: OrderStatus! @override(from: "old-orders-service")
}

Decision Framework

ScenarioRecommended
Enterprise, GraphOS analyticsApollo GraphOS
Open-source, self-hostedThe Guild Hive
MIT license requiredThe Guild Hive
High-performance OSS routerCosmo (Apache 2.0)
Visual schema designWunderGraph
Apollo Federation complianceHive or Apollo
Cost-sensitiveHive (free self-host)
New project, Apollo ecosystemApollo GraphOS

Verdict

Apollo Federation remains the ecosystem standard — the widest adoption, most tooling, and the specification that all other implementations target. Apollo GraphOS at $99-$1,700/month is the trade-off for managed schema registry and analytics.

The Guild Hive is the most compelling alternative — MIT licensed, Apollo Federation 2 compliant, free to self-host, and actively developed by the team behind some of the most-used GraphQL tooling (graphql-code-generator, graphql-yoga, envelop). For cost-conscious teams, the savings over Apollo GraphOS are significant.

Cosmo is the performance-focused open-source router — if you want an Apache 2.0 licensed router with benchmark performance comparable to Apollo Router, Cosmo is the answer.

Compare GraphQL federation platform pricing, spec compliance, and schema registry features at APIScout — find the right federation infrastructure for your GraphQL supergraph.

Comments