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

Endpoint	Limit	Window	Scope
List meetings	60 req	1 minute	Per user
Get transcript	60 req	1 minute	Per user
Action items	60 req	1 minute	Per user
Meeting summary	60 req	1 minute	Per user
Webhook management	10 req	1 minute	Per user

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

Issue	Cause	Fix
429 Too Many Requests	Exceeded 60 req/min user cap	Wait for Retry-After, then resume
Empty transcript	Meeting still processing	Poll with 30s interval until ready
401 on refresh	Expired OAuth token	Rotate token before batch starts
Timeout on long meetings	Transcript > 2 hours of audio	Request with Accept-Encoding: gzip
Missing action items	AI extraction not yet complete	Retry after 5-minute delay

Resources

• Fathom API Documentation

Next Steps

See fathom-performance-tuning.