Connect Fathom to Claude: Analyze Meeting History and Teams

If you need to connect Fathom to Claude to analyze meeting transcripts, extract action items, or audit team meeting activity, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's tool calls and Fathom's REST APIs. You can either build and maintain this infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL. If your team uses ChatGPT, check out our guide on connecting Fathom to ChatGPT or explore our broader architectural overview on connecting Fathom to AI Agents.

Giving a Large Language Model (LLM) read and write access to a specialized conversational intelligence platform like Fathom is a distinct engineering challenge. You are not just dealing with simple CRUD operations. You have to handle deeply nested transcript arrays, asynchronous summary generation, granular webhook configurations, and strict rate limits. Every time an API endpoint is updated or a schema drifts, you have to update your server code, redeploy, and test the integration.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Fathom, connect it natively to Claude Desktop or your custom Claude applications, and execute complex meeting analysis workflows using natural language.

The Engineering Reality of the Fathom API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover and invoke tools via JSON-RPC 2.0, the reality of implementing it against vendor APIs is painful. Fathom's API presents several unique architectural challenges that you must account for if you decide to build this connectivity from scratch.

Massive, Deeply Nested Payloads Fathom's primary value is in its conversational data. When you query a single meeting or recording, the response is not a flat metadata object. Endpoints return deeply nested structures containing crm_matches, calendar_invitees, action_items, and massive array sets for transcript. If you expose these raw payloads directly to an LLM without strict JSON Schema definitions and parameter filtering, you will immediately blow out Claude's context window or trigger token limit errors. Truto handles this by dynamically generating strict query and body schemas from Fathom's documentation records, ensuring Claude only asks for and receives exactly what is required.

Granular Webhook Topologies Unlike basic SaaS applications where you subscribe a webhook to a generic meeting.ended event, Fathom requires highly specific boolean configurations to determine what data is sent to the destination. When provisioning a webhook, you must explicitly declare include_transcript, include_crm_matches, include_summary, or include_action_items. If an AI agent attempts to create a webhook without understanding this strict requirement, the API will reject the request. Truto normalizes these requirements into an MCP-compliant schema, so Claude understands exactly which boolean flags are required to route the correct data.

Rate Limits and 429 Pass-Throughs Fathom enforces strict rate limits on API consumption. When an AI agent gets stuck in a loop - perhaps trying to recursively summarize a year of weekly syncs - it will hit a 429 Too Many Requests error. A common mistake when building custom MCP servers is attempting to have the server automatically absorb, retry, or backoff these requests. Truto takes the correct architectural approach: it does not retry, throttle, or apply backoff on rate limit errors. Instead, Truto passes the HTTP 429 error directly back to the caller (Claude) and normalizes Fathom's upstream rate limit info into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. This guarantees that the caller - whether it is Claude Desktop or a custom LangGraph agent - assumes responsibility for the retry and backoff logic, preventing silent failures and blocked event loops.

How to Generate a Fathom MCP Server

Truto dynamically generates MCP tools from Fathom's resource definitions. Tools are never cached or pre-built. They are derived at runtime using a combination of the integration's resource configurations and environment-level documentation overrides. You can generate a standalone Fathom MCP server in two ways.

Method 1: Via the Truto UI

If you prefer a visual interface, you can generate an MCP server directly from your Truto dashboard:

1. Navigate to the Integrated Accounts page and select your connected Fathom account.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration. You can filter by specific methods (e.g., read, write) or by functional tags (e.g., meetings, admin). You can also set an expiration date for the server.
5. Click Create and copy the generated MCP server URL (e.g., https://api.truto.one/mcp/a1b2c3d4e5f6...).

Method 2: Via the Truto API

For automated deployments or dynamic agent provisioning, you can generate the MCP server programmatically. The API validates that the Fathom integration is AI-ready, generates a cryptographically secure token, hashes it for storage, and returns the URL.

curl -X POST https://api.truto.one/integrated-account/{fathom_account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Fathom Meeting Analyst Agent",
    "config": {
      "methods": ["read", "write", "custom"]
    }
  }'

The response will contain your active MCP server URL:

{
  "id": "mcp_8f7d6e5c",
  "name": "Fathom Meeting Analyst Agent",
  "config": {
    "methods": ["read", "write", "custom"]
  },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}

Connecting the Fathom MCP Server to Claude

Once you have your Truto MCP server URL, connecting it to Claude requires zero additional code. The URL inherently contains the cryptographic token necessary to authenticate requests against that specific Fathom tenant. You can connect it via the UI or a configuration file.

Method A: Via the Claude UI

If your organization uses Claude via a managed enterprise interface (or if you are applying this pattern to ChatGPT's custom connectors):

1. Open your AI client's settings. For Claude Desktop or web, navigate to Settings -> Integrations -> Add MCP Server (or Settings -> Connectors -> Add in similar LLM platforms).
2. Name the integration (e.g., "Fathom Data Access").
3. Paste the Truto MCP URL into the Server URL field.
4. Click Add or Save. Claude will automatically send an initialize JSON-RPC request to the URL, discover the Fathom tools, and make them available in your context window.

Method B: Via Manual Config File

If you are running Claude Desktop locally and prefer to manage connections via the configuration file, you can utilize the @modelcontextprotocol/server-sse transport package.

Locate your claude_desktop_config.json file:

• Mac: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json

Add your Fathom server using the following configuration:

{
  "mcpServers": {
    "fathom_analyst": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/a1b2c3d4e5f6..."
      ]
    }
  }
}

