Skip to main content
skill CX Codex

granola-webhooks-events — Claude Code skill: event-driven automation

granola-webhooks-events — a skill for building event-driven automations with Granola meeting data through Zapier. Process meeting events in real time and route them to custom handlers or external services.

MIT 1 installs ★ 2,935 updated 2026-10-29

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add jeremylongshore/tons-of-skills-marketplace --skill granola-webhooks-events -a claude-code
Open on GitHub

What granola-webhooks-events does

Granola pipes all events through Zapier, not direct webhooks. Two triggers are available: "Note Added to Granola Folder" fires when a note lands in a folder automatically, and "Note Shared to Zapier" requires manual sharing of individual notes. Each trigger sends meeting title, attendee names and emails, note content, and event timestamp.

You can filter events within Zapier—catch only external meetings by email domain, meetings containing action items (marked with checkboxes), or matches by keywords in the title. The skill provides working examples in Express.js and FastAPI that parse note content, extract tasks, and route events based on meeting type or attendee composition.

Requires a Granola Business plan (for Zapier access) and a Zapier account. Custom handlers should implement idempotency to skip duplicate processing if the same event retries.

What it helps with

  • forward meeting data to a CRM or issue tracker on each event
  • extract action items from note content and create tasks
  • filter events by external attendees or keywords in meeting title
  • prevent duplicate task creation when a webhook retries

Example prompts for the agent

  • Set up a webhook that sends every meeting with external attendees to a Slack channel
  • Build a Zapier filter to catch only meetings with 'demo' in the title
  • Write a handler that parses note content and creates Linear issues from action items

How to install granola-webhooks-events

1Skills CLI (Vercel)

npx skills add jeremylongshore/tons-of-skills-marketplace --skill granola-webhooks-events -a claude-code

2Manually: put the files in place

~/.claude/skills/granola-webhooks-events/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/granola-webhooks-events/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about granola-webhooks-events

How do I install granola-webhooks-events for Claude Code?

Run npx skills add jeremylongshore/tons-of-skills-marketplace --skill granola-webhooks-events -a claude-code, then see ~/.claude/skills/granola-webhooks-events/SKILL.md for usage details.

What does this skill teach?

It covers the Granola event model through Zapier, shows the structure of meeting payloads, and demonstrates how to filter, route, and process events in custom code.

What Granola plan is required?

You need a Business plan, since Zapier integration is only available at that tier.

Source text

SKILL.md · MIT
---
name: granola-webhooks-events
description: 'Build event-driven automations with Granola''s Zapier webhook triggers.

  Use when creating real-time notification systems, processing meeting events,

  or building custom integrations that react to Granola note creation.

  Trigger: "granola webhooks", "granola events", "granola triggers",

  "granola real-time", "granola event-driven".

  '
allowed-tools: Read, Write, Edit, Bash(curl:*), Bash(node:*), Bash(python3:*)
version: 1.13.0
license: MIT
author: Jeremy Longshore <[email protected]>
tags:
- saas
- granola
- webhooks
- automation
compatibility: Designed for Claude Code
---
# Granola Webhooks & Events

## Overview

Granola does not expose raw webhook endpoints. All event-driven automation flows through Zapier, which provides two trigger events. This skill covers the event model, webhook payload structure, event filtering, processing patterns, and building custom event handlers.

## Prerequisites

- Granola Business plan (for Zapier access)
- Zapier account (Free for basic Zaps, Paid for multi-step)
- Optional: custom webhook endpoint (Express.js, FastAPI, or serverless function)

## Instructions

### Step 1 — Understand the Event Model

Granola fires events through Zapier triggers, not direct webhooks. Two triggers are available:

| Trigger | When It Fires | Use Case |
|---------|--------------|----------|
| **Note Added to Granola Folder** | A note is placed in a specific folder (automatic) | Auto-route by meeting type |
| **Note Shared to Zapier** | You manually click Share > Zapier on a note | Selective sharing for important meetings |

### Step 2 — Webhook Payload Structure

When a Zapier trigger fires, Granola sends this data:

