Shopify APIshopify.dev ↗
Access the full Shopify GraphQL Admin API schema: types, fields, mutations, queries, enums, and more across all categories via 3 structured endpoints.
What is the Shopify 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.
curl -X GET 'https://api.parse.bot/scraper/34fe858c-da35-4567-8de3-5ca4da20fb89/get_api_navigation?version=2026-01&category=Access&type_kind=mutations' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace shopify-dev-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Shopify GraphQL Admin API schema explorer — typed SDK walkthrough."""
from parse_apis.shopify_graphql_admin_api_reference import (
ShopifySchema, TypeKind, TypeNotFound,
)
client = ShopifySchema()
# Browse all scalar types in the schema — limit caps total items fetched.
for scalar in client.typesummaries.list(kind=TypeKind.SCALARS, limit=5):
print(scalar.name, scalar.href)
# Fetch full detail for a specific object type by name.
order = client.graphqltypes.get(kind=TypeKind.OBJECTS, name="Order")
print(order.name, order.kind, order.description[:80])
# Inspect fields on the fetched type.
if order.fields:
for field in order.fields[:3]:
print(field.name, field.type_signature)
# Batch-fetch mutations in a category with offset-based paging.
for mutation in client.graphqltypes.batch(kind=TypeKind.MUTATIONS, category="Access", limit=3):
print(mutation.name, mutation.kind)
if mutation.arguments:
print(" args:", mutation.arguments[0].name, mutation.arguments[0].type_signature)
# Navigate from a summary to its full detail via the instance method.
summary = client.typesummaries.list(kind=TypeKind.ENUMS, limit=1).first()
if summary:
detail = summary.details(kind=TypeKind.ENUMS)
print(detail.name, detail.kind, len(detail.enum_values or []), "values")
# Handle a type that doesn't exist — typed error catch.
try:
client.graphqltypes.get(kind=TypeKind.OBJECTS, name="NonExistentType999")
except TypeNotFound as exc:
print(f"Type not found: {exc.type_name}")
print("exercised: typesummaries.list / graphqltypes.get / graphqltypes.batch / summary.details / TypeNotFound")
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. When type_kind is specified, returns a flat list of matching types with a total count. When no type_kind filter is applied, returns the full tree with category names and type counts per kind. Not all type kinds exist in every category (e.g. unions are only in the 'GraphQL Types' category).
| 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)"
}
}About the Shopify API
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.
The Shopify API is a managed, monitored endpoint for shopify.dev — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when shopify.dev changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official shopify.dev API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- 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 | 100 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.