GraphQL to JSON Converter Online — Schema to JSON

Paste GraphQL Schema Definition Language and emit a structured JSON description of types, fields, scalars, enums, and unions — 100% in your browser.

Input GraphQL SDL

JSON Output

What is a GraphQL to JSON converter?

A GraphQL to JSON converter reads GraphQL Schema Definition Language (SDL) and emits a structured JSON document that describes every type, input, interface, enum, union, and scalar. It captures field names, target types, and the non-null / list wrappers — everything a code generator, schema differ, or documentation builder needs to walk the schema programmatically.

SDL is the human-friendly representation of a GraphQL schema, but most automation works on JSON. Whether you're feeding the schema into a TypeScript generator, comparing two schema versions, or building static documentation, having a JSON view that you can query with jq or load with JSON.parse is dramatically more convenient than re-parsing SDL each time.

How to convert GraphQL to JSON — 4 steps

Paste SDL. Copy your schema.graphql contents into the input — one or many type blocks.
Click Convert. The parser walks every block and extracts fields, list wrappers, and non-null markers.
Read the JSON. The result is a top-level types array, with one entry per definition.
Pipe into your tooling. Save the JSON and feed it to codegen, schema diff, or doc-build steps.

Sample input and output

# Input SDL
type User {
  id: ID!
  posts: [Post!]!
}

enum Role { ADMIN VIEWER }

// Output JSON
{
  "types": [
    {
      "kind": "type",
      "name": "User",
      "fields": [
        { "name": "id",    "type": "ID",   "nonNull": true,  "isList": false, "listItemNonNull": false },
        { "name": "posts", "type": "Post", "nonNull": true,  "isList": true,  "listItemNonNull": true }
      ]
    },
    { "kind": "enum", "name": "Role", "values": ["ADMIN", "VIEWER"] }
  ]
}

Faithful Type Wrappers

Captures isList, listItemNonNull, and nonNull as separate booleans so [User!]! survives the round-trip without ambiguity.

All Definition Kinds

Handles type, input, interface, enum, union, and scalar — the building blocks every schema is made of.

Privacy First

Schemas often leak product surface area — internal field names, deprecated APIs. The parser runs in JavaScript on your machine.

Common use cases

check_circleFeeding a schema into TypeScript / Flow / Kotlin code generators that prefer JSON
check_circleDiffing two schema versions to detect breaking changes in CI
check_circleBuilding static GraphQL documentation from a JSON description
check_circleGenerating mock fixtures by walking the JSON type list
check_circlePowering custom GraphQL linters that operate on a structural representation
check_circleAuditing schemas for deprecated fields, missing nullability, or naming consistency
check_circlePre-processing schemas before pushing them to a federated gateway
check_circleTeaching newcomers how SDL maps to a structural type model

SDL JSON vs introspection JSON

GraphQL servers expose an introspection JSON via the __schema query — a deeply nested document with kind enums, ofType chains, and full argument metadata. It's exhaustive but verbose. The JSON this tool produces is a flatter, simpler view designed for human inspection and quick programmatic walks. Use this when you want to jq the schema or feed it to a small codegen; use server introspection when you need every last detail including args and default values.

Round-trip and explore

Generate schemas from JSON, format SDL, or work with the JSON output downstream.

JSON to GraphQL GraphQL Formatter JSON Formatter

Frequently Asked Questions

Why convert GraphQL to JSON?

Tooling, code generators, and custom build steps almost always work with JSON, not SDL. Converting a schema into JSON makes it easy to feed into TypeScript generators, schema diffing tools, documentation builders, and ad-hoc scripts that need a structured, programmatic view of the types.

What is the JSON shape produced?

The output is a top-level "types" array. Each entry has a "kind" (type / input / interface / enum / union / scalar) and a "name". Object-like kinds also have a "fields" array with name, type, nonNull, isList, and listItemNonNull flags. Enums have a "values" array; unions have a "types" array of member names.

Does it support full GraphQL introspection format?

No — this is a lightweight SDL-to-JSON view, not the full introspection schema returned by __schema queries. The introspection format is much more verbose (kind enums, ofType chains, args, default values). For introspection JSON, use a GraphQL server with the introspection query enabled.

Are field arguments preserved?

Field argument lists are stripped from the field signature so the type information stays clean. If you need argument metadata, run a real GraphQL parser like graphql-js — but for type-only diffing, codegen, and documentation, the simpler JSON is usually what you want.

Does it handle directives and descriptions?

Comments (#) are stripped before parsing. Triple-quoted descriptions on the same line as a field are detected and skipped, but the converter does not preserve them in the output. The focus is on the structural shape of the schema, not its documentation.

How are list and non-null wrappers represented?

Each field carries three booleans: nonNull (the outer ! after the closing bracket), isList (whether the type is wrapped in [ ]), and listItemNonNull (the inner ! before the closing bracket). [User!]! becomes type=User, isList=true, listItemNonNull=true, nonNull=true.

Is my schema sent to your servers?

No. The parser runs in your browser. Open DevTools and check the Network tab when you click Convert — no requests are made. Schemas containing internal type names, deprecated fields, or sensitive entity definitions never leave the device.

Can I round-trip from JSON back to SDL?

The JSON output preserves enough information to regenerate equivalent SDL by hand or with a small script (kind + name + fields with wrappers). However, descriptions, directives, and field arguments are not round-trippable through this tool.