Imported from jeremylongshore/tons-of-skills-marketplace (skills/.curated/fathom-rate-limits/SKILL.md). Install upstream with npx skills add jeremylongshore/tons-of-skills-marketplace --skill fathom-rate-limits. Copyright stays with the author (MIT).

Fathom Rate Limits

Prerequisites

• Current provider limits, aggregate baseline, stable request/event IDs, synthetic test data, and a capacity owner.

Instructions

1. Bound concurrency and preserve idempotency for meeting, sync, and follow-up operations.
2. Monitor throttling, queue age, errors, and duplicate-action risk using redacted aggregate metrics.
3. Back off with jitter on transient limits and reduce load before replaying failed work.

Output

• A rate-aware workflow with bounded retry, idempotency, redacted monitoring, and safe recovery ownership.

Examples

Increase synthetic development workload gradually below approved limits, record aggregate 429s/latency/completion, and apply backoff on throttling. Do not retry meeting/CRM follow-up actions without checking stable IDs, consent, and current state.

Overview

Fathom's API enforces a strict 60 requests-per-minute cap per user across all API keys. Since meeting transcripts and action items are often fetched in bulk after a day of calls, this limit becomes a real constraint for teams processing large meeting backlogs. Transcript endpoints are especially heavy because they return full conversation text, making pagination and careful throttling essential for any integration that syncs meeting intelligence into CRMs or project trackers.

Rate Limit Reference

Rate Limiter Implementation

class FathomRateLimiter {
  private tokens: number = 60;
  private lastRefill: number = Date.now();
  private queue: Array<{ resolve: () => void }> = [];

  async acquire(): Promise<void> {
    this.refill();
    if (this.tokens >= 1) { this.tokens -= 1; return; }
    return new Promise(resolve => this.queue.push({ resolve }));
  }

  private refill() {
    const now = Date.now();
    const elapsed = now - this.lastRefill;
    this.tokens = Math.min(60, this.tokens + (elapsed / 60_000) * 60);
    this.lastRefill = now;
    while (this.tokens >= 1 && this.queue.length) {
      this.tokens -= 1;
      this.queue.shift()!.resolve();
    }
  }
}

const limiter = new FathomRateLimiter();

Retry Strategy

async function fathomRetry<T>(fn: () => Promise<Response>, maxRetries = 3): Promise<T> {
  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    await limiter.acquire();
    const res = await fn();
    if (res.ok) return res.json();
    if (res.status === 429) {
      const retryAfter = parseInt(res.headers.get("Retry-After") || "60", 10);
      const jitter = Math.random() * 3000;
      await new Promise(r => setTimeout(r, retryAfter * 1000 + jitter));
      continue;
    }
    if (res.status >= 500 && attempt < maxRetries) {
      await new Promise(r => setTimeout(r, Math.pow(2, attempt) * 2000));
      continue;
    }
    throw new Error(`Fathom API ${res.status}: ${await res.text()}`);
  }
  throw new Error("Max retries exceeded");
}

Batch Processing

async function syncAllTranscripts(meetingIds: string[], batchSize = 10) {
  const results: any[] = [];
  for (let i = 0; i < meetingIds.length; i += batchSize) {
    const batch = meetingIds.slice(i, i + batchSize);
    const batchResults = await Promise.all(
      batch.map(id => fathomRetry(() =>
        fetch(`${BASE}/api/v1/meetings/${id}/transcript`, { headers })
      ))
    );
    results.push(...batchResults);
    if (i + batchSize < meetingIds.length) await new Promise(r => setTimeout(r, 12_000));
  }
  return results;
}

Error Handling

Resources

• Fathom API Documentation

Next Steps

See fathom-performance-tuning.