gamma-rate-limits
Understand and manage Gamma API rate limits effectively.Use when hitting rate limits, optimizing API usage,or implementing request queuing systems.Trigger with phrases like "gamma rate limit", "gamma quota","gamma 429", "gamma throttle", "gamma request limits".
When & Why to Use This Skill
This Claude skill provides comprehensive strategies and production-ready code implementations for managing Gamma API rate limits. It helps developers eliminate '429 Too Many Requests' errors by implementing robust exponential backoff logic, request queuing systems, and real-time usage monitoring to ensure stable, high-volume API integrations.
Use Cases
- Automating error handling for Gamma API integrations using exponential backoff to gracefully recover from rate limit triggers.
- Implementing a centralized request queuing system to maintain steady throughput and stay within specific tier limits (Free, Pro, Team).
- Developing real-time monitoring tools to track API quota consumption, remaining requests, and reset windows for better resource planning.
- Optimizing high-concurrency workflows like bulk presentation generation or large-scale exports to prevent service interruptions.
| name | gamma-rate-limits |
|---|---|
| description | | |
| allowed-tools | Read, Write, Edit |
| version | 1.0.0 |
| license | MIT |
| author | Jeremy Longshore <jeremy@intentsolutions.io> |
Gamma Rate Limits
Overview
Understand Gamma API rate limits and implement effective strategies for high-volume usage.
Prerequisites
- Active Gamma API integration
- Understanding of HTTP headers
- Basic queuing concepts
Rate Limit Tiers
| Plan | Requests/min | Presentations/day | Exports/hour |
|---|---|---|---|
| Free | 10 | 5 | 10 |
| Pro | 60 | 50 | 100 |
| Team | 200 | 200 | 500 |
| Enterprise | Custom | Custom | Custom |
Instructions
Step 1: Check Rate Limit Headers
const response = await gamma.presentations.list();
// Rate limit headers
const headers = response.headers;
console.log('Limit:', headers['x-ratelimit-limit']);
console.log('Remaining:', headers['x-ratelimit-remaining']);
console.log('Reset:', new Date(headers['x-ratelimit-reset'] * 1000));
Step 2: Implement Exponential Backoff
async function withBackoff<T>(
fn: () => Promise<T>,
options = { maxRetries: 5, baseDelay: 1000 }
): Promise<T> {
for (let attempt = 0; attempt < options.maxRetries; attempt++) {
try {
return await fn();
} catch (err) {
if (err.status !== 429 || attempt === options.maxRetries - 1) {
throw err;
}
const delay = err.retryAfter
? err.retryAfter * 1000
: options.baseDelay * Math.pow(2, attempt);
console.log(`Rate limited. Retrying in ${delay}ms...`);
await new Promise(r => setTimeout(r, delay));
}
}
throw new Error('Max retries exceeded');
}
// Usage
const result = await withBackoff(() =>
gamma.presentations.create({ title: 'My Deck', prompt: 'AI overview' })
);
Step 3: Request Queue
class RateLimitedQueue {
private queue: Array<() => Promise<any>> = [];
private processing = false;
private requestsPerMinute: number;
private interval: number;
constructor(requestsPerMinute = 60) {
this.requestsPerMinute = requestsPerMinute;
this.interval = 60000 / requestsPerMinute;
}
async add<T>(fn: () => Promise<T>): Promise<T> {
return new Promise((resolve, reject) => {
this.queue.push(async () => {
try {
resolve(await fn());
} catch (err) {
reject(err);
}
});
this.process();
});
}
private async process() {
if (this.processing) return;
this.processing = true;
while (this.queue.length > 0) {
const fn = this.queue.shift()!;
await fn();
await new Promise(r => setTimeout(r, this.interval));
}
this.processing = false;
}
}
// Usage
const queue = new RateLimitedQueue(30); // 30 req/min
const results = await Promise.all([
queue.add(() => gamma.presentations.create({ ... })),
queue.add(() => gamma.presentations.create({ ... })),
queue.add(() => gamma.presentations.create({ ... })),
]);
Step 4: Monitor Usage
async function getRateLimitStatus() {
const status = await gamma.rateLimit.status();
return {
limit: status.limit,
remaining: status.remaining,
percentUsed: ((status.limit - status.remaining) / status.limit * 100).toFixed(1),
resetAt: new Date(status.reset * 1000),
resetIn: Math.ceil((status.reset * 1000 - Date.now()) / 1000),
};
}
// Usage
const status = await getRateLimitStatus();
console.log(`Used ${status.percentUsed}% of rate limit`);
console.log(`Resets in ${status.resetIn} seconds`);
Output
- Rate limit aware API calls
- Automatic retry with backoff
- Request queuing system
- Usage monitoring dashboard
Error Handling
| Scenario | Strategy | Implementation |
|---|---|---|
| Occasional 429 | Exponential backoff | withBackoff() wrapper |
| Consistent 429 | Request queue | RateLimitedQueue class |
| Near limit | Preemptive throttle | Check remaining before call |
| Burst traffic | Token bucket | Implement token bucket algorithm |
Resources
Next Steps
Proceed to gamma-security-basics for security best practices.