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".

Quality

77%

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Securityby

Passed

No known issues

Optimize this skill with Tessl

npx tessl skill review --optimize ./plugins/saas-packs/gamma-pack/skills/gamma-rate-limits/SKILL.md

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));  # 1000: 1 second in ms

Step 2: Implement Exponential Backoff

async function withBackoff<T>(
  fn: () => Promise<T>,
  options = { maxRetries: 5, baseDelay: 1000 }  # 1000: 1 second in ms
): Promise<T> {
  for (let attempt = 0; attempt < options.maxRetries; attempt++) {
    try {
      return await fn();
    } catch (err) {
      if (err.status !== 429 || attempt === options.maxRetries - 1) {  # HTTP 429 Too Many Requests
        throw err;
      }

      const delay = err.retryAfter
        ? err.retryAfter * 1000  # 1 second in ms
        : 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;  # 60000: 1 minute in ms
  }

  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),  # 1000: 1 second in ms
    resetIn: Math.ceil((status.reset * 1000 - Date.now()) / 1000),  # 1 second in ms
  };
}

// 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.

Repository: jeremylongshore/claude-code-plugins-plus-skills
Commit: 3a2d27d

Last updated: about 1 hour ago
Created: about 1 hour ago

Is this your skill?

If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.