Resource Limitations

The Arize GraphQL API has limitations in place to protect against excessive or abusive calls to our servers.

Pagination Enforcement

Certain connections require a first or last argument to be passed in to avoid massive fan-out queries. For these types of queries, you will encounter an error indicating that you must set a page size that is under a certain number. For more details about pagination and GraphQL, please consult

Rate Limit

There are simple frequency limitations placed on the Arize GraphQL API to avoid abusive behavior. Queries are limited to 100 queries per minute and mutations are limited to 300 per minute.

A good rule of thumb is to avoid more than 100 requests a minute and to avoid massive parallel jobs.

Complexity Limit

With GraphQL, one query can replace multiple. A single complex GraphQL query could return data equivalent to thousands of REST requests. This means the query rate limit does not sufficiently represent the computational costs on our servers.

To accurately represent the server cost of a query, the GraphQL API calculates a call's complexity score based on the query itself. As long as your query falls under our complexity cost limit of 1000, you can execute this level of query.

the complexity limit and cost for a given query in the explorer by specifying the rateLimit node.

Calculating Complexity

Note: The minimum cost of a call to the GraphQL API is 1, representing a single request.

Each equates to 1 complexity point. This includes the estimated nodes returned from connections.
Each node defaults to 1 complexity point.

Below is an example query and complexity score calculation:

query {
  node(id:"U3BhN226MQ==") {
    ... on Space{
      name
      monitors(first: 50, monitorCategory:drift){
        edges {
          node {
            name
            threshold
            status
          }
        }
      }
    }
  }
}

Calculation:

1 Space node + 1 Space field (name) + (50 Monitors X 5 Monitor Fields (name, threshold, status, edges, node )

Total Query Cost = 252

Returning a call's complexity cost

With the GraphQL API, you can check the complexity cost for a given query by querying fields on the rateLimit object:

query {
  rateLimit {
    limit
    cost
  }
}

The limit field returns the maximum number of points the client is permitted to consume for a given call
The cost field returns the point cost for the current call

Last updated 1 year ago

Was this helpful?

query { node(id:"U3BhN226MQ==") { ... on Space{ name monitors(first: 50, monitorCategory:drift){ edges { node { name threshold status } } } } } }