Linear's GraphQL API, as of Nov 2026, allows 2,500 requests per hour per user with an API key, 5,000 per hour for OAuth apps, and 600 per hour per IP address when unauthenticated. There's also a complexity limit of up to 3,000,000 points per hour for an API key, and a single query can't go over 10,000 points.
Linear meters two things at once: how many requests you make, and how heavy each one is. Most integrations think about the first and get caught by the second.
The hourly numbers
| Item | Limit | Applies to |
|---|---|---|
| Requests per hour (API key) | 2,500 | Each user |
| Requests per hour (OAuth app) | 5,000 | Each user or app user |
| Requests per hour (unauthenticated) | 600 | Each IP address |
| Complexity points per hour (API key) | 3,000,000 | Each user |
| Complexity points per hour (OAuth app) | 2,000,000 | OAuth apps |
| Complexity points per hour (unauthenticated) | 100,000 | Unauthenticated requests |
| Maximum complexity of a single query | 10,000 points | Every request |
Linear notes that these limits may change. All requests by the same user share the API key quota, even across different API keys, so making a second key doesn't double your allowance.
How the bucket refills
Linear uses the leaky bucket algorithm. Tokens refill at a constant rate, the limit divided by the period, rather than all at once on the hour. In practice that means a burst drains the bucket and then you're limited to the refill pace, while a steady trickle of requests can run all day without trouble.
How complexity is scored
Each property you ask for scores 0.1 points and each object scores 1 point. A connection, such as a list of issues, multiplies its children's points by the pagination argument, or by the default of 50 if you don't set one, rounded up.
Here's why that matters. Ask for 50 projects, and for each project its 50 issues, and the issue objects alone come to 2,500 before you add a single property. Add a few fields per issue and a nested list inside each, and you can hit the 10,000-point cap on one query, which is always rejected above that, long before you're anywhere near the hourly request limit.
The default page size is the trap
Linear Developers' page on rate limiting points out that default pagination returns up to 50 records, so querying children multiplies complexity fast. Because the default applies whenever you leave the argument out, a query that looks small in your code can score far higher than you expect. Set the page size on every connection, and keep it as small as the job allows.
Reading the headers
- X-RateLimit-Requests-Limit, -Remaining and -Reset tell you where you stand on request count.
- X-Complexity tells you what the query you just sent scored.
- X-RateLimit-Complexity headers track the hourly complexity allowance.
- X-RateLimit-Endpoint headers appear on queries and mutations that have their own lower limits.
Log X-Complexity during development. It's the quickest way to find the one query that's eating your allowance.
Staying well under
Linear discourages polling. It recommends webhooks so you hear about changes instead of asking repeatedly, plus filters, sorting by the updated timestamp so you only fetch what's changed, and custom queries that ask for just the fields you need. If you're new to the push model, this explainer on APIs and webhooks covers the difference, and tools for monitoring API usage can alert you before you hit a wall.
If you temporarily need higher limits, for a migration say, contact Linear support, which reviews requests case by case.
Want AI doing the heavy lifting in your marketing?
I build the systems that handle the boring 80 percent, so you get your week back. Done properly, with the human kept in.
How Trello and Pipedrive meter calls
Trello's API allows 300 requests per 10 seconds for each API key and 100 per 10 seconds for each token. Pipedrive uses a daily token allowance shared across the company account, plus burst limits over a rolling 2-second window. For a broader look at trackers, here's my list of issue trackers to compare.
My advice for integration builders
Use OAuth if more than one person will run your integration, because each user gets their own allowance. Set an explicit page size on every connection, request only the fields you use, and check X-Complexity on each new query. Swap polling for webhooks, and contact support before a big migration rather than after it stalls.
Want your tool on this list? Featured spots and reviews here are paid partnerships. Here's how to partner with me.
Frequently asked questions
What is the Linear API rate limit?
2,500 requests per hour, as of Nov 2026, with an API key, 5,000 for OAuth apps and 600 unauthenticated.
What is query complexity?
A score: 0.1 per property and 1 per object, multiplied by pagination on connections.
What is the maximum complexity of one query?
10,000 points.
How do I avoid hitting the limit?
Use webhooks, filters, smaller page sizes and custom queries.
Can I get higher limits?
Contact Linear support, which reviews requests case by case.
