# GraphQL Schema Check and Breaking Changes

Paste a GraphQL SDL schema (schema.graphql) to list its types, fields and arguments, with issues such as undefined types by line number. Paste an old and a new schema to see breaking change candidates, such as removed fields or newly required arguments, apart from safe changes. Nothing leaves your browser.

- URL: https://tools.itlibra.com/en/graphql-schema-studio
- On-device・No upload
- Last updated: 2026-10-31

## How to use

1. Paste the old SDL in “Before (old schema)” and the new one in “After (new schema)”, or open a schema.graphql file with “Open file”. “Try a sample” also works.
2. To check a single schema, press “Check schema” (it reads the left pane). To compare two, press “Compare” (or Ctrl / ⌘ + Enter).
3. The check shows the list of types, the tree of types reachable from the roots, and issues with line numbers. The comparison shows the breaking change candidates and the safe changes.
4. Use “Copy Markdown” to paste a table into a pull request description, or “Save JSON” to keep the verdict, counts and changes.

## Use cases

- Check whether a schema.graphql change in a pull request breaks existing clients
- Find undefined types and duplicate names by line before running the code
- List the types reachable from Query and Mutation to get an overview of a schema
- Compare internal GraphQL schemas without sending them outside

## What it does

### Type list and tree from the roots

Reads type, interface, union, enum, input, scalar, schema and extend, and shows the types reachable from Query, Mutation and Subscription as a tree.

### Issues by line number

Shows undefined types, duplicate names, missing interface fields, empty enums and output types used in input, each with its line number.

### Breaking change candidates

Removed fields and types, newly required arguments, nullable-to-non-null changes and removed enum values are shown as candidates, apart from safe changes such as additions.

### A reason on every row

Each row says which rule put it in its group. The rules are listed on the page, so the basis can be used in a review.

### Runs only in your browser

The SDL is not sent anywhere and is analysed inside your browser. The tool never fetches a schema from a URL.


## Supported formats

### Input

- SDL (the schema.graphql form)
- .graphql / .gql / .txt
- UTF-8 (with or without BOM)

### Output

- On-screen lists (types, issues, changes)
- Markdown (table for a pull request)
- JSON (verdict, counts and changes)


## Capability matrix

| Feature | Support | Notes |
| --- | --- | --- |
| Reading SDL: type, interface, union, enum, input, scalar, schema and extend | Supported | — |
| Fields, arguments, types (with ! and \[ \]), descriptions ("..." and """...""") and @deprecated | Supported | — |
| Tree of types reachable from Query, Mutation and Subscription | Supported | — |
| Issues: undefined types, duplicate names, missing interface fields, empty enums, output types in input | Supported | Not every rule in the specification is checked. These are the issues this tool reads |
| Comparing two schemas, sorting breaking change candidates and safe changes | Supported | These are candidates. Your API policy and actual usage are unknown, so general rules are used |
| Syntax that cannot be read | Partial | The line is shown by number and its definition is skipped. The result uses only the parts that could be read |
| Comparing directive definitions | Not supported | Not compared |
| Converting an introspection result (JSON) to SDL | Not supported | Not supported. Paste the SDL instead |
| Running or validating queries, connecting to a server | Not supported | No network access |
| Importing or fetching other files or URLs | Not supported | Not fetched. Shown as an unresolved reference |
| Settings that change the rules | Not supported | The rules can be read on the page, but no setting changes the groups |
| Offline use | Supported | Works without a connection once the page has loaded |

## Limits & notes

- Up to 300,000 characters per SDL. Files up to 1 MB.
- The type tree goes to depth 12 and up to 2,000 entries. The rest is shown as omitted.
- The issue and change lists count every item, then show them on the screen.
- The verdict follows general rules. Each API may have its own policy.

## Privacy & safety

SDL is analysed only inside your browser. Nothing is sent or stored, and closing the page discards it. Analytics only record that a run happened, with no content or counts.

## FAQ

### What is a breaking change in GraphQL?

A change after which existing clients stop working as before. Removing a field or type, making an argument required (nullable to non-null) and changing an output field from non-null to nullable are examples. This tool shows candidates by the GraphQL specification’s rules.

### Can I paste an introspection result (JSON)?

Not yet. The tool reads SDL (the schema.graphql form). It does not convert introspection JSON to SDL and does not connect to a server.

### Can it fully validate a schema?

No. It is a light check for undefined types, duplicate names and missing interface fields. It does not run every rule of the specification, so use a GraphQL tool for a final check as well.

### How is this different from the OpenAPI diff tool?

For a REST API definition, use the OpenAPI diff tool. This tool compares GraphQL type definitions (SDL). OpenAPI describes HTTP operations, while GraphQL describes types.

### Where do I get the SDL?

Paste the SDL that your server library prints, or the schema.graphql in your repository. “Open file” also reads it.