Fathom Rate LimitsSAFE

Model-agnostic agent-skills platform with a harness-free canonical layer, verified adapters, and the ccpi package manager. Explore at tonsofskills.com.

The instruction file, verbatim from the audited commit — this is the text the model reads, and the surface the audit's instruction layer examines. Quoted here so you can judge it without cloning anything.

---
name: fathom-rate-limits
description: 'Handle Fathom API rate limits (60 requests/minute per user).

  Trigger with phrases like "fathom rate limit", "fathom 429", "fathom throttle".

  '
allowed-tools: Read, Write, Edit
version: 1.6.0
license: MIT
author: Jeremy Longshore <[email protected]>
tags:
- saas
- meeting-intelligence
- ai-notes
- fathom
compatibility: Designed for Claude Code
---
# 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

```typescript
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

```typescript
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

```typescript
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`.

SAFEgrade B · trust 89/100 Nothing in the source contradicts what it says it does. Grade A is reserved for packages that have also passed the behavioural sandbox.

What the source does

Filesystem

none-observed

Network

none-observed

Shell

none-observed

Dependencies

pinned

Secrets in source

none-found

Findings (0)

No findings outside the package's declared scope.

Gates applied: no_behavioural_pass.