```json
{
  "title": "Sprint Planning — Q1 Week 12",
  "creator_name": "Sarah Chen",
  "creator_email": "[email protected]",
  "attendees": [
    {"name": "Sarah Chen", "email": "[email protected]"},
    {"name": "Mike Johnson", "email": "[email protected]"},
    {"name": "Alex Kim", "email": "[email protected]"}
  ],
  "calendar_event_title": "Sprint Planning",
  "calendar_event_datetime": "2026-03-22T10:00:00Z",
  "note_content": "## Summary\nDiscussed Q1 priorities...\n\n## Action Items\n- [ ] @sarah: Schedule design review..."
}
```

**Key fields for filtering and routing:**

- `attendees[].email` — detect internal vs. external meetings
- `calendar_event_title` — match meeting type patterns
- `note_content` — search for action items, decisions, keywords

### Step 3 — Event Filtering Patterns

Use Zapier Filter steps to route events:

**Filter: Only External Meetings**

```
Filter: attendees.email DOES NOT contain "@company.com"
(at least one attendee has a non-company email)
```

**Filter: Only Meetings with Action Items**

```
Filter: note_content contains "- [ ]"
```

**Filter: Only Sales Calls (by title keywords)**

```
Filter: calendar_event_title contains any of: "discovery", "demo", "sales", "prospect"
```

**Filter: Long Meetings Only (> 30 min)**

```
Use Zapier Code step to parse calendar_event_datetime and compare to note timestamp
```

### Step 4 — Build a Custom Webhook Handler

Forward Granola events from Zapier to your own endpoint:

```yaml
# Zapier configuration
Trigger: Granola — Note Added to Folder ("All Meetings")
Action: Webhooks by Zapier — POST
  URL: https://your-api.com/webhooks/granola
  Payload Type: JSON
  Data:
    title: "{{title}}"
    creator: "{{creator_email}}"
    attendees: "{{attendees}}"
    content: "{{note_content}}"
    datetime: "{{calendar_event_datetime}}"
    hmac: "{{your_webhook_secret}}"
```

**Express.js handler:**

```javascript
// webhook-handler.js
import express from 'express';
const app = express();
app.use(express.json());

app.post('/webhooks/granola', async (req, res) => {
  const { title, creator, attendees, content, datetime } = req.body;

  // Validate webhook (use HMAC or shared secret)
  // if (!verifyHmac(req)) return res.status(401).send('Unauthorized');

  console.log(`Meeting received: ${title} (${datetime})`);

  // Extract action items
  const actionItems = content
    .split('\n')
    .filter(line => line.match(/^- \[ \]/))
    .map(line => line.replace('- [ ] ', ''));

  // Route based on meeting type
  const isExternal = attendees.some(a => !a.email?.endsWith('@company.com'));

  if (isExternal) {
    await handleExternalMeeting({ title, attendees, content, actionItems });
  } else {
    await handleInternalMeeting({ title, content, actionItems });
  }

  res.status(200).json({ processed: true, actions: actionItems.length });
});

async function handleExternalMeeting({ title, attendees, content, actionItems }) {
  // CRM update, follow-up email draft, Slack #sales notification
  console.log(`External meeting: ${title}, ${actionItems.length} action items`);
}

async function handleInternalMeeting({ title, content, actionItems }) {
  // Linear tasks, Notion archive, Slack #team notification
  console.log(`Internal meeting: ${title}, ${actionItems.length} action items`);
}

app.listen(3000, () => console.log('Granola webhook handler running on :3000'));
```

**Python FastAPI handler:**

```python
from fastapi import FastAPI, Request
import re

app = FastAPI()

@app.post("/webhooks/granola")
async def handle_granola_event(request: Request):
    data = await request.json()
    title = data.get("title", "Untitled")
    content = data.get("content", "")
    attendees = data.get("attendees", [])

    # Extract action items
    actions = re.findall(r"- \[ \] (.+)", content)

    # Route by attendee type
    external = [a for a in attendees if not a.get("email", "").endswith("@company.com")]

    if external:
        # Process external meeting
        await process_external(title, actions, external)
    else:
        await process_internal(title, actions)

    return {"processed": True, "action_count": len(actions)}
```

