GraphQL Compare — Compare GraphQL Files Online Free
Your schema is a public promise — compare GraphQL SDL files and catch breaking changes before clients do. Removed fields and non-nullable args made unmissable. Free, no signup.
How to Compare GraphQL Files Online
Comparing two GraphQL files with GraphQL Compare takes under a minute:
- Load the original .graphql file into the left panel.
- Then add the updated .graphql file on the right side.
- Run Compare and review additions in green, deletions in red.
Tip: scan for removed fields and newly non-nullable arguments first — those are the breaking changes clients feel immediately. Works in every current browser — Chrome, Firefox, Edge, or Safari — on any desktop or mobile system, with no limit on comparisons. Free side-by-side comparison is the default, no account required; Premium unlocks the line-by-line analytical view.
Understanding the GraphQL File Format
GraphQL (.graphql) files contain schema definitions (SDL) and operations for GraphQL APIs — the type system that clients depend on. Because clients query against the schema's exact shape, schema evolution is governed by one question above all: is this change breaking? Comparing schema versions is how teams answer it before clients find out the hard way. Schema-first development makes the SDL the source of truth, so GraphQL schema comparison is effectively API governance — the diff is where deprecations, additions, and breaking edits become explicit decisions.
Common Uses of GraphQL Files
The everyday scenarios it was built for:
- API teams diff the schema against the last published version as a release gate.
- Mobile teams check upcoming schema changes before the backend deploys.
- Reviewers audit type changes in federation subgraphs.
- Developers compare generated schemas between codegen versions.
- Platform teams document deprecations between API versions.
- Integrators verify a partner's schema update against their queries.
Diffing the schema against the last published version is the release-gate check that keeps mobile clients from discovering breaking changes in production.
Differences Detected in GraphQL Files
The tool provides schema-aware highlighting: GraphQL type diff for added, removed, and modified types; mutation comparison covering changed arguments and return types; query field changes including nullability shifts (String → String! is breaking for inputs); directive diff; and GraphQL deprecation comparison tracking @deprecated additions and removals.
Examples of Changes Found in GraphQL Files
Schema edits the type-level diff typically surfaces:
- A field 'email: String' changed to 'email: String!' — non-breaking for outputs but breaking for inputs; the nullability shift is flagged for classification.
- A mutation createOrder whose input gained a required field 'currency: CurrencyCode!' — a breaking change caught pre-deploy.
- A type where 'legacyId: ID @deprecated(reason: "Use id")' was finally removed after the deprecation window.
- An enum OrderStatus that gained a SUSPENDED value, requiring client handling review.
- A schema where email: String became email: String! on an input type — newly required, instantly breaking every client that omitted it.
Why Use FileDiffs for GraphQL Comparison
A GraphQL schema is a public promise to every client, and a removed field or a newly required argument breaks them the moment it deploys. FileDiffs compares SDL files in the browser, making breaking changes unmissable before clients discover them. It's built as an API release gate rather than a generic differ, with examples like an input field changing from String to String! and instantly breaking every client that omitted it, the kind of edit you want to catch in review, not in production logs.
Frequently Asked Questions About Compare GraphQL Files Online
Upload or paste both SDL files and the tool highlights every changed type, field, argument, and directive — the raw material for breaking-change analysis. Read removed-field and non-nullable-argument highlights first — those are the breaking changes clients feel immediately.
Diff the new schema against the current one and review highlights against breaking-change rules: removed fields, added required arguments, changed types, and tightened nullability are the classic breakers. A field removed from the SDL fails every client query that selects it, the moment the new schema deploys.
Compare the schema files directly; type-level and field-level highlights show exactly how the contract evolved between versions. Diff the working schema against the last published version as a release gate before every deploy.
Export the SDL from each version (introspection or schema files) and diff them — the report is your API changelog for client teams. Deprecation highlights tell consumers what to migrate away from before the removal actually lands.
The diff flags @deprecated directives as they're added or removed, letting you track deprecation rollout and confirm fields aren't deleted before their sunset date. Track @deprecated additions across versions — they're the official early warning of coming breakage.
Yes. Your SDL files are compared in the browser with nothing sent to a server, so internal API schemas stay confidential. No upload, no storage — the comparison is entirely on your device.