Restart Claude Desktop. The application will execute the command, establish the Server-Sent Events (SSE) connection, and pull the complete list of Fathom tools into your workspace.

Hero Fathom Tools for Claude

Truto maps Fathom's underlying API endpoints into standardized MCP tools. The execution utilizes a flat input namespace - meaning query parameters and body parameters are passed as a single object by Claude, and Truto's proxy API handles the schema mapping and execution natively. Here are the highest-leverage tools available for your Fathom integration.

List All Fathom Meetings

Retrieves a paginated list of meetings. This tool returns extensive metadata including the title, URL, recording timestamps, CRM matches, and default action items. It is the primary entry point for discovery.

"Claude, check Fathom for any meetings I had yesterday regarding the 'Project Apex' deal. Give me the meeting URLs and a quick overview of the default summary provided by Fathom."

List All Fathom Recording Transcript

Fetches the raw, timestamped transcript for a specific Fathom recording using the recording_id. The return payload includes speaker display names and exact text segments, making it perfect for deep qualitative analysis.

"Take the recording ID from our last meeting and pull the full Fathom transcript. I need you to identify every instance where the client mentioned 'pricing' or 'budget' and map it to the timestamp."

List All Fathom Recording Summary

Retrieves the formatted summary for a specific recording. If you provide a destination_url in the tool call, Fathom will asynchronously POST the markdown-formatted summary to that endpoint.

"Get the meeting summary for the recording ID I just pasted. I need to see the template format used, and if there are missing action items, let me know so we can draft them."

Create a Fathom Webhook

Automates the provisioning of real-time data pipelines. Claude can dynamically establish webhooks that route Fathom data to external systems. It requires specifying at least one boolean flag (e.g., include_transcript).

"Create a new Fathom webhook that points to our Slack integration URL. Make sure it triggers for all new meetings and explicitly includes the action items and CRM matches in the payload."

List All Fathom Team Members

Audits the user directory within your Fathom instance. This tool returns the name, email, and creation date for every team member, which is vital for mapping meeting attendees to internal identity providers.

"Pull the list of all active Fathom team members. Cross-reference their emails with the invitees from the last recorded meeting to see which of our internal engineers actually attended."

To view the complete inventory of available Fathom tools, including detailed JSON Schema definitions for every query and body parameter, visit the Fathom integration page.

Workflows in Action

Exposing Fathom's API to Claude enables autonomous workflows that previously required manual data entry or complex Zapier pipelines. Here are two real-world examples of how personas leverage these tools.

1. The Sales Engineering Post-Mortem

Sales engineers often need to extract deeply technical requirements from discovery calls without manually scrubbing video timelines. Claude can automate this extraction.

"I need to run a post-mortem on the 'Enterprise SSO Discovery' call from yesterday. Find the meeting, pull the full transcript, and generate a technical spec document detailing exactly what SAML configurations the prospect asked for. Ignore the small talk."

Tool Execution Sequence:

1. Claude calls list_all_fathom_meetings with a date filter to locate the specific discovery call and extract the recording_id.
2. Claude calls list_all_fathom_recording_transcript using that ID to pull the raw, timestamped speaker data.
3. Claude analyzes the massive text payload in memory, identifying technical keywords, and synthesizes the final technical spec document for the user.

2. Automated RevOps Webhook Provisioning

Revenue Operations teams constantly spin up new tracking workflows. Instead of navigating developer documentation, they can instruct Claude to build the pipeline.

"We just launched a new Zapier catcher for our Salesforce pipeline. Please create a Fathom webhook pointing to https://hooks.zapier.com/hooks/catch/123/abc. It needs to send data whenever a meeting finishes, and it absolutely must include the CRM matches and the summary."

Tool Execution Sequence:

1. Claude interprets the requirements and maps them to Fathom's strict webhook schema.
2. Claude calls create_a_fathom_webhook, passing the destination_url, setting triggered_for to meeting completions, and explicitly setting include_crm_matches and include_summary to true.
3. Claude returns the newly generated webhook id and secret to the user for their security records.

Security and Access Control

Giving an LLM direct access to your conversational intelligence platform requires strict governance. Truto MCP servers implement access control at the token level, ensuring agents only touch the data they are authorized to access.

• Method Filtering: You can restrict a Fathom MCP server to read-only operations by passing methods: ["read"] during creation. This allows Claude to pull transcripts and summaries while preventing it from deleting webhooks or altering configurations.
• Tag Filtering: Tools are grouped by functional area. You can pass tags: ["meetings"] to ensure the MCP server only exposes meeting and recording endpoints, completely hiding team directory tools from the model.
• API Token Authentication: By default, the MCP server URL is sufficient for connection. For zero-trust environments, you can enforce require_api_token_auth: true. This forces Claude (and the end user) to pass a valid Truto API token in the authorization header, tying every AI action back to a specific human identity.
• Automatic Expiration: You can provision ephemeral servers by setting an expires_at timestamp. Cloudflare KV handles the immediate revocation, and a Durable Object alarm ensures the underlying database records are scrubbed.

Final Thoughts on Connecting Fathom to Claude

Connecting Fathom to Claude via an MCP server transitions your AI from a static text generator into an active participant in your organization's meeting intelligence. While building a custom server forces your engineering team to manage deep JSON parsing, rate limit headers, and webhook flag validation, utilizing a managed architecture removes the integration burden entirely.

By leveraging Truto, you can generate a Fathom MCP server in seconds, hand the URL to Claude, and immediately begin orchestrating complex post-call workflows. The LLM gains native access to the data, and your engineers keep their focus on core product architecture.