### Step 5 — Processing Patterns

| Pattern | When to Use | Implementation |
|---------|------------|----------------|
| **Immediate** | Time-sensitive follow-ups | Direct Zapier actions, ~2 min latency |
| **Batch** | Reduce noise, aggregate | Queue to SQS/Redis, process every 15 min |
| **Conditional** | Route by meeting type | Zapier Paths or custom webhook with routing logic |
| **Idempotent** | Prevent duplicate processing | Store processed note IDs, skip duplicates |

### Step 6 — Error Handling and Retry

Zapier handles retries automatically for failed actions. For custom webhooks:

```javascript
// Implement idempotency
const processedNotes = new Set(); // Use Redis/DB in production

app.post('/webhooks/granola', async (req, res) => {
  const noteId = `${req.body.title}-${req.body.datetime}`;

  if (processedNotes.has(noteId)) {
    return res.status(200).json({ status: 'already_processed' });
  }

  processedNotes.add(noteId);
  // ... process the event
});
```

## Output

- Zapier triggers configured for target folders
- Event filtering routing meetings by type
- Custom webhook handler processing events
- Idempotency preventing duplicate processing

## Error Handling

| Error | Cause | Fix |
|-------|-------|-----|
| Trigger not firing | Wrong folder name in Zapier | Verify folder name matches exactly (case-sensitive) |
| Empty note_content | Note still processing when trigger fires | Add 2-minute Delay step before processing actions |
| Duplicate events | Zapier retry on timeout | Implement idempotency with note ID deduplication |
| Webhook timeout | Handler takes > 30s | Return 200 immediately, process async |
| Missing attendees | Calendar event has no attendee list | No fix — attendees come from calendar event data |

## Examples

For a synthetic `meeting.completed` event, record `event=evt-opaque-9; origin=approved; signature=pass; idempotency=once; destination=staging-actions; retention=none; rollback=consumer-disabled`. Do not retain the meeting title, attendees, notes, or payload.

## Resources

- [Zapier Granola Integration](https://zapier.com/apps/granola/integrations)
- [Zapier Webhooks Documentation](https://zapier.com/help/create/code-webhooks)
- [4 Ways to Automate Granola](https://zapier.com/blog/automate-granola/)

## Next Steps

Proceed to `granola-performance-tuning` for transcription quality optimization.

© Jeremy Longshore · MIT · jeremylongshore/tons-of-skills-marketplace

Similar skills

All skills for Automation and no-code: n8n, Zapier, Make →

From the same set139

The whole set →
docker-container-basics The docker-container-basics skill assists with basic Docker container work, from guided steps to configuration generation and checks. It activates on Docker-related requests. CX Codex +1 1installs gitlab-ci-basics gitlab-ci-basics — a skill for everyday GitLab CI work: it walks through steps, writes pipeline configs and checks them for common mistakes. Activates on its own when gitlab shows up in a prompt. CX Codex +1 1installs calendar-event-creator calendar-event-creator generates code and configs for calendar event operations in business workflows. Activates automatically when you prompt the agent about calendar setup. CX Codex +1 1installs email-parser This skill helps configure email parsing tasks, produce setup files and code, and check the result. It activates when a request mentions email parser. CX Codex +1 1installs granola-core-workflow-a granola-core-workflow-a configures meeting templates, chat recipes, and pre-call context inside Granola. Helps structure agendas and summaries for standups and customer calls. CX Codex +1 1installs monitoring-cross-chain-bridges monitoring-cross-chain-bridges tracks bridge TVL, volume, fees, and transfer status across networks. Use it to compare routes or inspect a cross-chain transaction. CX Codex +1 1installs vercel-cost-tuning vercel-cost-tuning reads Vercel billing and finds where money leaks: function time, bandwidth, middleware calls. Use it before the next invoice. CX Codex +1 1installs linear-cost-tuning linear-cost-tuning analyzes Linear API consumption, trims GraphQL query complexity, and shifts redundant polling loops to push webhooks. CX Codex +1 1installs

More in the catalog

Project sponsors

Companies that keep this analytics open