> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.runtype.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.runtype.com/_mcp/server.

# Granola integration

> Connect Granola so that Agents and Flows can read your meeting notes, transcripts, and folders.

Connect Granola so that an Agent or a Flow can list and search your meeting notes, read a
note's AI summary, pull its transcript, and list your folders. The Granola tools are read-only.
They can't create or change notes.

## Before you begin

You need the following:

* A Granola Business or Enterprise plan. Other Granola plans don't include API access.
* A Granola API key. In the Granola app, go to **Settings > Connectors > API keys** and create
  a key. Granola API keys start with `grn_`. Treat the key as a password.

## Connect Granola

To connect Granola in the dashboard, follow these steps:

1. Go to **Settings > Integrations**.
2. In the **Granola** card, paste your key in the **Granola API key** field.
3. Click **Connect Granola**. Runtype sends a test request to Granola with the key before it
   saves the key. If Granola accepts the key, the card shows a **Connected** message.

If Granola rejects the key, Runtype doesn't save it and shows Granola's reason. For the most
common reasons, see [Troubleshooting](#troubleshooting).

Each key that you save is a separate connection in the current organization. If you paste the
same key again, Runtype updates the existing connection. If you paste a different key, Runtype
adds a second connection and keeps the first one. The **Update key** button works the same
way.

## Connect with the API

To save a key with the API, send it to the Granola install endpoint. The Runtype API key that
you use needs the `INTEGRATIONS:WRITE` scope.

**`Connect Granola`**

```bash title="Connect Granola"
curl -X POST https://api.runtype.com/v1/integrations/granola/install \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"apiKey": "grn_YOUR_GRANOLA_KEY", "displayName": "Sales team"}'
```

Replace the following:

* `YOUR_API_KEY`: your Runtype API key.
* `grn_YOUR_GRANOLA_KEY`: your Granola API key.

The `displayName` field is optional. It names the connection, and it takes 1 to 100
characters. The response contains the connection's integration ID, and `created` is `false`
when the key updated an existing connection:

```json
{
  "integrationId": "intgr_YOUR_INTEGRATION_ID",
  "created": true
}
```

If Granola rejects the key, the request fails with status `422` and Granola's reason. If
Runtype can't reach Granola to test the key, the request fails with status `502`.

To list your Granola connections and their integration IDs, send a `GET` request with an API
key that has the `INTEGRATIONS:READ` scope:

**`List Granola connections`**

```bash title="List Granola connections"
curl "https://api.runtype.com/v1/integrations/connections?provider=granola" \
  -H "Authorization: Bearer YOUR_API_KEY"
```

## Add Granola tools to an Agent

Granola tools don't use your connection automatically. Each Granola tool must name its
credential in the Agent's `tools.toolConfigs`, keyed by the tool ID. A Granola tool without a
credential fails when the Agent calls it. This way, adding a Granola tool never gives an Agent
your organization's meeting notes by accident.

The agent tool picker in the dashboard doesn't list Granola tools. Add them to the Agent's
definition with the API or the SDK. For the SDK, see
[Manage Agents as code](/user-guide/agents/manage-agents-as-code).

Granola tool IDs use the form `builtin:granola:<tool>`. The following Agent tools fragment adds
two Granola tools that use one connection:

**`Agent tools`**

```json title="Agent tools"
{
  "tools": {
    "toolIds": [
      "builtin:granola:find_meeting_notes",
      "builtin:granola:get_meeting_note"
    ],
    "toolConfigs": {
      "builtin:granola:find_meeting_notes": {
        "integrationId": "intgr_YOUR_INTEGRATION_ID"
      },
      "builtin:granola:get_meeting_note": {
        "integrationId": "intgr_YOUR_INTEGRATION_ID"
      }
    }
  }
}
```

Replace `intgr_YOUR_INTEGRATION_ID` with the integration ID of your Granola connection.

### Use a secret instead of a connection

To use a key that isn't a connection, such as a separate key for each of your customers, store
the key as a secret and set `apiKey` to a reference to it:

**`Tool config with a secret`**

```json title="Tool config with a secret"
{
  "builtin:granola:list_meeting_notes": {
    "apiKey": "{{secret:GRANOLA_API_KEY}}"
  }
}
```

The value must be exactly one `{{secret:NAME}}` reference. Runtype rejects a literal `grn_`
key in `apiKey`. If a tool config has both `apiKey` and `integrationId`, the tool uses
`apiKey`. For how to create a secret, see
[Managing secrets](/user-guide/settings/managing-secrets).

## Available tools

The following table lists the Granola tools. In Agent instructions, refer to a tool by the name
that the model sees, such as `granola_find_meeting_notes`.

| Tool                     | What it does                                                                                                                                                                                                                           |
| ------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `list_meeting_notes`     | Lists notes, newest first. Filters by `created_after`, `created_before`, and `updated_after`, which take ISO 8601 timestamps. Returns 10 notes by default. Set `page_size` to return up to 30, and pass `cursor` to get the next page. |
| `get_meeting_note`       | Gets one note by `note_id`, with its AI summary, attendees, calendar event, and folders. Set `include_transcript` to `true` to add the transcript.                                                                                     |
| `get_meeting_transcript` | Gets only the transcript of one note, by `note_id`.                                                                                                                                                                                    |
| `list_folders`           | Lists the folders that the API key can read.                                                                                                                                                                                           |
| `find_meeting_notes`     | Finds notes whose title, owner, or attendee name or email contains `query`. Searches notes from the last 30 days, or from the time in `since`.                                                                                         |

Granola returns only notes that have an AI summary. A meeting that is in progress, or that
Granola hasn't processed yet, doesn't appear in lists, and `get_meeting_note` returns a
not-found error for it.

`find_meeting_notes` searches at most the 150 newest notes in its time window. If more notes
exist, the result has `truncated` set to `true` and a hint. To search older notes, set `since`
to a narrower window.

## Poll for new meeting notes

The **New Granola Meeting Notes** example Flow finds notes that were created or updated since
its last run, and writes a digest of their takeaways and action items. To create it, click
**Create flow** on the **Flows** page, click **Use an example**, and select it.

The Flow's first step, **Fetch Updated Meeting Notes**, has an empty `integrationId` in its
tool config. The dashboard can't set this value, so the Flow fails until you update the Flow
with the API and set `integrationId` to your connection's ID.

To run the Flow on a timer, attach it to a Schedule. The step reads the Schedule's
`{{_schedule.lastRunAt}}` variable to choose which notes to fetch. On the first run, it fetches
notes from the last 24 hours. For more information, see
[What are Schedules?](/user-guide/schedules/what-are-schedules).

## Troubleshooting

* **`Granola rejected the API key (401)`**: The key is wrong or revoked. Create a key in
  Granola, and connect again.
* **`Granola denied access (403)`**: The Granola plan doesn't include API access, or the key
  can't read the requested notes.
* **`Granola tools require an explicit credential in the tool config`**: The tool has no
  `toolConfigs` entry, or its `integrationId` is empty. Add an `integrationId` or an `apiKey`
  for that tool ID.
* **`No Granola connection matches integrationId`**: The integration ID doesn't belong to a
  connection in the current organization. List your connections, and copy the ID again.
* **`Granola returned no transcript for this note`**: The Granola plan or the key doesn't
  include transcripts.
* **`Granola rate limit reached (429)`**: Wait, and try again. For a scheduled Flow, run the
  Schedule less often.

## Next steps

* [Agent tools](/user-guide/agents/agent-tools): add and manage tools on an Agent.
* [Built-in tools](/user-guide/tools/built-in-tools): how `toolIds` and `toolConfigs` work.
* [Linear integration](/user-guide/integrations/linear-integration): create issues from meeting action items.