GraphQL Query Complexity & Depth Calculator

Schema (SDL)

GraphQL schema

"A made-up furniture shop API for the GraphQL complexity analyser."
directive @cost(weight: String!) on FIELD_DEFINITION | OBJECT
directive @listSize(assumedSize: Int, slicingArguments: [String!], sizedFields: [String!]) on FIELD_DEFINITION

type Query {
  products(first: Int = 10, after: String, category: String): ProductConnection!
  product(id: ID!): Product
  order(id: ID!): Order
  search(term: String!, limit: Int = 20): [SearchResult!]!
  me: Customer
}

type Mutation {
  addToBasket(sku: String!, qty: Int = 1): Basket! @cost(weight: "10")
}

type ProductConnection {
  edges: [ProductEdge!]!
  pageInfo: PageInfo!
  totalCount: Int!
}

type ProductEdge { cursor: String! node: Product! }
type PageInfo { hasNextPage: Boolean! endCursor: String }

interface Node { id: ID! }

type Product implements Node {
  id: ID!
  name: String!
  price: Money!
  reviews(first: Int = 5): [Review!]! @listSize(slicingArguments: ["first"])
  related(first: Int = 4): [Product!]!
  variants: [Variant!]! @listSize(assumedSize: 6)
  stock: Int! @cost(weight: "3")
}

type Variant { sku: String! finish: Finish! price: Money! }
enum Finish { NATURAL SMOKED WHITE_OILED }
type Money { amount: Float! currency: String! }
type Review implements Node { id: ID! rating: Int! body: String author: Customer! }
type Customer implements Node { id: ID! name: String! orders(first: Int = 10): [Order!]! }
type Order implements Node { id: ID! total: Money! items: [OrderItem!]! placed: String! }
type OrderItem { product: Product! qty: Int! }
type Article { title: String! url: String! }
type Basket { items: [OrderItem!]! total: Money! }
union SearchResult = Product | Article

Query

Query, mutation or subscription

Variables (JSON, optional)

Operation

Cost and limits

Cost of an object field

Cost of a scalar or enum field

Assumed size of lists without a page-size argument

Depth limit

Cost limit

Field	Type	Multiplier	Weight	Repeated	Cost

Each field costs its weight plus its multiplier times the cost of its children. Multipliers come from slicing arguments (first, last, limit and similar, or those named in @listSize), then @listSize(assumedSize), then the assumed list size; edges and nodes inside a sliced connection aren't multiplied again. @cost(weight) overrides a field's weight. Fragments are expanded and @skip/@include honoured.

What it does

Validates a GraphQL operation against your schema, then works out its depth, requested nodes and cost with list multipliers, @listSize and @cost.

Validation against your SDL: unknown fields and arguments, required arguments, leaf selections, fragments, variables and spreads
Depth and field count with fragments expanded and @skip/@include honoured
Cost with multipliers from first, last, limit and similar arguments, including their schema defaults
@listSize (assumedSize, slicingArguments) and @cost(weight) from the IBM GraphQL cost directive spec

Private by design

Everything happens in your browser. Nothing you type, paste or upload is sent anywhere, and it keeps working offline once the page has loaded.

What you get

Validation errors, depth, nodes, cost and a per-field cost table, with a Copy and a Download button on every result.

GraphQL
APIs
Performance
Security

Why it matters

A single GraphQL request can ask for a few fields or for millions of records: ten products, each with ten reviews, each by a customer with ten orders, is already a thousand rows. Servers protect themselves with depth limits and cost analysis, and clients hit those limits with errors that rarely say which part of the query is to blame.

This analyser validates the query against your schema with the core GraphQL rules (checked against graphql-core, the Python port of the reference implementation), then walks it field by field. Every field gets a weight and a multiplier from its page-size argument, so the table shows exactly where the cost comes from and how far a smaller first would bring it down.

How to use it

Paste your schema in SDL.
Paste the query, and any variables as JSON.
Set the costs and limits your server uses.
Read the validation errors, the totals and the cost of each field.

FAQ

How is GraphQL query cost calculated?

Each field has a weight, and fields that return lists multiply the cost of everything below them by the number of items requested. Summing over the query gives its cost.

What is query depth?

The deepest level of nested fields. Depth limits stop recursive queries such as friends of friends of friends.

What do @cost and @listSize do?

They come from the IBM GraphQL cost directive spec: @cost sets a field's weight, and @listSize says how many items a list returns or which arguments set its size.

Why is my list field assumed to return 10 items?

Without a page-size argument or @listSize, its size is unknown, so an assumption is used. Change it under Cost and limits, or annotate the schema.

Work with me

Want a site that gets these right?

I build fast, accessible websites and web apps that pass these checks from day one. Tell me about your project and I'll reply personally with honest next steps.

Start a project What I do

All developer tools · Back to leej.uk

GraphQL Query Complexity Analyser