shopify.dev APIshopify.dev ↗
Access the full Shopify GraphQL Admin API schema: types, fields, mutations, queries, enums, and more across all categories via 3 structured endpoints.
curl -X GET 'https://api.parse.bot/scraper/34fe858c-da35-4567-8de3-5ca4da20fb89/get_api_navigation?version=2026-01&category=orders&type_kind=unions' \ -H 'X-API-Key: $PARSE_API_KEY'
Get the full navigation tree of the Shopify GraphQL Admin API. Returns all categories, type groups, and individual types with their names and URL paths. Supports filtering by category and/or type kind. Note: not all type kinds exist in every category (e.g. unions are only in the 'GraphQL Types' category, not in 'orders').
| Param | Type | Description |
|---|---|---|
| version | string | API version (e.g., '2026-01', '2025-10') |
| category | string | Filter by category name (e.g., 'access', 'orders', 'products and collections'). Omitting returns all categories. |
| type_kind | string | Filter by type kind: mutations, objects, queries, connections, enums, input-objects, interfaces, payloads, scalars, unions. Omitting returns all type kinds. |
{
"type": "object",
"fields": {
"items": "array of type entries with name, href, and metadata",
"total": "integer, count of filtered items (present when type_kind is specified)",
"version": "string, the API version queried",
"category": "string, the category filter applied or 'all'",
"type_kind": "string, the type kind filter (present when type_kind is specified)",
"categories": "array of category names (present when no type_kind filter)",
"total_types": "integer, total number of types (present when no type_kind filter)",
"type_counts": "object mapping type kind to count (present when no type_kind filter)"
},
"sample": {
"data": {
"items": [
{
"href": "/docs/api/admin-graphql/2026-01/queries/draftOrder",
"name": "draftOrder",
"category": "Orders",
"type_kind": "queries"
}
],
"version": "2026-01",
"category": "orders",
"categories": [
"Orders"
],
"total_types": 275,
"type_counts": {
"objects": 155,
"queries": 30,
"mutations": 90
}
},
"status": "success"
}
}About the shopify.dev API
This API exposes the complete Shopify GraphQL Admin API schema documentation across 3 endpoints, covering types, fields, arguments, mutations, queries, enums, connections, and interfaces from categories including Access, Orders, Products, B2B, and Billing. The get_type_detail endpoint returns full field signatures, argument lists, return types, and code examples for any named type, while get_api_navigation provides a browsable tree of every type across all schema categories.
What the API covers
The API surfaces the complete Shopify GraphQL Admin API schema for a given version (e.g., 2026-01, 2025-10). It covers all type kinds recognized by the schema: objects, mutations, queries, connections, enums, input-objects, interfaces, payloads, scalars, and unions. Every response includes the version field so you always know which release of the schema you're reading.
Navigating the schema
get_api_navigation returns a tree of all categories and their member types, each with a name and href. You can filter by category (e.g., 'orders', 'products and collections') and/or by type_kind. When no type_kind filter is applied, the response includes type_counts (a map of kind to integer count) and total_types, giving a quick summary of the schema's shape. When type_kind is specified, the response narrows to a flat items array with a total count.
Inspecting individual types
get_type_detail accepts a type_kind and type_name and returns the full definition: description, kind, fields (with type_signature), arguments, enum_values, interfaces, return_type, and examples where available. This is the right endpoint for code generation, documentation tools, or validation logic that needs to know exactly what a type like Order or appRevokeAccessScopes exposes.
Batch retrieval and pagination
get_types_batch fetches multiple types of a given type_kind in one call, with limit and offset for pagination. Each entry in the types array includes name, kind, category, description, and optional fields, arguments, or enum_values depending on the type kind. The response also returns returned (actual count) alongside total (available count), making it straightforward to iterate through large type groups like all mutations in the orders category.
- Auto-generate typed GraphQL client code from field signatures and argument lists returned by
get_type_detail. - Build a versioned schema diff tool by comparing
type_countsandfieldsresponses across two API versions. - Populate an internal developer portal with up-to-date descriptions and examples for every Shopify Admin mutation.
- Validate an existing Shopify app's GraphQL queries against current enum values and input-object shapes.
- Enumerate all connections in a category like
ordersto map out pagination patterns in the Admin API. - Extract all
payloadsfor a given category to document expected mutation return structures. - Identify deprecated fields or types by scanning descriptions returned across all objects in a batch call.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 250 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does Shopify have an official developer API for this schema?+
What does `get_api_navigation` return when I filter by both `category` and `type_kind`?+
items array of type entries (each with name and href), a total count, the version, the applied category, and the type_kind. Not all type kinds exist in every category — for example, unions are only present in certain categories — so some filter combinations return an empty items array.Does `get_type_detail` return code examples for every type?+
examples field is present when examples are available in the schema documentation. Not every type has examples; the field may be absent or empty for types like scalars or simple enums. Fields, arguments, and enum values are consistently returned for the relevant type kinds.Does the API cover REST Admin API endpoints or only GraphQL?+
Can I retrieve historical schema versions beyond the two shown in the examples?+
version parameter accepts version strings like 2026-01 or 2025-10, and the API will attempt to return schema data for the version requested. Coverage depends on which versions are available in the source documentation. Older versions not published on shopify.dev may not return data. You can fork the API on Parse and revise it to handle version fallback or validation logic.