---
title: "Connect Granola to Claude: Access Note Transcripts and Folders"
slug: connect-granola-to-claude-access-note-transcripts-and-folders
date: 2026-08-13
author: Nidhi KN
categories: ["AI & Agents"]
excerpt: "Learn how to connect Granola to Claude using a managed MCP server. This step-by-step guide covers extracting meeting transcripts, automating webhooks, and tool calling."
tldr: "Connect Granola to Claude using Truto's managed MCP server. Execute AI workflows to extract meeting action items, summarize transcripts, and automate webhook provisioning using natural language."
canonical: https://truto.one/blog/connect-granola-to-claude-access-note-transcripts-and-folders/
---

# Connect Granola to Claude: Access Note Transcripts and Folders


If you need to connect Granola to Claude to automate meeting note extraction, summarize transcripts, or provision webhooks dynamically, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's tool calls and Granola'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 Granola to ChatGPT](https://truto.one/connect-granola-to-chatgpt-search-meeting-notes-and-manage-webhooks/) or explore our broader architectural overview on [connecting Granola to AI Agents](https://truto.one/connect-granola-to-ai-agents-automate-meeting-summaries-and-syncing/).

Giving a Large Language Model (LLM) read and write access to a platform like Granola—which houses highly sensitive meeting transcripts and organizational intelligence—is an engineering challenge. You have to handle API key authentication, map complex JSON schemas to MCP tool definitions, deal with Granola's specific cursor-based pagination, and enforce strict security boundaries. Every time Granola updates an endpoint, 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 Granola, connect it natively to Claude, and execute complex workflows using natural language.

> Want to give your AI agents secure, authenticated access to Granola and 100+ other SaaS APIs? Let's talk about managed MCP architecture.
>
> [Talk to us](https://cal.com/truto/partner-with-truto)

## The Engineering Reality of the Granola API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools over JSON-RPC 2.0, the reality of implementing it against Granola's APIs requires handling domain-specific quirks. You are dealing with massive text payloads, strict event-driven systems, and rate limits that can easily disrupt AI agent workflows.

If you decide to build a custom MCP server for Granola, you own the entire API lifecycle. Here are the specific challenges you will face:

### Transcript Payload Processing
Granola is built around meetings, which means the API frequently returns massive strings in the `transcript` field. If you expose the list endpoint without schema boundaries, Claude might attempt to pull down 50 full transcripts at once, instantly blowing out the model's context window. You must engineer your MCP layer to strictly separate the `list` operation (returning lightweight metadata like `id`, `title`, `owner`) from the `get` operation (returning the heavy `transcript` and `summary_text`). Truto handles this mapping automatically via its dynamic tool generation.

### Webhook Security and State Management
Granola allows you to programmatically create webhooks to listen for events (e.g., when a meeting note is generated). However, the `signing_secret` used to verify Granola webhooks is *only* returned in the response payload when the webhook is created. If your LLM creates a webhook but fails to capture or store that secret, the webhook is effectively useless for secure external systems. Furthermore, webhooks can be scoped to specific `folder_ids`, requiring a multi-step orchestration where the agent must first discover the folder ID before attempting to create the webhook.

### Rate Limit Normalization
A critical detail for AI agents querying APIs: **Truto does not retry, throttle, or apply backoff on rate limit errors.** When the Granola API returns an HTTP 429, Truto passes that error directly to the caller. However, Truto normalizes the upstream rate limit information into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF specification. Your MCP client implementation or agent framework is strictly responsible for interpreting these headers and executing retry/backoff logic. You cannot rely on the proxy to absorb these limits.

## Generating a Managed MCP Server for Granola

Rather than hand-coding tool definitions, Truto's MCP architecture derives tools dynamically from the integration's underlying schema and documentation records. A tool only appears in the MCP server if it has a corresponding documentation entry, ensuring only curated, well-described endpoints are exposed to the LLM.

You can generate this server via the Truto UI or programmatically via the REST API.

### Method 1: Via the Truto UI
This is the fastest method for internal tooling or quick agent deployment.

1. Navigate to the **Integrated Accounts** page in your Truto dashboard and select your connected Granola instance.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Select your desired configuration (e.g., filter to specific methods like `read`, or set an expiration date).
5. Copy the generated MCP server URL (e.g., `https://api.truto.one/mcp/a1b2c3d4e5f6...`).

### Method 2: Via the Truto API
For developers building multi-tenant AI products, you can generate MCP servers programmatically. This endpoint validates that tools are available, generates a cryptographically hashed token, stores it in distributed KV storage for fast lookup, and returns the ready-to-use URL.

**Endpoint:** `POST /integrated-account/:id/mcp`

```bash
curl -X POST "https://api.truto.one/integrated-account/<granola_account_id>/mcp" \
  -H "Authorization: Bearer <YOUR_TRUTO_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Claude Granola Access",
    "config": {
      "methods": ["read", "write"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'
```

The response contains the exact URL Claude needs to connect to the JSON-RPC 2.0 endpoint.

```json
{
  "id": "mcp-7890-granola",
  "name": "Claude Granola Access",
  "config": { "methods": ["read", "write"] },
  "expires_at": "2026-12-31T23:59:59Z",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}
```

## Connecting the MCP Server to Claude

Once you have the Truto MCP URL, you must configure Claude to use it as a remote connector. Because Truto's MCP servers are self-contained and stateless from the client's perspective, the URL includes the hashed token necessary for authentication.

### Method A: Via the Claude UI
If you are using Claude's web interface (Enterprise/Team plans) or ChatGPT's developer mode, you can plug the URL directly into the UI.

1. Open Claude and navigate to **Settings**.
2. Go to **Integrations** (or **Connectors** depending on your plan).
3. Click **Add MCP Server** or **Add custom connector**.
4. Name the connector "Granola".
5. Paste the Truto MCP URL (`https://api.truto.one/mcp/...`) and click **Add**.

Claude will immediately initiate a handshake, parse the capabilities, and load the Granola tools.

### Method B: Via Manual Config File (Claude Desktop)
If you are running Claude Desktop locally or orchestrating a custom agent environment, you use the standard `claude_desktop_config.json` file. Because Truto provides a remote HTTPS endpoint, you use the official `@modelcontextprotocol/server-sse` transport proxy to translate standard I/O into SSE/HTTP.

Locate your configuration file (usually at `~/Library/Application Support/Claude/claude_desktop_config.json` on macOS) and update it:

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

Restart Claude Desktop. The Granola tools will now be available in the chat interface via the attachment icon.

## Hero Tools for Granola

When Claude lists the available tools on the server, it receives dynamically generated snake_case tool definitions. Because query parameters and request body parameters share a flat input namespace in MCP, Truto automatically extracts and routes them to the correct upstream Granola payload. 

Here are 6 high-leverage tools available for Granola.

### list_all_granola_notes
Lists the authenticated user's Granola notes. It supports optional filters like date ranges and folder IDs. Truto automatically injects `limit` and `next_cursor` schemas to handle pagination. Crucially, this endpoint returns metadata (titles, attendees), but excludes the massive transcript payload.

> "Get all meeting notes from this week that belong to the 'Engineering Syncs' folder. Give me a bulleted list of the titles and their IDs."

### get_single_granola_note_by_id
Retrieves a single meeting note by its ID, pulling down the full `transcript`, `summary_text`, and `summary_markdown`. This is the primary tool Claude uses to analyze what actually happened in a meeting.

> "Pull the full transcript for the note with ID 8a9b-4cd2. Summarize the key technical decisions we made regarding the database migration."

### list_all_granola_folders
Lists the organizational folders within Granola (similar to how you [manage folders in Google Workspace](https://truto.one/connect-google-to-claude-manage-files-folders-workspace-data/)). Because notes and webhooks can be scoped to specific folders, this tool is usually the first step in an orchestration chain, allowing the model to look up a folder's ID by its human-readable `name`.

> "List out our Granola folders. I need to find the exact folder ID for 'Q4 Client Kickoffs'."

### list_all_granola_webhook_endpoints
Returns a list of all webhook endpoints currently configured and managed by the current API key. It returns the URLs, event subscriptions, and whether the webhook is currently enabled.

> "Audit our Granola webhooks. Are there any webhooks currently listening for 'note.created' events?"

### create_a_granola_webhook_endpoint
Provisions a new webhook endpoint to receive event deliveries at an external HTTPS URL. The model must provide the `url` and `scopes` (events). The response will include a `signing_secret` that is only displayed once.

> "Create a new webhook pointing to 'https://api.ourdomain.com/granola-ingest' listening for 'note.updated' events. Make sure to output the signing secret so I can save it."

### delete_a_granola_webhook_endpoint_by_id
Tears down an existing webhook endpoint immediately. Required parameter is the webhook `id`.

> "Delete the webhook endpoint with ID 1234-5678 to stop the data feed to the legacy staging server."

To view the complete inventory of available Granola tools and their exact JSON schema definitions, visit the [Granola integration page](https://truto.one/integrations/detail/granola).

## Workflows in Action

When Claude is connected to Granola via Truto's MCP server, it can execute complex, multi-step orchestration workflows entirely through natural language.

### 1. Extracting Action Items from a Client Kickoff

In this workflow, the user asks Claude to extract action items from a specific meeting. The agent must first find the meeting, then retrieve the unstructured transcript, and finally process it.

> "Find the meeting note from yesterday titled 'Acme Corp Kickoff' and generate a list of exact action items assigned to the engineering team."

1. Claude calls `list_all_granola_notes` passing yesterday's date as a filter.
2. Claude parses the JSON response, finding the note where `title` matches "Acme Corp Kickoff", and extracts its `id`.
3. Claude calls `get_single_granola_note_by_id` using that `id` to pull the full `transcript`.
4. Claude processes the raw transcript text in its context window and outputs a formatted markdown list of action items directly to the user.

```mermaid
sequenceDiagram
    participant User as User
    participant Claude as Claude Desktop
    participant MCP as Truto MCP Server
    participant Granola as Granola API

    User->>Claude: "Find yesterday's Acme Corp Kickoff..."
    Claude->>MCP: Call list_all_granola_notes
    MCP->>Granola: GET /notes?date=yesterday
    Granola-->>MCP: Returns notes metadata
    MCP-->>Claude: JSON array of notes
    Claude->>MCP: Call get_single_granola_note_by_id (id: 9a8b)
    MCP->>Granola: GET /notes/9a8b
    Granola-->>MCP: Returns note with full transcript
    MCP-->>Claude: JSON with transcript
    Claude-->>User: Markdown action items
```

### 2. Automating Folder-Scoped Webhook Provisioning

In this workflow, an IT admin instructs Claude to set up an event pipeline for a specific department.

> "I need to track new notes in the 'Enterprise Sales' folder. Create a webhook pointing to our internal [Slack-listener URL](https://truto.one/connect-slack-to-claude-manage-channels-threads-and-users/) that fires on new note creation for that folder."

1. Claude calls `list_all_granola_folders` to scan the organizational structure.
2. Claude matches the string "Enterprise Sales" to its corresponding `id`.
3. Claude calls `create_a_granola_webhook_endpoint`, passing the requested URL, the `note.created` event scope, and the `folder_ids` array.
4. Claude receives the response and presents the webhook ID and the critical `signing_secret` to the user.

```mermaid
flowchart TD
    A["User Prompt:<br>'Track new notes in Enterprise Sales...'"] --> B["Call list_all_granola_folders"]
    B --> C{"Folder 'Enterprise Sales' found?"}
    C -->|Yes| D["Extract folder_id"]
    C -->|No| E["Ask user for clarification"]
    D --> F["Call create_a_granola_webhook_endpoint<br>with folder_id & URL"]
    F --> G["Output webhook ID & signing_secret"]
```

## Security and Access Control

Exposing meeting transcripts and organizational data to an LLM requires strict security boundaries. Truto provides four key mechanisms to lock down your Granola MCP servers:

*   **Method Filtering (`config.methods`)**: You can restrict the MCP server to read-only operations. Setting `methods: ["read"]` ensures Claude can list and read notes, but cannot create or delete webhooks, protecting your infrastructure from AI hallucinations.
*   **Tag Filtering (`config.tags`)**: If your integration configuration assigns tags to resources, you can restrict the MCP server to specific resource groups (e.g., exposing only `notes` tools while hiding `webhooks` tools).
*   **Conditional Authentication (`require_api_token_auth`)**: By default, the cryptographically hashed MCP URL is the only authentication required. By setting this flag to `true`, the MCP client must also pass a valid Truto API token in the `Authorization` header. This prevents unauthorized access even if the MCP URL is leaked in logs or config files.
*   **Time-to-Live (`expires_at`)**: You can generate temporary MCP servers for short-lived agent sessions. The token is stored in distributed KV storage with a native TTL, and a background durable object alarm is scheduled to permanently purge the database record once it expires.

## Wrapping Up

Connecting Granola to Claude transforms an LLM from a passive chat interface into an active, [organizational intelligence agent](https://truto.one/connect-notion-to-claude-search-knowledge-and-structure-databases/). By leveraging Truto to auto-generate and manage the MCP server layer, you bypass the friction of handling API keys, mapping JSON schemas to tool definitions, and dealing with Granola's specific cursor pagination and rate limit schemas. Your engineering team can focus on designing better agent logic, rather than maintaining boilerplate integration code.