✨ New Plugin Alert ✨ SleekRank is now available with €50 launch discount
✨ New Plugin Alert ✨ SleekRank is now available with €50 launch discount
✨ New Plugin Alert ✨ SleekRank is now available with €50 launch discount
✨ New Plugin Alert ✨ SleekRank is now available with €50 launch discount
✨ New Plugin Alert ✨ SleekRank is now available with €50 launch discount
✨ New Plugin Alert ✨ SleekRank is now available with €50 launch discount
✨ New Plugin Alert ✨ SleekRank is now available with €50 launch discount
✨ New Plugin Alert ✨ SleekRank is now available with €50 launch discount
✨ New Plugin Alert ✨ SleekRank is now available with €50 launch discount
✨ New Plugin Alert ✨ SleekRank is now available with €50 launch discount

GraphQL type pages from your schema SDL

Introspect any GraphQL schema, dump it to JSON and SleekRank renders /graphql-type/{slug}/ for every Object, Interface, Enum and InputObject. Fields, arguments and relationships come from the same row, so the docs match the running API.

€50 off for the first 100 lifetime licenses!

SleekRank for GraphQL type pages

Why GraphQL docs need one page per type, not one explorer

GraphQL introspection makes a schema fully self-describing. A medium SaaS often exposes 2,000 to 10,000 distinct types across Object, Interface, Enum, Union and InputObject kinds. Most docs sites collapse all of that into a single explorer with a sidebar tree, which is great for browsing but invisible to search.

SleekRank reads an introspection dump as a JSON array, one row per type. Each row holds slug, name, kind, description, a fields array and an implementedBy array. Save the array to data/graphql-types.json, set the URL pattern to /graphql-type/{slug}/, and the base page renders every type through one Twig template.

The detail page renders the type name, kind badge, description, field table with argument lists, and a related-types section that links to anything the type references. Crawlers see thousands of distinct URLs, each focused on one part of the schema, and developers searching for a specific type land on the right page instead of the explorer root.

Workflow

From GraphQL introspection to indexable type pages

1

Run the introspection query

Fire a standard GraphQL introspection request against your endpoint and capture the full type list. Normalize the result and save it as data/graphql-types.json in the theme.
2

Point SleekRank at the file

Set the data source to data/graphql-types.json, the URL pattern to /graphql-type/{slug}/ and the slug field to slug. SleekRank reports the type count and prepares the catalog.
3

Design one type template

Build a Twig template that renders the type name, kind badge, description, fields table with arguments, and links to related types. Use row fields directly so every type renders consistently.
4

Refresh on schema changes

Add the introspection step to your deploy pipeline. New types appear automatically, deprecated types render a banner, and the catalog tracks the running schema without manual posts.

Data in, pages out

Introspected GraphQL types as JSON

Each type from the schema becomes one row with slug, name, kind and a fields array. SleekRank renders one /graphql-type/{slug}/ page per row.
Data source: GraphQL introspection JSON
slug name kind field_count owner_service
user User OBJECT 32 core
order Order OBJECT 41 commerce
product-variant ProductVariant OBJECT 28 commerce
checkout-line-item CheckoutLineItem OBJECT 17 commerce
order-status-enum OrderStatus ENUM 6 commerce
URL pattern: /graphql-type/{slug}/
Generated pages
  • /graphql-type/user/
  • /graphql-type/order/
  • /graphql-type/product-variant/
  • /graphql-type/checkout-line-item/
  • /graphql-type/order-status-enum/

Comparison

GraphQL explorer vs SleekRank type pages

Single GraphQL explorer

  • Search lands developers on the explorer root with no per-type context
  • Each type lives behind a JavaScript tree, invisible to most crawlers
  • Per-type meta descriptions and titles are impossible from one URL
  • Field changes require manual updates outside the introspection dump
  • Type-to-type links rely on client-side navigation rather than crawlable hrefs
  • Sitemap exposure stays at one URL, regardless of how large the schema grows

SleekRank

  • Introspection JSON drives /graphql-type/{slug}/ for every type
  • Object, Interface, Enum, Union and InputObject share one row schema
  • Field arguments render from typed data, including non-null and list wrappers
  • Related types link automatically via the type reference graph in the JSON
  • Faceted index at /graphql-type/?kind=ENUM and ?owner_service=commerce
  • Re-run introspection on deploy to keep type pages in lockstep with the API

Features

What SleekRank gives you for GraphQL type pages

Schema-to-row pipeline

A small build step runs an introspection query against your GraphQL endpoint, normalizes the result and writes one row per type to data/graphql-types.json. The conversion preserves field arguments, default values and deprecation flags so the docs match the real schema.

Kind and owner facets

