Skip to main content الرئيسية المنشئون jeremylongshore tons-of-skills-marketplace linear-rate-limits
linear-rate-limits Handle Linear API rate limiting, complexity budgets, and quotas.
Use when dealing with 429 errors, implementing throttling,
or optimizing request patterns to stay within limits.
Trigger: "linear rate limit", "linear throttling", "linear 429",
"linear API quota", "linear complexity", "linear request limits".
الانتقال إلى التثبيت سوق المهارات اكتشف واستكشف مهارات الذكاء الاصطناعي التي بناها المجتمع.
التثبيت باستخدام Codex أو Claude انسخ هذا Prompt والصقه في Codex أو Claude أو مساعد آخر ليراجع صفحة Skill ويثبّتها لك.
عرض تفاصيل Prompt يتجاوز الأمر المباشر Prompt المخصّص للمراجعة. افحص المصدر قبل تشغيله.
npx skills add https://github.com/jeremylongshore/tons-of-skills-marketplace --skill linear-rate-limitsيبقى الأمر في سطر واحد. مرّر أفقيًا لمراجعته كاملًا قبل النسخ.
تفضّل نسخة محلية؟ نزّل الملفات المتاحة حاليًا لدى SkillsMP.
تحميل Zip جاري التحميل... المزيد من هذا المستودع langchain-deploy-integration Deploy a LangChain 1.0 / LangGraph 1.0 app to Cloud Run, Vercel, or LangServe correctly — with timeouts sized for chain length, cold-start mitigation, SSE anti-buffering headers, and Secret Manager over .env. Use when prepping a first production deploy, debugging a stream that hangs behind a proxy, or diagnosing p99 latency spikes. Trigger with "langchain deploy", "langchain cloud run", "langchain vercel python", "langchain langserve", or "langchain docker".
langchain-langgraph-agents Build a correct LangGraph 1.0 ReAct agent with create_react_agent — typed tools, error propagation, recursion caps, and stop conditions that actually stop. Use when writing a first tool-calling agent, migrating from AgentExecutor or initialize_agent, or diagnosing an agent that loops on vague prompts. Trigger with "langgraph agent", "create_react_agent", "langgraph tool calling", "AgentExecutor migration", or "agent loop cost".
langchain-langgraph-human-in-loop Build LangGraph 1.0 human-in-the-loop approval flows with interrupt_before /
interrupt_after and Command(resume=...) — JSON-serializable state, clean
resume semantics, and UI wiring for approval decisions. Use when adding an
approval gate before an expensive tool call, wiring a Slack/web UI for agent
approvals, or debugging a graph that crashes on interrupt.
Trigger with "langgraph human in loop", "langgraph interrupt_before",
"langgraph approval flow", "Command resume", "langgraph HITL".
name linear-rate-limits description Handle Linear API rate limiting, complexity budgets, and quotas.
Use when dealing with 429 errors, implementing throttling,
or optimizing request patterns to stay within limits.
Trigger: "linear rate limit", "linear throttling", "linear 429",
"linear API quota", "linear complexity", "linear request limits".
allowed-tools Read, Write, Edit, Grep version 1.12.0 license MIT author Jeremy Longshore <jeremy@intentsolutions.io> tags ["saas","linear","api"] compatibility Designed for Claude Code
Linear Rate Limits
Overview
Linear uses the leaky bucket algorithm with two rate limiting dimensions. Understanding both is critical for reliable integrations:
Budget Limit Refill Rate Requests 5,000/hour per API key ~83/min constant refill Complexity 250,000 points/hour ~4,167/min constant refill Max single query 10,000 points Hard reject if exceeded
Complexity scoring: Each property = 0.1 pt, each object = 1 pt, connections multiply children by first arg (default 50), then round up.
Prerequisites
@linear/sdk installedUnderstanding of HTTP response headers
Familiarity with async/await patterns
Instructions
Step 1: Read Rate Limit Headers
Linear returns rate limit info on every response.
const response = await fetch ("https://api.linear.app/graphql" , {
method : "POST" ,
headers : {
Authorization : process.env .LINEAR_API_KEY !,
"Content-Type" : "application/json" ,
},
body : JSON .stringify ({ query : "{ viewer { id } }" }),
});
const headers = {
requestsRemaining : response.headers .get ("x-ratelimit-requests-remaining" ),
requestsLimit : response.headers .get
"x-ratelimit-requests-limit"
requestsReset
headers
get
"x-ratelimit-requests-reset"
complexityRemaining
headers
get
"x-ratelimit-complexity-remaining"
complexityLimit
headers
get
"x-ratelimit-complexity-limit"
queryComplexity
headers
get
"x-complexity"
console
log
`Requests: ${headers.requestsRemaining} /${headers.requestsLimit} `
console
log
`Complexity: ${headers.complexityRemaining} /${headers.complexityLimit} `
console
log
`This query cost: ${headers.queryComplexity} points`
Step 2: Exponential Backoff with Jitter import { LinearClient } from "@linear/sdk" ;
class RateLimitedClient {
private client : LinearClient ;
constructor (apiKey : string this .client = new LinearClient ({ apiKey });
}
async withRetry<T>(fn : () => Promise <T>, maxRetries = 5 ): Promise <T> {
for (let attempt = 0 ; attempt < maxRetries; attempt++) {
try {
return await fn ();
} catch (error : any ) {
const isRateLimited = error.status === 429 ||
error.message ?.includes ("rate" ) ||
error.type === "ratelimited" ;
if (!isRateLimited || attempt === maxRetries - 1 ) throw error;
const delay = 1000 * Math .pow (2 , attempt) + Math .random () * 500 ;
console .warn (`Rate limited (attempt ${attempt + 1 } /${maxRetries} ), waiting ${Math .round(delay)} ms` );
await new Promise (r =>setTimeout (r, delay));
}
}
throw new Error ("Unreachable" );
}
get sdk () { return this .client ; }
}
Step 3: Request Queue with Token Bucket Prevent bursts by spacing requests evenly.
class RequestQueue {
private queue : Array <{ fn : () => Promise <any >; resolve : Function ; reject : Function }> = [];
private processing = false ;
private intervalMs : number ;
constructor (requestsPerSecond = 10 ) {
this .intervalMs = 1000 / requestsPerSecond;
}
async enqueue<T>(fn : () => Promise <T>): Promise <T> {
return new Promise ((resolve, reject ) => {
this .queue .push ({ fn, resolve, reject });
if (!this .processing ) this .processQueue ();
});
}
private async processQueue (this .processing = true ;
while (this .queue .length > 0 ) {
const { fn, resolve, reject } = this .queue .shift ()!;
try {
resolve (await fn ());
} catch (error) {
reject (error);
}
if (this .queue .length > 0 ) {
await new Promise (r =>setTimeout (r, this .intervalMs ));
}
}
this .processing = false ;
}
}
const queue = new RequestQueue (8 );
const client = new LinearClient ({ apiKey : process.env .LINEAR_API_KEY ! });
const teamResults = await Promise .all (
teamIds.map (id =>enqueue (() => client.team (id)))
);
Step 4: Reduce Query Complexity
const light = await client.issues ({
first : 50 ,
filter : { team : { id : { eq : teamId } } },
});
const minimal = await client.client .rawRequest (`
query { issues(first: 50) { nodes { id identifier title priority } } }
` );
const fresh = await client.issues ({
first : 50 ,
orderBy : "updatedAt" ,
filter : { updatedAt : { gte : lastSyncTime } },
});
Step 5: Batch Mutations Combine multiple mutations into one GraphQL request.
async function batchUpdatePriority (client : LinearClient , issueIds : string [], priority : number const chunkSize = 20 ;
for (let i = 0 ; i < issueIds.length ; i += chunkSize) {
const chunk = issueIds.slice (i, i + chunkSize);
const mutations = chunk.map ((id, j ) =>
`u${j} : issueUpdate(id: "${id} ", input: { priority: ${priority} }) { success }`
).join ("\n" );
await queue.enqueue (() =>
client.client .rawRequest (`mutation BatchUpdate { ${mutations} }` )
);
}
}
async function batchArchive (client : LinearClient , issueIds : string []for (let i = 0 ; i < issueIds.length ; i += 20 ) {
const chunk = issueIds.slice (i, i + 20 );
const mutations = chunk.map ((id, j ) =>
`a${j} : issueArchive(id: "${id} ") { success }`
).join ("\n" );
await client.client .rawRequest (`mutation { ${mutations} }` );
}
}
Step 6: Rate Limit Monitor class RateLimitMonitor {
private remaining = { requests : 5000 , complexity : 250000 };
update (headers : Headers const reqRemaining = headers.get ("x-ratelimit-requests-remaining" );
const cxRemaining = headers.get ("x-ratelimit-complexity-remaining" );
if (reqRemaining) this .remaining .requests = parseInt (reqRemaining);
if (cxRemaining) this .remaining .complexity = parseInt (cxRemaining);
}
isLow (): boolean {
return this .remaining .requests < 100 || this .remaining .complexity < 5000 ;
}
getStatus (return {
requests : this .remaining .requests ,
complexity : this .remaining .complexity ,
healthy : !this .isLow (),
};
}
}
Error Handling Error Cause Solution HTTP 429 Request or complexity budget exceeded Parse headers, back off exponentially Query complexity too highSingle query > 10,000 pts Reduce first to 50, remove nested relations Burst of 429s on startup Init fetches too much data Stagger startup queries, cache static data Timeout on SDK call Server under load Add 30s timeout, retry once
Examples
Rate Limit Status Check curl -s -I -X POST https://api.linear.app/graphql \
-H "Authorization: $LINEAR_API_KEY " \
-H "Content-Type: application/json" \
-d '{"query": "{ viewer { id } }"}' 2>&1 | grep -i ratelimit
Safe Bulk Import const rlClient = new RateLimitedClient (process.env .LINEAR_API_KEY !);
const items = [];
for (let i = 0 ; i < items.length ; i++) {
await rlClient.withRetry (() =>
rlClient.sdk .createIssue ({ teamId : "team-uuid" , title : items[i].title })
);
if ((i + 1 ) % 50 === 0 ) console .log (`Imported ${i + 1 } /${items.length} ` );
}
Resources 