Rate Limits

Learn more about how the monday.com GraphQL API implements rate limiting.

Our API uses a construct called complexity to define the cost of each query made.

monday.com API rate limits are based on the complexity of the queries an app makes in a given time period. There are two limits to keep in mind:

  • A single query is limited to 5,000,000 complexity points
  • All queries made must not exceed 10,000,000 points per minute (1M for trial and free accounts) using your API token generated from the Admin section or the Access Tokens section
  • For apps only, reads and writes are each limited to 5,000,000 complexity points a minute

Calculating complexity

Complexity levels are calculated based on the query. Each call will have a different level of complexity depending on the structure of the query. To keep your query complexity low only ask for the objects and properties you need. Additionally, consider implementing pagination.

As an example, a query for all boards and all users would be calculated by adding together the complexity levels of each of those queries.

Additionally, a query for all boards and their items that returns 1,000 boards and 1,000 items per board would have a complexity of 1,000,000 (i.e. 1,000 x 1,000).

query {
    boards {
        items {
            id
        }
    }
}

Default Complexities

Certain queries have default complexities regardless of their results. For example, querying most objects without limits (i.e all boards, items, groups etc.) is calculated as a complexity of 1,000. However, there are specific objects (like updates) which have a default complexity of 25.

Pagination

To work efficiently and avoid reaching the complexity limit, we recommend you add limits to your query so it returns the same number of records each time.

Objects that support pagination take two arguments: limit and page. The limit argument defines the maximum number of objects that are returned, and the page defines which "page" to retrieve.

With this approach, you lower the complexity of each query while still returning the same amount of information (in more calls).

Here's a query that uses the limit and page parameters to return the first 10 updates in an account:

query {
    updates (limit:10, page:1) {
        id
        items {
            id
        }
    }   
}

You can change the "page" argument to return the next 10 items (ie, the 11th to 20th update):

query {
    updates (limit:10, page:2) {
        id
        items {
            id
        }
    }   
}

Happy paginating!

Complexity of nested queries

Nesting queries inside queries will increase the complexity of your query exponentially. Currently, the maximum number of nested queries allowed is 6.

When calculating the complexity of nested queries, multiply the complexity level of each query together. As such, it is very important to add limits to each query to prevent exceeding the complexity limit.

Here's an example of a deeply nested query:

query {
    updates (ids: [12345, 23456, 34567]) {
        board_folder_id
        permissions
        items {
            name
            creator {
                birthday
                teams {
                    name
                    users {
                        id
                    }
                }
            }
        }
    }
}

Checking the complexity of a query or mutation

Since accounts are limited by complexity per minute, understanding the complexity level of each query plays a large role when making queries. The best way to calculate the complexity is to add the complexity field to your queries.

To see how to query complexity, please see the Complexity section.

Exceeding the Limit

The complexity limit starts at 5,000,000 for a single query. Each minute the complexity limit resets to 10,000,000 (or 5,000,000 for reads and 5,000,000 for writes for apps).

There are also mutation-specific rate limits, based on the number of API calls made within a minute for the following mutations:

  • duplicate_group
  • duplicate_board

The mutations above will have an additional rate limit of 40 mutations per minute. If you exceed this limit, you will receive a 429 HTTP response code with "Call limit exceeded for DuplicateGroup" or "Call limit exceeded for DuplicateBoard" error message.

If you exceed either of these limits, the query will return an error in the "errors" field.


Did this page help you?