Each row carries kind and an owner_service tag. The same data drives an index page that filters by kind and service, so developers can browse all Enum types in the commerce service without leaving the catalog. The faceted URLs are crawlable too.

Crawlable type pages

Every type lives at its own /graphql-type/{slug}/ URL with a unique title, meta description and JSON-LD block. Long-tail queries like "graphql ProductVariant fields" land directly on the right page instead of bouncing through an explorer.

Use cases

Where per-type GraphQL pages move the needle

Public API docs

Public GraphQL APIs use SleekRank to render a reference page per type, which ranks for long-tail queries and reduces support questions about field shape and required arguments.

Internal schema portals

Platform teams expose their internal schema as searchable docs, with owner_service tags so consumers can find the types behind each squad without learning the explorer.

Migration assistance

During schema migrations, deprecated types stay live with a banner pointing at their replacement. The data file flag controls the banner, so cutover happens by editing one field.

The bigger picture

Why GraphQL type pages outperform a single explorer

GraphQL APIs ship with a self-describing schema, but most docs sites stop short of turning that schema into crawlable pages. Developers searching for a specific type get bounced to the explorer root and have to drill in by hand, which is painful for them and invisible to search. SleekRank takes the introspection output and turns it into a real catalog with one URL per type.

Every Object, Interface, Enum and InputObject gets a focused title and meta description, with fields and arguments rendered from typed data instead of free text. Because the JSON is the source of truth, schema migrations are reflected on the next deploy without anyone editing pages by hand. Deprecations turn into banners, new types turn into new URLs, and related-type links keep the graph fully crawlable.

The end result is a reference site that grows with the API instead of lagging behind it, and that ranks for long-tail queries developers actually type.

Questions

Common questions about SleekRank for GraphQL type pages

A small script runs the standard introspection query, normalizes the type list, and emits one row per type with slug, name, kind, description and a fields array. The fields array preserves arguments, type references and non-null wrappers. The resulting array is written to data/graphql-types.json for SleekRank to read on render.

 

Yes. SleekRank parses the JSON once and caches a slug-to-row map. Individual page render is an O(1) lookup, and WordPress full-page cache absorbs repeat traffic. A schema with ten thousand types is well within range, with no meaningful per-page slowdown.

 

Each field row carries an args array of argument objects with name, type and default value. The template renders them in a parameter table with the same conventions as GraphQL SDL, including non-null exclamation marks and list brackets. Because the data is structured, the rendering stays consistent across thousands of types.

 

Re-run introspection on deploy, overwrite the JSON, then sync SleekRank. Each type page picks up the new fields and arguments on the next request. Deprecated fields can be tagged with a deprecation reason that the template renders as a banner above the field row.

 

Yes. The /graphql-type/ index reads the array and groups by kind, with optional filters by owner_service. Both the index and the detail pages render from the same rows, so type counts, kinds and descriptions never disagree between list and detail views.

 

Union rows carry a memberTypes array with slugs of each constituent type. Interface rows carry an implementedBy array. The template renders both as link lists pointing at /graphql-type/{slug}/, so the type relationship graph is fully crawlable instead of being hidden behind JavaScript.

 

Yes. Many teams keep the explorer for interactive queries and add SleekRank pages for the static, indexable reference. Both can read from the same introspection JSON or the same upstream schema, so they stay aligned without duplicate maintenance.

 

InputObject types render the same way as Object types with a different kind badge. Query, Mutation and Subscription roots become first-class rows too, with their top-level fields and arguments rendered exactly as the schema declares them.

 

Pricing

More than 1000+
happy customers

Explore our flexible licensing options tailored to your needs. Upgrade your license anytime to access more features, or opt for a lifetime license for ongoing value, including lifetime updates and lifetime support. Our hassle-free upgrade process ensures that our platform can grow with you, starting from whichever plan you choose.

Starter

€99

EUR

per year

Get started

further 30% launch-discount applied during checkout for existing customers.

  • 3 websites
  • 1 year of updates
  • 1 year of support

Pro

€179

EUR

per year

Get started

further 30% launch-discount applied during checkout for existing customers.

  • Unlimited websites
  • 1 year of updates
  • 1 year of support

Lifetime ♾️

Launch Offer

€299

€249

EUR

once

Get started

further 30% launch-discount applied during checkout for existing customers.

  • Unlimited websites
  • Lifetime updates
  • Lifetime support

...or get the Bundle Deal
and save €250 🎁

The Bundle (unlimited sites)

Pay once, own it forever

Elevate your WordPress site with our exclusive plugin bundle that includes all of our premium plugins in one package. Enjoy lifetime updates and lifetime support. Save significantly compared to buying plugins individually.

What’s included

  • SleekAI

  • SleekByte

  • SleekMotion

  • SleekPixel

  • SleekRank

  • SleekView