What is the difference between the Router Schema and the Client Schema?

The Router Schema is used internally for query planning and includes @inaccessible fields needed for federation resolution. The Client Schema is the schema exposed via introspection to API consumers. Both are accessible in the Schema Registry.

When does the registry update?

The registry updates when a composition succeeds. When a subgraph is published and composition completes successfully, the new schema becomes the active version in the registry. Failed compositions do not update the registry.

Can I view individual subgraph schemas, not just the federated schema?

Yes. A subgraph dropdown in the Schema Registry lets you switch between the composed federated graph schema and any individual subgraph schema.

How do I get the schema into my code generation tool?

Download the schema as a `.graphql` file directly from the Schema Registry in Studio, then point your code generation tooling at that file.

Does the Schema Registry work with a self-hosted Cosmo deployment?

Yes. The Schema Registry is part of Studio and works identically with self-hosted Cosmo and Cosmo Cloud.

What permissions do I need to access the Schema Registry?

You need Studio access and appropriate namespace permissions. The specific permission requirements depend on your organization's namespace configuration.

GraphQL Schema Registry | Cosmo by WunderGraph

The problem

Why finding the right schema is harder than it should be

In a distributed GraphQL architecture, schemas are scattered across multiple repositories and services. Getting an accurate view of the current production schema takes more effort than it should.

Schemas are scattered across repositories and services

In a distributed GraphQL architecture, schemas are scattered across repositories and services. There is no single place to see the complete API surface. Developers can end up working with outdated schemas or missing type definitions.

No authoritative view of the federated graph

The composed federated graph schema is hard to find without a central registry. Developers looking for type definitions across subgraphs have to piece information together from multiple sources, with no guarantee they are looking at the current production schema.

Local development can drift from production

Code generation and documentation tools need an accurate schema file. Without a central registry, teams rely on manually managed schema files that can drift from the current production schema.

Our solution

One source of truth for every GraphQL schema

The Schema Registry keeps your composed federated graph schema and individual subgraph schemas in Studio. Developers can view the current schema, copy it, or download it for use with development tools.

What the registry gives you

The registry displays the most recent successfully composed schema for your federated graph.
Both the Router Schema, used for query planning and including @inaccessible fields, and the Client Schema, exposed via introspection, are accessible.
A subgraph dropdown lets you view any individual subgraph schema from the same interface.
Copy schemas to the clipboard or download them as `.graphql` files for code generation and documentation tools.
Last-updated timestamps show when schemas changed.

One place. Always current. Easy to export.

Schema registry

Before & After

Before Cosmo	With Cosmo
Schemas scattered across repositories	Single source of truth in Studio
Unclear which schema version is active	Current production schema always visible
Manual schema file management	One-click copy or download
No easy visibility into subgraph schemas	View any subgraph schema in Studio

What's in the registry

Every schema view you need

Router Schema — used for query planning; includes @inaccessible fields needed for federation resolution.
Client Schema — the schema exposed via introspection.
Subgraph schemas — each individual subgraph schema, accessible via dropdown.
Last-updated timestamps — every schema view shows when it last changed.

Key benefits

Always know what your graph looks like

Every benefit below is available on the Free tier.

One place for the federated schema and every subgraph schema

The registry gives you the composed federated graph schema and each individual subgraph schema in Studio. No need to check multiple repositories or services to find the current schema.

Always reflects the latest successful composition

The registry updates when composition succeeds. What you see is the latest successfully composed schema, not a stale local copy or manually maintained file.

Copy or download in one click

Copy the schema to your clipboard or download it as a `.graphql` file. Use it with code generation tools or documentation generators.

View any subgraph schema without leaving Studio

A dropdown selector lets you view any individual subgraph schema. Use it to understand how types and fields are defined across services.

Timestamps show when the schema last changed

Each schema view includes a last-updated timestamp, so developers can see when the schema changed and whether they are looking at the current version.

How to use the Schema Registry

01

Always the latest composition.

Open Schema Registry in Studio

Open the Schema Registry in Studio. The registry displays the most recent successfully composed schema for your federated graph in SDL format.

02

Every subgraph in one place.

Switch between schema views

Use the subgraph dropdown to view any individual subgraph schema. The registry also provides access to both the Router Schema and the Client Schema.

03

One click, production-accurate.

Copy to clipboard

Copy the schema directly to your clipboard for use in development tools or documentation. The copied schema reflects the latest successfully composed version in the registry.

04

Ready for code generation.

Download as a .graphql file

Download the schema as a `.graphql` file for code generation tools or API documentation generators like GraphQL Voyager and SpectaQL.

05

Know when it last changed.

Check the last-updated timestamp

Each schema view shows a last updated timestamp. Use it to see when the schema changed and confirm you are working from the current version.

Use cases

When developers reach for the registry

Development environment setup

Code generation

A new developer needs the current production schema for code generation. They open Studio, navigate to the Schema Registry, and download the federated graph schema as a `.graphql` file. Their local development environment matches production exactly with minimal setup time.

Debugging type definitions

Debugging

A frontend developer needs to understand how a type is defined and which subgraph owns it. They view the federated schema for the complete type definition, then use the subgraph dropdown to check each relevant subgraph's contribution to that type.

API documentation

Documentation

A technical writer needs to document the current API for external consumers. They open the Schema Registry, copy the complete federated schema, and use it as the source for API documentation tools. The documentation is generated from the authoritative schema source, not a manually maintained copy.

When to use the Schema Registry

When to use

You need the current production schema for code generation or documentation tools.
You want to understand how a type is defined across subgraphs.
You need to verify when the schema last changed.

Requirement

The federated graph needs at least one successful composition. The registry displays the latest successfully composed schema, so there is no current schema to show until composition succeeds.

Always-current schemas for your whole team

Free tier. No credit card. Schema Registry included from day one.

Start Free See the docs

Ready to go deeper?

Full reference for the Schema Registry interface and the Schema Explorer for interactive graph navigation.

Schema Registry docs →Schema Explorer docs →

The current production schema, always in one place