Complete Granola integration skill pack with 24 skills covering AI meeting notes, transcription, summaries, and meeting intelligence. Flagship tier vendor pack.

24 Skills

MIT License

Free Pricing

Installation

Open Claude Code and run this command:

/plugin install granola-pack@claude-code-plugins-plus

Use --global to install for all projects, or --project for current project only.

Skills (24)

granola-ci-integration SKILL.md View full skill →

Build automated pipelines from Granola meeting notes to GitHub Issues, Linear tasks, Slack notifications, and documentation updates using Zapier and GitHub Actions.

ReadWriteEditBash(gh:*)Bash(curl:*)

Granola CI Integration

Overview

Build automated pipelines that process Granola meeting notes into development artifacts: GitHub Issues from action items, Linear tasks with team routing, Slack digests for stakeholders, and meeting logs in your repository. Uses Zapier as the middleware between Granola and dev tools.

Prerequisites

Granola Business plan (for Zapier access)
Zapier account (Free for basic, Paid for multi-step Zaps)
GitHub repository with Actions enabled
Optional: Linear account, Slack workspace

Instructions

Step 1 — Set Up the Zapier Pipeline


# Pipeline: Granola → Zapier → GitHub + Slack + Linear

Trigger:
  App: Granola
  Event: Note Added to Granola Folder
  Folder: "Engineering"  # Only process engineering meetings

Step 2 — Parse Action Items with Zapier Code

Add a Code by Zapier step (JavaScript) to extract action items:


// Zapier Code Step — Extract action items from Granola note
const noteContent = inputData.note_content || '';
const meetingTitle = inputData.title || 'Untitled Meeting';
const meetingDate = inputData.calendar_event_datetime || new Date().toISOString();

// Extract action items: matches "- [ ] @person: task" or "- [ ] task"
const actionRegex = /- \[ \] @?(\w+):?\s+(.+)/g;
const actions = [];
let match;

while ((match = actionRegex.exec(noteContent)) !== null) {
  actions.push({
    assignee: match[1],
    task: match[2].trim(),
    meeting: meetingTitle,
    date: meetingDate.split('T')[0],
  });
}

// Extract decisions: lines starting with "- " under "## Decisions" or "## Key Decisions"
const decisionSection = noteContent.match(/## (?:Key )?Decisions\n([\s\S]*?)(?=\n##|$)/);
const decisions = decisionSection
  ? decisionSection[1].split('\n').filter(l => l.startsWith('- ')).map(l => l.replace('- ', ''))
  : [];

output = [{
  action_count: actions.length,
  actions: JSON.stringify(actions),
  decisions: decisions.join('; '),
  meeting_title: meetingTitle,
  meeting_date: meetingDate,
}];

Step 3 — Create GitHub Issues from Action Items


# For each action item, create a GitHub issue
Action:
  App: GitHub
  Event: Create Issue
  Repository: "your-org/your-repo"
  Title: "Meeting Action: {{task}} [{{date}}]"
  Body: |
    ## Context
    From meeting: **{{meeting}}** on {{date}}

    ## Task
    {{task}}

    ## Assigned To
    @{{assignee}}

    ---
    *Auto-created from Granola meeting notes*
  Labels: "meeting-action"
  Assignee: "{{assignee}}"  # Must match GitHub username

Step 4 — GitHub Actions Workflow for Meeting Logs

Create a workflow triggered by Zapier via repository_di


                
                  
                  
                  granola-common-errors
                  SKILL.md
                  View full skill →
                
                
                  Troubleshoot common Granola errors — audio capture failures, transcription issues, calendar sync problems, and integration errors.
                  
                      ReadWriteEditBash(pgrep:*)Bash(ps:*)Bash(system_profiler:*)Bash(defaults:*)
                    
                
                
                  Granola Common Errors
Overview
Diagnose and fix the most common Granola issues. Each error includes platform-specific symptoms, root causes, and step-by-step remediation. Granola captures audio from your device's system audio output (not via meeting platform APIs), so most issues trace back to audio permissions or device configuration.
Prerequisites

Granola installed (even if malfunctioning)
Terminal access for diagnostic commands (macOS) or PowerShell (Windows)
Admin/sudo access for permission changes

Instructions
Step 1 — Quick Diagnostic Check

# Is Granola running?
pgrep -l Granola

# What version?
defaults read /Applications/Granola.app/Contents/Info.plist CFBundleShortVersionString 2>/dev/null

# Audio devices available
system_profiler SPAudioDataType 2>/dev/null | grep -A2 "Default Input"

Step 2 — Match Your Symptom

Audio / Transcription Issues
"No Audio Captured" — Transcript is Empty
Root cause: Granola cannot hear system audio. On macOS, this is almost always a permissions issue.
macOS fix:

System Settings > Privacy & Security > Screen & System Audio Recording
Enable Granola (this grants system audio access despite the misleading name)
System Settings > Privacy & Security > Microphone > Enable Granola
Restart Granola after changing permissions (right-click menu bar icon > Restart)


# Nuclear option — reset Core Audio if devices are confused
sudo killall coreaudiod
# coreaudiod restarts automatically

Windows fix:

Settings > Privacy & Security > Microphone > Ensure Granola is enabled
Check that the correct audio device is set as default output
Right-click sound icon > Sound settings > ensure no audio enhancements are enabled

"Transcription Starts Then Stops" (4-5 Minutes In)
Root cause: Granola stops transcription when it detects no new audio for ~15 minutes, or when the computer sleeps.
Fix:

Keep your machine awake during meetings (disable sleep/screen lock)
Ensure meeting audio is playing through your default output device
Bluetooth devices can cause dropouts — try built-in speakers or wired headset
Right-click Granola icon > Restart Granola, then reopen the note

"Poor Transcription Quality"

Cause
Fix


Background noise
Use noise-cancelling headset or quiet room


Echo/reverb
Smaller room, soft furnishings


Crosstalk (multiple speakers)
One person speaks at a t
                
              
                
                  
                  
                  granola-core-workflow-a
                  SKILL.md
                  View full skill →
                
                
                  Meeting preparation and template setup in Granola — templates, recipes, and pre-meeting workflows.
                  
                      ReadWriteEdit
                    
                
                
                  Granola Core Workflow A: Meeting Preparation & Templates
Overview
Configure Granola templates (which structure the enhanced output) and recipes (repeatable Chat prompts) for consistent, high-quality meeting notes. Granola ships with 29 built-in templates and supports custom templates per workspace.
Prerequisites

Granola installed and authenticated
Calendar synced with upcoming meetings
At least one meeting captured (to understand the enhancement flow)

Instructions
Step 1 — Choose a Built-in Template
Click the Change template icon at the bottom of your notes before or during a meeting:

Template
Best For
Sections Generated


1-on-1
Manager/report check-ins
Check-in, Updates, Discussion, Action Items


Stand-up
Daily sync
Progress, Blockers, Priorities


Discovery Call
Sales prospecting
Budget, Authority, Need, Timeline (BANT)


Sprint Planning
Agile ceremonies
Sprint Goals, Velocity, Backlog, Risks


Weekly Team
Status meetings
Updates, Decisions, Action Items


Interview Debrief
Hiring loops
Candidate Assessment, Strengths, Concerns


Project Kick-Off
New initiatives
Goals, Scope, Timeline, RACI


Pipeline Review
Sales forecast
Deal Status, Next Steps, Risks


Design Crit
Creative review
Feedback, Changes Requested, Approvals


Templates tell the AI how to structure the enhanced output — a sales call produces different sections than a standup.
Step 2 — Create a Custom Template

Open Granola Settings > Templates
Click Create New Template
Define the structure using section headers:


## Customer Feedback Session

### Context
[Brief on the customer and their product usage]

### Key Feedback Themes
[Grouped by category: UX, Performance, Features, Support]

### Verbatim Quotes
[Direct customer quotes with timestamps]

### Severity Assessment
[Critical / High / Medium / Low for each issue]

### Action Items
[Owner, task, due date]

### Follow-Up Commitment
[What we promised the customer and by when]


Name it and optionally set auto-trigger conditions:


Calendar event title contains specific keywords (e.g., "feedback", "customer")
Attendee email domains (e.g., @customer.com)

Step 3 — Create Recipes for
                
              

                
                  
                  
                  granola-core-workflow-b
                  SKILL.md
                  View full skill →
                
                
                  Post-meeting note processing, sharing, and follow-up workflows in Granola.
                  
                      ReadWriteEdit
                    
                
                
                  Granola Core Workflow B: Post-Meeting Processing & Sharing
Overview
After a meeting ends, Granola processes your audio and produces a transcript. This skill covers the post-meeting workflow: enhancing notes, sharing to integrations, using Granola Chat for follow-up, and managing the People & Companies CRM.
Prerequisites

At least one meeting captured in Granola
Integrations connected (Slack, Notion, HubSpot — optional but recommended)
Templates configured (see granola-core-workflow-a)

Instructions
Step 1 — Enhance Notes
After the meeting ends (transcript processing takes 1-2 minutes):

Open the meeting note in Granola
Click Enhance Notes
Select your template (or accept the auto-matched one)
Granola merges your typed notes + full transcript into structured output

The Enhance step uses GPT-4o or Claude to:

Organize content under template sections
Extract action items with owners
Identify key decisions
Generate a concise summary
Pull verbatim quotes (if your template includes that section)

Step 2 — Review and Edit
Before sharing, review the enhanced notes:

[ ] Action items are correctly attributed to the right people
[ ] Decisions are accurately captured
[ ] No sensitive information in sections you plan to share externally
[ ] Summary reflects the actual meeting outcome (not hallucinated)

Edit directly in the Granola editor — changes are saved instantly.
Step 3 — Share to Integrations
Slack (native integration):

Click Share > Slack
Select the target channel (or use auto-post to a configured folder's default channel)
Granola posts a concise summary with action items
Recipients can click through to the full note or use AI Chat in Slack for questions

Notion (native integration):

Click Share > Notion
Notes are saved as rows in a dedicated Notion database (created on first connect)
Each note becomes a database entry with title, date, participants, and content
Currently one-at-a-time sharing (for auto-sync, use Zapier — see granola-sdk-patterns)

HubSpot / Attio / Affinity (native CRM integration):

Click Share > HubSpot (or Attio/Affinity)
Granola auto-matches the note to the correct Contact, Company, or Deal based on attendee emails
Review the match suggestion and confirm
Meeting summary appears on the CRM record timeline

> Note: Native HubSpot integration does not auto-create new contacts
                
              

                
                  
                  
                  granola-cost-tuning
                  SKILL.md
                  View full skill →
                
                
                  Optimize Granola costs — plan selection, ROI calculation, seat management, and billing strategies for individuals and teams.
                  
                      ReadWriteEdit
                    
                
                
                  Granola Cost Tuning
Overview
Optimize Granola spending with plan selection, ROI analysis, and seat management. Granola pricing is simple: $0 (Basic), $14/user/month (Business), or $35+/user/month (Enterprise). No per-minute charges, no meeting count limits on paid plans, and no hardware device requirements.
Prerequisites

Current Granola plan and usage data (Settings > Account)
Team size and meeting frequency for team deployments
Budget constraints identified

Instructions
Step 1 — Calculate Individual ROI

Time savings calculation:
  Meetings per week:           [____]
  Average meeting duration:    [____] min
  Time spent on manual notes:  ~15-20 min per meeting
  Time with Granola:           ~2-3 min per meeting (review + edit)
  Time saved per meeting:      ~15 min

Monthly calculation:
  Meetings per month:          20 (example)
  Time saved:                  20 * 15 min = 300 min = 5 hours
  Your hourly rate:            $60 (example)
  Monthly value of time saved: 5 * $60 = $300

  Granola Business cost:       $14/month
  ROI:                         $300 / $14 = 21x return
  Break-even:                  0.93 meetings/month (~1 meeting)

At $14/month, Granola pays for itself if it saves you just one meeting's worth of note-taking per month.
Step 2 — Select the Right Plan

Your Situation
Recommended Plan
Monthly Cost


Trying Granola (< 25 meetings ever)
Basic (Free)
$0


Individual, needs integrations
Business
$14


Team of 2-5, shared folders
Business
$14/user


Team of 5-20, needs admin controls
Business
$14/user


20+ users, SSO/SCIM required
Enterprise
$35+/user


Regulated industry (SOC 2 audit)
Enterprise
$35+/user


Just need transcription, no integrations
Basic (while it lasts)
$0


Cost comparison with competitors (per user/month):

Tool
Price
Key Difference


Granola Business
$14
No bot, system audio capture


Otter.ai Pro
$16.99
Bot joins meeting


Fireflies.ai Pro
$18
Bot joins meeting


tl;dv Pro
$20
Bot joins meeting


Fathom
Free (basic)
Limited features


Granola's differentiator: no bot joins your meeting, which means no "Granola is recording" banner visible to participants.
Step 3 — Optimize Team Costs
Seat audit (monthly):

Settings > Team — r
                
              

                
                  
                  
                  granola-data-handling
                  SKILL.md
                  View full skill →
                
                
                  Manage Granola data export, retention policies, GDPR/CCPA compliance, and archival workflows.
                  
                      ReadWriteEditBash(python3:*)Bash(curl:*)
                    
                
                
                  Granola Data Handling
Overview
Manage data lifecycle for Granola meeting data: export, retention policies, GDPR/CCPA compliance, and long-term archival. Covers individual data rights, organizational policies, and automated archival workflows.
Prerequisites

Granola admin access (for retention policies)
Understanding of applicable regulations (GDPR, CCPA, SOC 2)
Export destination prepared (cloud storage, Notion, local)

Instructions
Step 1 — Understand Data Types and Sensitivity

Data Type
What It Contains
Sensitivity
Storage


Meeting Notes
Your typed notes + AI-enhanced output
Medium
Granola cloud + local cache


Transcripts
Full text transcription of audio
High (verbatim speech)
Granola cloud + local cache


Audio
Raw meeting audio
Critical
Deleted after transcription (not stored)


Attendee Info
Names, emails from calendar events
PII
Granola cloud (People & Companies)


Calendar Metadata
Event titles, times, attendee lists
Low-Medium
Synced from Google/Outlook


Key fact: Granola does not store raw audio after transcription. This is a significant privacy advantage — there is no audio file to leak, export, or subpoena.
Step 2 — Export Meeting Data
Individual note export:

Open the meeting note in Granola
Click the ... menu > Copy (copies as Markdown)
Paste into your target: Notion, Google Doc, text editor

Important limitation: Granola does not currently support bulk export, PDF export, or structured file download (JSON/CSV). The available options are:

Copy individual notes as text/Markdown
Share to Notion (one note at a time via native integration)
Share to Slack (one note at a time)
Enterprise API (read-only access to workspace notes)

Workaround for bulk access — local cache:

#!/usr/bin/env python3
"""Export Granola meetings from local cache to Markdown files."""
import json
from pathlib import Path
from datetime import datetime

CACHE_PATH = Path.home() / "Library/Application Support/Granola/cache-v3.json"
OUTPUT_DIR = Path.home() / "Desktop/granola-export"
OUTPUT_DIR.mkdir(exist_ok=True)

def export_from_cache():
    raw = json.loads(CACHE_PATH.read_text())
    state = json.loads(raw) if isinstance(raw, str) else raw
    data = state.get("state", state)
    docs = data.get("document

                

              

                
                  
                  
                  granola-debug-bundle
                  SKILL.md
                  View full skill →
                
                
                  Create diagnostic bundles for Granola support requests.
                  
                      ReadWriteEditBash(system_profiler:*)Bash(sw_vers:*)Bash(defaults:*)Bash(curl:*)Bash(pgrep:*)Bash(ls:*)Bash(zip:*)Bash(mkdir:*)Bash(uname:*)Grep
                    
                
                
                  Granola Debug Bundle
Current State
!sw_vers 2>/dev/null || uname -a
!defaults read /Applications/Granola.app/Contents/Info.plist CFBundleShortVersionString 2>/dev/null || echo 'Granola version: check Menu > About'
Overview
Collect diagnostic information for Granola support. Produces a zip bundle with system info, audio configuration, network connectivity, and app state — without exposing meeting content, transcripts, or API keys.
Prerequisites

Terminal access (macOS Terminal or Windows PowerShell)
Granola installed (even if malfunctioning)
Internet access for network diagnostics

Instructions
Step 1 — Create Debug Directory

set -euo pipefail
DEBUG_DIR="$HOME/Desktop/granola-debug-$(date +%Y%m%d-%H%M%S)"
mkdir -p "$DEBUG_DIR"
echo "Debug directory: $DEBUG_DIR"

Step 2 — Collect System Information
macOS:

set -euo pipefail
cd "$DEBUG_DIR"

# OS and hardware
sw_vers > system-info.txt
uname -a >> system-info.txt
sysctl -n hw.memsize | awk '{printf "RAM: %.0f GB\n", $1/1073741824}' >> system-info.txt

# Granola version
defaults read /Applications/Granola.app/Contents/Info.plist CFBundleShortVersionString >> system-info.txt 2>/dev/null || echo "Version: not found" >> system-info.txt

# Granola process status
pgrep -l Granola >> system-info.txt 2>/dev/null || echo "Granola: NOT RUNNING" >> system-info.txt

# Audio configuration (critical for transcription issues)
system_profiler SPAudioDataType > audio-config.txt 2>/dev/null

Windows (PowerShell):

$dir = "$env:USERPROFILE\Desktop\granola-debug-$(Get-Date -Format 'yyyyMMdd-HHmmss')"
New-Item -ItemType Directory -Path $dir

# System info
Get-CimInstance Win32_OperatingSystem | Select Caption, Version > "$dir\system-info.txt"
Get-Process Granola -ErrorAction SilentlyContinue >> "$dir\system-info.txt"

# Audio devices
Get-CimInstance Win32_SoundDevice | Select Name, Status > "$dir\audio-config.txt"

Step 3 — Check Permissions (macOS)

set -euo pipefail
cd "$DEBUG_DIR"
echo "=== Permission Check ===" > permissions.txt

# Check if Granola has microphone access
sqlite3 ~/Library/Application\ Support/com.apple.TCC/TCC.db \
  "SELECT service, allowed FROM access WHERE client='ai.granola.app';" >> permissions.txt 2>/dev/null \
  || echo "Cannot read TCC database (expected on macOS 14+). Check manually:" >> permissions.txt

echo "" >> permissions.txt
echo "Manual verification required:&q

                

              

                
                  
                  
                  granola-deploy-integration
                  SKILL.md
                  View full skill →
                
                
                  Deploy Granola native integrations — Slack, Notion, HubSpot, Attio, Affinity, and Zapier.
                  
                      ReadWriteEdit
                    
                
                
                  Granola Deploy Integration
Overview
Granola offers native integrations with Slack, Notion, HubSpot, Attio, and Affinity plus Zapier for 8,000+ additional apps. This skill covers setup, configuration, and testing for each platform. Business plan ($14/user/mo) required for all integrations.
Prerequisites

Granola Business or Enterprise plan
Admin access to target platforms (Slack workspace admin, Notion workspace, CRM portal)
Integration requirements documented per team

Instructions
Integration 1 — Slack
Setup:

Settings (avatar bottom-left) > Integrations > Slack > Connect
Authorize Granola in your Slack workspace
Configure default channels per Granola folder:


Granola Folder
Slack Channel
Auto-Post


Sales Calls
#sales-notes
On


Engineering
#eng-meetings
On


All Hands
#general
On


1-on-1s
(none)
Off


How it works:

After enhancing notes, click Share > Slack > select channel
With auto-post enabled on a folder, every note in that folder posts automatically
Slack messages include a concise summary + action items
Recipients can ask follow-up questions via the AI Chat button in Slack

Slack Huddles support:
Granola captures Slack Huddle audio the same way as Zoom/Meet — via system audio. Just ensure Granola is running and the huddle is on a synced calendar (or manually start recording).
Integration 2 — Notion
Setup:

Settings > Integrations > Notion > Connect
Authorize Granola in your Notion workspace
Granola creates a dedicated database on first connection

How it works:

Click Share > Notion to send a note
Each note becomes a row in Granola's Notion database with:
Title, Date, Participants, Content (full enhanced note)
You cannot choose a custom database — Granola creates its own
Sharing is one-at-a-time (not automatic)

Auto-sync workaround (via Zapier):

Trigger: Granola — Note Added to Folder ("All Meetings")
Action: Notion — Create Database Item
  Database: Your Custom Database
  Title: "{{title}}"
  Date: "{{calendar_event_datetime}}"
  Content: "{{note_content}}"

This bypasses the one-at-a-time limitation and lets you target any Notion database.
Integration 3 — HubSpot (Native CRM)
                
              

                
                  
                  
                  granola-enterprise-rbac
                  SKILL.md
                  View full skill →
                
                
                  Configure enterprise role-based access control for Granola workspaces.
                  
                      ReadWriteEdit
                    
                
                
                  Granola Enterprise RBAC
Overview
Configure role-based access control for Granola with SSO group mapping, per-workspace permissions, sharing policies, and audit logging. Granola's role hierarchy controls who can create, share, and manage meeting notes across the organization.
Prerequisites

Granola Enterprise plan ($35+/user/month)
Organization admin access
SSO configured (Okta, Azure AD, or Google Workspace)
SCIM provisioning enabled (recommended for automated role assignment)

Instructions
Step 1 — Understand the Role Hierarchy

Organization Owner (1-2 people)
  │   Full control: billing, SSO, org settings, all workspaces
  │
  ├── Workspace Admin (per department)
  │     Manage workspace: members, integrations, settings
  │     All member capabilities
  │
  ├── Team Lead
  │     View team analytics, manage folder structure
  │     All member capabilities
  │
  ├── Member (default role)
  │     Create notes, share internally, use integrations
  │
  ├── Viewer
  │     Read-only access to shared notes
  │     Cannot create or record meetings
  │
  └── Guest (external)
      Single workspace access, read-only
      Time-limited (30-day default expiration)

Step 2 — Permission Matrix

Permission
Owner
WS Admin
Lead
Member
Viewer
Guest


Record meetings
Yes
Yes
Yes
Yes
No
No


Create notes
Yes
Yes
Yes
Yes
No
No


Share internally
Yes
Yes
Yes
Yes
No
No


Share externally
Yes
Yes
Policy
Policy
No
No


View shared notes
Yes
Yes
Yes
Yes
Yes
Yes


Manage integrations
Yes
Yes
No
No
No
No


Manage members
Yes
Yes
No
No
No
No


View analytics
Yes
Yes
Yes
No
No
No


Configure retention
Yes
Yes
No
No
No
No


Manage billing
Yes
No
No
No
No
No


Configure SSO/SCIM
Yes
No
No
No
No
No


Step 3 — Map SSO Groups to Roles
Configure in Organization Settings > Security > SSO > Group Mapping:

SSO Group (IdP)
Granola Workspace
Granola Role


engineering-all<
                
              
                
                  
                  
                  granola-hello-world
                  SKILL.md
                  View full skill →
                
                
                  Capture your first meeting with Granola and review AI-enhanced notes.
                  
                      ReadWriteEditBash(pgrep:*)Bash(open:*)
                    
                
                
                  Granola Hello World
Overview
Capture your first meeting with Granola and learn the three-phase workflow: live notepad, Enhance Notes, and Granola Chat. Granola captures audio from your device (no bot joins), transcribes it, and merges your typed notes with the full transcript to produce structured output.
Prerequisites

Completed granola-install-auth setup
Calendar connected with an upcoming meeting (or create a test one)
Microphone + Screen & System Audio permissions granted

Instructions
Step 1 — Start a Meeting

Join any video call — Zoom, Google Meet, Teams, Slack Huddle, or WebEx
Granola auto-detects the meeting from your synced calendar
A floating notepad appears showing the meeting title and attendees
If auto-detection fails, click the Granola icon in your menu bar and select Start Recording

Step 2 — Take Live Notes in the Notepad
During the meeting, type rough notes directly in the Granola notepad:

- discussed Q1 priorities
- sarah owns onboarding revamp
- need design review by thursday
- budget question - follow up with finance

These notes give Granola context. The AI uses your notes plus the full transcript to produce better output — you do not need to capture everything.
Step 3 — End Meeting and Enhance

End your video call
Granola processes the transcript (typically 1-2 minutes)
Click Enhance Notes — Granola merges your notes with the transcript
Select a template (or use the default) to structure the output

Step 4 — Review Enhanced Output
Granola produces structured notes based on your template:

# Team Standup — March 22, 2026

## Summary
Discussed Q1 priorities. Agreed to focus on customer onboarding
improvements. Sarah will lead the initiative with a design review
by Thursday.

## Key Decisions
- Onboarding revamp is the top priority for Q1
- Budget approval needed from Finance before expanding scope

## Action Items
- [ ] @sarah: Schedule design review meeting by Thursday
- [ ] @mike: Create onboarding improvement tickets in Linear
- [ ] @alex: Follow up with Finance on budget allocation

## Participants
Sarah Chen, Mike Johnson, Alex Kim

Step 5 — Use Granola Chat
After enhancement, use the chat panel to ask questions about the meeting:

"List my action items"
"Draft a follow-up email to the attendees"
"What were the open questions?"
"Summarize the budget discussion"

Granola Chat has full context of the transcript and your notes.
Step 6 — Use Recipes for Repeatable Prompts
Type / in Granola Chat to invoke Recipes — saved prompts for common tasks:

<
                
              

                
                  
                  
                  granola-incident-runbook
                  SKILL.md
                  View full skill →
                
                
                  Incident response procedures for Granola meeting capture failures and outages.
                  
                      ReadWriteEditBash(curl:*)Bash(pgrep:*)Bash(pkill:*)Bash(open:*)
                    
                
                
                  Granola Incident Runbook
Overview
Standard operating procedures for Granola incidents — from individual recording failures to organization-wide outages. Covers triage, remediation, communication, escalation, and post-incident review. Designed for IT admins, team leads, and individual users.
Prerequisites

Granola admin access (for org-level incidents)
Bookmark status.granola.ai for service status
Internal communication channel identified (#granola-support or similar)

Instructions
Step 1 — Triage: Assess Severity

# Quick status check
curl -s "https://status.granola.ai/api/v2/status.json" 2>/dev/null | python3 -c "
import json, sys
try:
    data = json.load(sys.stdin)
    indicator = data.get('status', {}).get('indicator', 'unknown')
    desc = data.get('status', {}).get('description', 'Unknown')
    print(f'Status: {indicator} — {desc}')
except:
    print('Cannot reach status page — possible network issue')
" || echo "Network error — check internet connection"


Severity
Description
Response Time
Example


P1 Critical
Org-wide outage, data loss risk
Immediate
Granola service down, no one can record


P2 High
Multiple users affected
< 1 hour
Recording fails for a team, sync broken


P3 Medium
Single user issue
< 4 hours
One person's transcription stopped


P4 Low
Minor issue, workaround exists
< 24 hours
UI glitch, slow processing


Scope assessment questions:

Is it just you, or are others affected too? → Ask in #granola-support
Is status.granola.ai showing an incident? → P1/P2 if yes
Was it working earlier today? → Recent change (OS update, permissions) likely
Which platform? (Zoom/Meet/Teams) → Platform-specific audio routing

Step 2 — Remediation by Incident Type

Incident: "Meeting Not Recording"
Severity: P3 (single user) or P2 (team-wide)
Immediate actions:

Click Granola menu bar icon > Start Recording (manual override)
If manual start fails:


Check that the meeting has audio playing
Verify Granola is running: pgrep -l Granola
Restart: right-click menu bar icon > Restart Granola

Root cause investigation:

[ ] Calendar event has a
                
              

                
                  
                  
                  granola-install-auth
                  SKILL.md
                  View full skill →
                
                
                  Install and configure Granola AI meeting notes with calendar and audio permissions.
                  
                      ReadWriteEditBash(brew:*)Bash(open:*)Bash(pgrep:*)Bash(defaults:*)Bash(ls:*)
                    
                
                
                  Granola Install & Auth
Overview
Install Granola, the AI notepad that captures meeting audio directly from your device (no bot joins the call), transcribes with GPT-4o/Claude, and produces structured notes with action items. Supports Zoom, Google Meet, Teams, Slack Huddles, and WebEx.
Prerequisites

macOS 12+ or Windows 10+ (iOS/Android for mobile)
Google Calendar or Microsoft Outlook account
Active internet connection for initial auth

Instructions
Step 1 — Download and Install

# macOS via Homebrew
brew install --cask granola

# Or download directly
open "https://www.granola.ai/download"

Windows: download the installer from granola.ai/download and run the .exe.
Step 2 — Create Account and Authenticate

Launch Granola
Click Sign up — authenticate with Google or Microsoft
Granola uses WorkOS for SSO; enterprise users may see their IdP login (Okta, Azure AD)

Step 3 — Grant System Permissions
macOS (critical — both required):

System Settings > Privacy & Security > Microphone
  → Enable Granola

System Settings > Privacy & Security > Screen & System Audio Recording
  → Enable Granola

The Screen Recording permission is required because macOS bundles system audio capture under that category — Granola does not record your screen.
Windows:
Microphone permissions are granted automatically. Confirm at:

Settings > Privacy & Security > Microphone → Granola enabled

Step 4 — Connect Calendar

Granola Settings (avatar bottom-left) > Calendar
Connect Google Calendar or Microsoft Outlook
Select which calendars to sync (personal, work, shared)
Granola detects meetings from synced calendars with video/conference links

Step 5 — Verify Audio Capture

# macOS — confirm Granola is running
pgrep -l Granola

# Check installed version
defaults read /Applications/Granola.app/Contents/Info.plist CFBundleShortVersionString 2>/dev/null || echo "Check Granola > About"

Join or start any meeting (Zoom, Meet, Teams). Granola shows a floating notepad when it detects a calendar event with a conferencing link. Verify the live transcription indicator appears.
Step 6 — Configure Preferences

Setting
Location
Recommended


Auto-start with calendar
Preferences > General
On


Default template
Preferences > Templates
Match your meeting type


AI model
Uses GPT-4o/Claude
No c
                
              
                
                  
                  
                  granola-local-dev-loop
                  SKILL.md
                  View full skill →
                
                
                  Access Granola meeting data programmatically for developer workflows.
                  
                      ReadWriteEditBash(curl:*)Bash(jq:*)Bash(python3:*)Grep
                    
                
                
                  Granola Local Dev Loop
Overview
Access Granola meeting data programmatically using three methods: the local cache file (zero-auth, offline), the MCP server (AI agent integration), or the Enterprise API (workspace-wide access). Build developer workflows that turn meeting outcomes into code tasks, documentation, and project artifacts.
Prerequisites

Granola installed with meetings captured
Node.js 18+ or Python 3.10+ for scripts
For MCP: Claude Code, Cursor, or another MCP-compatible client
For Enterprise API: Business/Enterprise plan + API key

Instructions
Step 1 — Read the Local Cache (Zero Auth)
Granola stores meeting data in a local JSON cache file:

# macOS cache location
CACHE_FILE="$HOME/Library/Application Support/Granola/cache-v3.json"

# Check if cache exists and get size
ls -lh "$CACHE_FILE"

The cache has a double-JSON structure (JSON string inside JSON):

#!/usr/bin/env python3
"""Extract meetings from Granola local cache."""
import json
from pathlib import Path

CACHE_PATH = Path.home() / "Library/Application Support/Granola/cache-v3.json"

def load_granola_cache():
    raw = json.loads(CACHE_PATH.read_text())
    # Cache contains a JSON string that needs secondary parsing
    state = json.loads(raw) if isinstance(raw, str) else raw
    data = state.get("state", state)
    return {
        "documents": data.get("documents", {}),
        "transcripts": data.get("transcripts", {}),
        "meetings_metadata": data.get("meetingsMetadata", {}),
    }

cache = load_granola_cache()
docs = cache["documents"]
print(f"Found {len(docs)} meetings in local cache")

# List recent meetings
for doc_id, doc in sorted(docs.items(),
                          key=lambda x: x[1].get("updated_at", ""),
                          reverse=True)[:10]:
    print(f"  {doc.get('title', 'Untitled')} — {doc.get('updated_at', 'N/A')}")

Step 2 — Set Up Granola MCP Server
Granola's official MCP integration connects meeting context to AI tools:

// claude_desktop_config.json or .mcp.json
{
  "mcpServers": {
    "granola": {
      "command": "npx",
      "args": ["-y", "granola-mcp-server"]
    }
  }
}

With MCP connected, Claude Code and Cursor can:

Search across all your meetings by topic or person
Pull context from specific meetings into coding sessions
Create tickets based on discussed bugs or features
Scaffold code based on architectural decisions from meetings

Community MCP server
                
              

                
                  
                  
                  granola-migration-deep-dive
                  SKILL.md
                  View full skill →
                
                
                  Migrate to Granola from Otter.
                  
                      ReadWriteEditBash(python3:*)
                    
                
                
                  Granola Migration Deep Dive
Overview
Comprehensive guide for migrating to Granola from competing meeting note tools. Covers source-specific export procedures, historical data preservation, parallel-run strategy, team transition, and cutover execution. Granola's key differentiator — no bot joins meetings — means the migration also changes the user experience fundamentally.
Prerequisites

Access to source tool with export capability
Granola workspace configured (see granola-install-auth)
Migration timeline agreed with stakeholders
Budget approved for Granola licenses

Instructions
Step 1 — Assess Migration Scope

## Migration Assessment

Source tool: [Otter.ai / Fireflies / Fathom / tl;dv / Manual / Other]
Total meetings in source: [____]
Date range: [____] to [____]
Active users to migrate: [____]
Integrations to recreate: [Slack, Notion, CRM, etc.]
Historical data priority: [Archive all / Selective / Fresh start]
Target cutover date: [____]
Parallel run duration: [1 week / 2 weeks]

Step 2 — Source-Specific Export
From Otter.ai

Export format: TXT, SRT (subtitles), PDF
Bulk export: Otter Pro/Business: Settings > Export > Download All
Limitations: Free plan only exports individual notes
Key data: Transcripts with timestamps, speaker labels, action items

From Fireflies.ai

Export format: TXT, JSON, PDF, SRT
Bulk export: Admin > Data Management > Export
Limitations: Custom fields may not export
Key data: Transcripts, AI summaries, custom topics

From Fathom

Export format: Markdown, CSV, video clips
Bulk export: Settings > Data > Export All
Limitations: Video clips don't transfer
Key data: Meeting summaries, action items, highlights

From tl;dv

Export format: TXT, video recordings
Bulk export: Settings > Data Export
Limitations: AI highlights may not transfer
Key data: Transcripts, timestamps, meeting recordings

From Manual Notes (Google Docs, Notion, Confluence)

Already in accessible format
No export needed — archive in place
Focus on establishing the Granola workflow going forward

Step 3 — Choose Migration Strategy

Strategy
When to Use
Data Handling
Effort


Fresh Start
<100 historical meetings, or meetings have low reference value
Ar
                
              
                
                  
                  
                  granola-multi-env-setup
                  SKILL.md
                  View full skill →
                
                
                  Configure Granola across multiple workspaces and teams with SSO/SCIM provisioning.
                  
                      ReadWriteEdit
                    
                
                
                  Granola Multi-Environment Setup
Overview
Configure Granola for multi-workspace enterprise deployments with SSO-based user provisioning, per-workspace integration configuration, and compliance controls. Each workspace operates as an isolated unit with its own folders, integrations, sharing rules, and retention policies.
Prerequisites

Granola Enterprise plan ($35+/user/month)
Organization admin access in Granola
Identity provider configured (Okta, Azure AD, or Google Workspace)
Team structure and workspace plan documented

Instructions
Step 1 — Plan Workspace Structure
Map your organization to Granola workspaces:

Workspace
Owner
Members
Purpose


Engineering
VP Engineering
All engineers
Sprint planning, architecture, standups


Sales
VP Sales
Sales team + SDRs
Discovery calls, demos, pipeline reviews


Product
Head of Product
PMs + designers
Customer feedback, design reviews, PRDs


Customer Success
CS Lead
CS managers
Onboarding calls, QBRs, escalations


HR
HR Director
HR team
Interviews, 1-on-1s, performance reviews


Executive
CEO
C-suite
Board meetings, strategy, M&A


Step 2 — Create Workspaces

Navigate to Organization Settings > Workspaces
For each workspace:


Name: Department name (e.g., "Engineering")
Description: Purpose and scope
Owner: Department lead (Workspace Admin role)
Privacy: Private (members only) or Internal (org-visible)
Default sharing: Private for new notes

Step 3 — Configure SSO and User Provisioning
SSO Setup (Okta example):

Organization Settings > Security > SSO
Choose SAML 2.0 or OIDC
Configure in your IdP:


Entity ID: https://app.granola.ai/sso/{org-slug}
ACS URL: https://app.granola.ai/sso/callback
Name ID: Email address


Test with a pilot user before enforcing org-wide

SCIM Provisioning:

Organization Settings > Security > SCIM
Generate SCIM token
Configure in your IdP:


SCIM endpoint: https://api.granola.ai/scim/v2/{org-id}
Bearer token: Generated in step 2


Map IdP groups to Granola workspaces and roles:


IdP G
                
              
                
                  
                  
                  granola-observability
                  SKILL.md
                  View full skill →
                
                
                  Monitor Granola adoption, meeting analytics, and build custom dashboards.
                  
                      ReadWriteEditBash(curl:*)Bash(python3:*)
                    
                
                
                  Granola Observability
Overview
Monitor Granola usage, track meeting patterns, and build analytics dashboards. Granola Enterprise includes a usage analytics dashboard. For deeper insights, build custom pipelines using Zapier to stream meeting metadata to BigQuery, Metabase, or other analytics platforms.
Prerequisites

Granola Business or Enterprise plan
Admin access for organization-level analytics
Optional: BigQuery/Metabase for custom dashboards, Zapier for data pipeline

Instructions
Step 1 — Built-in Analytics (Enterprise)
Access the analytics dashboard at Settings > Analytics (Enterprise plan):

Metric
What It Shows


Total meetings captured
Meeting volume over time


Active users
Users who recorded meetings this period


Hours captured
Total meeting hours transcribed


Notes shared
How often notes are distributed


Action items created
Extracted action items across org


Adoption rate
Active users / total licensed seats


Step 2 — Define Key Metrics
Track these metrics to measure Granola's impact:

Category
Metric
Target
Formula


Adoption
Activation rate
>80%
Users with 1+ meeting / total seats


Adoption
Weekly active users
>70%
Users recording this week / total seats


Quality
Capture rate
>70%
Meetings captured / total calendar meetings


Quality
Share rate
>50%
Notes shared / notes created


Efficiency
Time saved
>10 min/meeting
Survey: manual notes time - Granola time


Efficiency
Action completion
>80%
Actions completed / actions created


Health
Processing success
>99%
Successful enhancements / total attempts


Health
Integration uptime
>99%
Successful syncs / total sync attempts


Step 3 — Build a Custom Analytics Pipeline
Stream meeting metadata from Granola to a data warehouse via Zapier:

# Zapier: Granola → BigQuery pipeline
Trigger: Granola — Note Added to Folder ("All Meetings")

Step 1 — Code by Zapier (extract metadata):
  const data = {
    meeting_id: inputData.title + '_' + inputData.calendar_event_datetime,
    title: inputData.title,
    date: inputData.calendar_event_datetime,
    creator: inputData.creator_email,
    attendee_count: JSON.parse(inputData.attende

                

              

                
                  
                  
                  granola-performance-tuning
                  SKILL.md
                  View full skill →
                
                
                  Optimize Granola transcription accuracy, note quality, and processing speed.
                  
                      ReadWriteEdit
                    
                
                
                  Granola Performance Tuning
Overview
Optimize Granola output quality across three dimensions: audio/transcription accuracy, AI enhancement quality, and integration speed. Granola's AI (GPT-4o/Claude) produces better output when it has clean audio, well-typed notes, and structured templates.
Prerequisites

Working Granola installation with meetings captured
Willingness to improve audio setup and meeting practices
At least 3-5 meetings captured to establish baseline quality

Instructions
Step 1 — Optimize Audio for Transcription
Granola captures system audio from your device. Transcription accuracy depends entirely on audio quality:
Hardware recommendations (by priority):

Setup
Accuracy Impact
Recommendation


Wired headset with mic
Highest
Best for solo/remote meetings


USB condenser mic
High
Best for in-office, multiple speakers


Laptop built-in mic
Medium
Acceptable for quiet environments


Bluetooth headset
Variable
May cause dropouts — test first


Speakerphone in room
Low
Echo and distance degrade accuracy


Audio configuration checklist:

[ ] Correct input device selected in System Settings > Sound > Input
[ ] Input volume at 75-100% (not too low, not clipping)
[ ] Audio enhancements disabled (Windows: right-click device > Properties > disable enhancements)
[ ] No conflicting virtual audio software (Loopback, BlackHole, etc.)
[ ] Bluetooth device stable (or switch to wired if experiencing drops)

Room setup:

[ ] Minimal background noise (close doors, turn off fans)
[ ] Soft surfaces to reduce echo (avoid glass-walled conference rooms)
[ ] Mic within 12 inches of speaker(s)
[ ] Meeting participants using headsets (reduces echo and crosstalk)

Step 2 — Improve Meeting Practices
These behaviors directly improve Granola's output:

Practice
Impact
Why It Helps


State names when assigning work
High
"Sarah, can you handle the API spec?" enables correct attribution


Use explicit action language
High
"Action item: review by Friday" — AI detects structured language


One speaker at a time
High
Crosstalk confuses speaker diarization


Summarize decisions verbally
Medium
"So we've decided to go with option B" — AI captures decisions


Spell technical terms first time
Medium
"We'll use 
                
              
                
                  
                  
                  granola-prod-checklist
                  SKILL.md
                  View full skill →
                
                
                  Production readiness checklist for Granola team and enterprise deployment.
                  
                      ReadWriteEdit
                    
                
                
                  Granola Production Checklist
Overview
Comprehensive pre-launch checklist for deploying Granola to a team or organization. Covers plan selection, security hardening, integration setup, pilot program, and go-live execution.
Prerequisites

Budget approved for Granola licenses
Team size and meeting volume estimated
IT/security review completed or in progress
Admin access to Granola workspace

Instructions
Phase 1 — Plan & License

[ ] Select plan: Business ($14/user/mo) or Enterprise ($35+/user/mo)
[ ] Seat count: Purchase seats for all target users
[ ] Billing: Annual billing for 10-15% savings, or monthly for flexibility
[ ] Contract: Enterprise agreement signed (if applicable)
[ ] SOC 2 report: Requested and reviewed (available on request from Granola)

Phase 2 — Security Configuration

[ ] SSO enabled: Okta, Azure AD, or Google Workspace (Enterprise)
[ ] SCIM provisioning: Auto-provision users from IdP groups (Enterprise)
[ ] AI training opt-out: Enabled org-wide (Enterprise: enforced by default)
[ ] Sharing defaults: Set to Private, external sharing disabled or admin-approved
[ ] Data retention: Configured per data type (notes: 1-2yr, transcripts: 90d)
[ ] DPA signed: Data Processing Agreement for GDPR compliance
[ ] Session timeout: Configured for security policy (Enterprise)

Phase 3 — Integration Setup

Integration
Configuration
Verification


Google Calendar or Outlook
Settings > Calendar > Connect
Test meeting shows in Granola


Slack
Settings > Integrations > Slack
Post test note to channel


Notion
Settings > Integrations > Notion
Share test note creates DB entry


HubSpot/Attio/Affinity
Settings > Integrations > CRM
Match test note to CRM contact


Zapier (optional)
Connect Granola app in Zapier
Test Zap fires on note creation


MCP (optional)
Configure in AI tool settings
Test meeting query in Claude/Cursor


Phase 4 — Workspace Configuration

[ ] Workspaces created: Per department/team (Engineering, Sales, Leadership, etc.)
[ ] Folders created: Per meeting type within each workspace
[ ] Templates configured: Default templates per folder/meeting type
[ ] Sharing rules: Per-folder auto-post to Slack 
                
              

                
                  
                  
                  granola-rate-limits
                  SKILL.md
                  View full skill →
                
                
                  Understand Granola plan limits, usage quotas, and API rate limiting.
                  
                      ReadWriteEdit
                    
                
                
                  Granola Rate Limits & Plan Quotas
Overview
Granola has three plan tiers with different feature access and limits. There are no per-meeting minute caps or monthly meeting count limits on paid plans. Limits primarily apply to the free tier and the Enterprise API.
Plan Comparison (Current as of March 2026)
Basic (Free) — $0

Feature
Limit


Meetings
25 lifetime (not monthly)


Meeting history
Visible for 14 days only


Enhance Notes
Included


Templates
Built-in only


Granola Chat
Included


People & Companies
Included


Integrations
None


API access
None


> The free plan is essentially a trial — 25 meetings total, ever. After that, you must upgrade.
Business — $14/user/month

Feature
Availability


Meetings
Unlimited


Meeting history
Unlimited retention


Templates
Built-in + custom


Granola Chat
Included


People & Companies
Included


Slack integration
Native


Notion integration
Native


CRM (HubSpot, Attio, Affinity)
Native


Zapier
Full access


MCP (AI agent integration)
Included


Team shared folders
Included


Admin controls
Basic


AI training opt-out (org-wide)
Included


Priority support
Included


Public API access
Included


Enterprise — $35+/user/month

Feature
Availability


Everything in Business
Included


SSO (Okta, Google Workspace)
Included


SCIM provisioning
Included


AI training opt-out (enforced)
Default on


Usage analytics dashboard
Included


Enterprise API (full)
Included


Custom data retention policies
Configurable


SOC 2 Type 2 compliance report
Available


Dedicated account manager
Included


Volume discounts
Negotiable


API Rate Limits
Enterprise API

Rate limits are applied per workspace (not per user)
When exceeded: HTTP 429 Too Many Requests response
Retry behavior: respect the 
                
              

                
                  
                  
                  granola-reference-architecture
                  SKILL.md
                  View full skill →
                
                
                  Enterprise reference architecture for meeting management with Granola.
                  
                      ReadWriteEdit
                    
                
                
                  Granola Reference Architecture
Overview
Enterprise reference architecture for deploying Granola as the meeting intelligence platform across an organization. Covers the core capture pipeline, Zapier middleware routing, multi-workspace topology, security layers, and integration patterns for Slack, Notion, CRM, and task management.
Prerequisites

Granola Enterprise plan ($35+/user/month)
Zapier Professional or higher (for multi-step Zaps and Paths)
Destination systems provisioned (Slack, Notion, CRM, Linear/Jira)
IT architecture review completed

Instructions
Step 1 — Core Pipeline Architecture

┌─────────────────────────────────────────────────────────┐
│                    MEETING PLATFORMS                      │
│  Zoom  |  Google Meet  |  Microsoft Teams  |  Slack Huddle│
└──────────────────────┬──────────────────────────────────┘
                       │ System audio capture (no bot)
                       ▼
┌─────────────────────────────────────────────────────────┐
│                    GRANOLA PLATFORM                       │
│                                                          │
│  ┌──────────┐  ┌──────────────┐  ┌─────────────────┐   │
│  │ Audio    │→ │ Transcription │→ │ AI Enhancement  │   │
│  │ Capture  │  │ (GPT-4o/     │  │ (Notes + Trans- │   │
│  │ (local)  │  │  Claude)     │  │  cript merge)   │   │
│  └──────────┘  └──────────────┘  └────────┬────────┘   │
│                                            │             │
│  ┌────────────────┐  ┌──────────────────┐  │            │
│  │ People &       │  │ Folders          │  │            │
│  │ Companies      │  │ (routing rules)  │←─┘            │
│  │ (built-in CRM) │  └────────┬─────────┘              │
│  └────────────────┘           │                         │
└───────────────────────────────┼─────────────────────────┘
                                │
            ┌───────────────────┼───────────────────┐
            │           ZAPIER MIDDLEWARE            │
            │                                       │
            │  ┌─────────┐  ┌─────────┐  ┌──────┐ │
            │  │ Filter  │→ │ Route   │→ │ Act  │ │
            │  │ (type/  │  │ (paths  │  │      │ │
            │  │ attendee)│  │ /rules) │  │      │ │
            │  └─────────┘  └─────────┘  └──────┘ │
            └──────┬──────────┬──────────┬─────────┘
                   │          │          │
        ┌──────────┴──┐ ┌────┴────┐ ┌───┴────────┐
        │ COMMUNICATE │ │ ARCHIVE │ │ ACT        │
        │ Slack       │ │ Notion  │ │ Linear/Jira│
        │ Email       │ │ Drive   │ │ Asana      │
        │ Teams       │ │ GCS/S3  │ │ HubSpot    │
        └─────────────┘ └─────────┘ └────────────┘

Step 2 — Folder-Based Routing Topology
Design folder structure to drive automated routing:

Folder
Trigger Type
Destinations
P
                
              
                
                  
                  
                  granola-sdk-patterns
                  SKILL.md
                  View full skill →
                
                
                  Zapier automation patterns and Enterprise API integration for Granola.
                  
                      ReadWriteEditBash(curl:*)
                    
                
                
                  Granola SDK Patterns
Overview
Granola does not have a traditional SDK. Integration is achieved through three channels: Zapier (8,000+ app connections), the Enterprise API (REST, workspace-level read access), and native integrations (Slack, Notion, HubSpot, Attio, Affinity). This skill covers automation patterns for all three.
Prerequisites

Granola Business plan ($14/user/month) for Zapier + native CRM
Enterprise plan ($35+/user/month) for API access
Zapier account for automation workflows

Instructions
Step 1 — Understand Zapier Triggers
Granola provides two Zapier triggers:

Trigger
Fires When
Use Case


Note Added to Granola Folder
A note is placed in a specific folder
Auto-route by meeting type


Note Shared to Zapier
You manually share a note to Zapier
Selective sharing for important meetings


Webhook payload data available:

title — meeting title from calendar
creatorname / creatoremail — note creator
attendees[] — array of {name, email} objects
calendareventtitle — original calendar event name
calendareventdatetime — meeting date/time
note_content — the enhanced note content (Markdown)

Step 2 — Build Common Zap Patterns
Pattern 1: Meeting Notes to Notion (auto-archive)

Trigger: Note Added to Granola Folder ("All Meetings")
Action: Notion — Create Database Item
  Database: Meeting Archive
  Title: "{{title}}"
  Date: "{{calendar_event_datetime}}"
  Content: "{{note_content}}"
  Attendees: "{{attendees}}"

Pattern 2: Action Items to Asana/Linear

Trigger: Note Shared to Zapier
Filter: note_content contains "Action Items"
Code Step (JavaScript):
  const lines = inputData.note_content.split('\n');
  const actions = lines
    .filter(l => l.match(/^- \[ \]/))
    .map(l => l.replace('- [ ] ', ''));
  output = actions.map(a => ({task: a}));
Action: Linear — Create Issue (for each action)
  Title: "{{task}}"
  Team: Engineering
  Label: "meeting-action"

Pattern 3: Sales Call Summary to Slack + HubSpot

Trigger: Note Added to Granola Folder ("Sales Calls")
Path A — Slack:
  Action: Post Message to #sales-updates
  Message: |
    *New Sales Call:* {{title}}
    *Attendees:* {{attendees}}

    {{note_content}}

    [View full notes in Granola]

Pa

                

              

                
                  
                  
                  granola-security-basics
                  SKILL.md
                  View full skill →
                
                
                  Security and privacy configuration for Granola meeting data.
                  
                      ReadWriteEdit
                    
                
                
                  Granola Security Basics
Overview
Granola achieved SOC 2 Type 2 certification in July 2025. It encrypts data with AES-256 at rest and TLS 1.3 in transit. Audio is transcribed server-side and not stored after processing. This skill covers security configuration, compliance posture, and organizational controls.
Prerequisites

Granola Business or Enterprise plan (for admin/security controls)
Understanding of your organization's compliance requirements
Admin access for workspace-level settings

Instructions
Step 1 — Understand Granola's Data Architecture

Audio Capture (your device)
  │
  ├─→ Transmitted via TLS 1.3
  │
  ▼
Granola Cloud (transcription)
  │
  ├─→ Transcript generated (GPT-4o / Claude)
  ├─→ Audio DELETED after processing (not stored)
  │
  ▼
Encrypted Storage (AES-256 at rest)
  │
  ├─→ Meeting notes (your typed + AI enhanced)
  ├─→ Transcript text (stored, searchable)
  ├─→ Attendee metadata
  │
  ▼
Your Device (local cache: cache-v3.json)

Key security properties:

No bot joins your meeting — audio is captured locally via system audio
Raw audio is never stored after transcription
Granola does not allow OpenAI or Anthropic to train on customer data
Enterprise plan enforces org-wide AI training opt-out by default
Local cache (cache-v3.json) contains meeting data on your device

Step 2 — Configure Account Security

Control
How to Enable
Plan Required


Google/Microsoft SSO
Default (social login)
All


Enterprise SSO (Okta, Azure AD)
Settings > Security > SSO
Enterprise


SCIM provisioning
Settings > Security > SCIM
Enterprise


Session timeout
Settings > Security
Enterprise


IP allowlisting
Contact Granola support
Enterprise


Step 3 — Configure Data Controls
Sharing defaults:

Settings > Privacy:
  Default sharing: Private (recommended)
  Auto-share with attendees: Off (enable per-folder instead)
  External sharing: Disabled or Admin Approval Required
  Public links: Disabled
  Link expiration: 30 days (if external sharing enabled)

Data retention:

Settings > Data Retention:
  Meeting notes: Organization policy (1-2 years typical)
  Transcripts: 90 days (recommended for storage efficiency)
  Audio: Deleted after processing (Granola default, not configurable)

AI training opt-out:

Settings > Privacy > AI Training:
  Organization-wide opt-out: Enabled (Enterprise: enforced by default)

                

              

                
                  
                  
                  granola-upgrade-migration
                  SKILL.md
                  View full skill →
                
                
                  Upgrade Granola app versions and migrate between subscription plans.
                  
                      ReadWriteEditBash(brew:*)Bash(defaults:*)Bash(rm:*)Bash(open:*)
                    
                
                
                  Granola Upgrade & Migration
Overview
Manage Granola desktop app updates and subscription plan changes. Granola auto-updates by default, but manual intervention may be needed for major versions or plan migrations that affect feature access.
Prerequisites

Current Granola version info (Granola menu > About, or check via CLI)
Admin access for organization-level plan changes
Data backup awareness before downgrading

Instructions
Step 1 — Check Current Version

# macOS — read version from app bundle
defaults read /Applications/Granola.app/Contents/Info.plist CFBundleShortVersionString 2>/dev/null || echo "Check Granola > About Granola"

Check for available updates: Granola menu bar icon > Check for Updates, or visit granola.ai/updates for the changelog.
Step 2 — Update the Desktop App
Auto-update (recommended):
Granola checks for updates automatically and downloads in the background. Enable at:

Granola > Preferences > General > Check for updates automatically: On

Manual update via Homebrew (macOS):

brew update && brew upgrade --cask granola

Manual download:
Download latest from granola.ai/download. Close Granola, install over the existing version. Settings and data are preserved.
Step 3 — Handle Update Issues
If Granola crashes or behaves incorrectly after updating:

# Clear caches (preserves your data and authentication)
rm -rf ~/Library/Caches/Granola

# If that doesn't help, reset preferences (you'll need to re-authenticate)
defaults delete ai.granola.app 2>/dev/null

# Nuclear option — full reinstall
brew uninstall --cask granola 2>/dev/null
rm -rf ~/Library/Caches/Granola
rm -rf ~/Library/Preferences/ai.granola.app.plist
brew install --cask granola

Your meeting data is stored server-side and in the local cache (~/Library/Application Support/Granola/cache-v3.json). Reinstalling does not delete your notes.
Step 4 — Upgrade Subscription Plan

Settings (avatar bottom-left) > Account > Subscription > Upgrade

Upgrade paths:
  Basic (Free) → Business ($14/user/mo): Immediate, prorated
  Business → Enterprise ($35+/user/mo): Contact sales

What changes on upgrade:
  Basic → Business:
    + Unlimited meetings (was 25 lifetime)
    + Unlimited history (was 14 days)
    + Slack, Notion, CRM integrations
    + Zapier automation
    + MCP (AI agent integration)
    + Team shared folders
    + Custom templates
    + Public API access

  Business → Enterprise:
    + SSO (Okta, Azure AD, Google Workspace)
    + SCIM auto-provi

                

              

                
                  
                  
                  granola-webhooks-events
                  SKILL.md
                  View full skill →
                
                
                  Build event-driven automations with Granola's Zapier webhook triggers.
                  
                      ReadWriteEditBash(curl:*)Bash(node:*)Bash(python3:*)
                    
                
                
                  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:

{
  "title": "Sprint Planning — Q1 Week 12",
  "creator_name": "Sarah Chen",
  "creator_email": "sarah@company.com",
  "attendees": [
    {"name": "Sarah Chen", "email": "sarah@company.com"},
    {"name": "Mike Johnson", "email": "mike@company.com"},
    {"name": "Alex Kim", "email": "alex@external.com"}
  ],
  "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
calendareventtitle — 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", "d

                

              

          

        

      
      

      
      

      
      

      
      
  Ready to use granola-pack?
  
    
    
  




      
      
          Related Plugins
          
            
                000-jeremy-content-consistency-validator
                Read-only validator that generates comprehensive discrepancy reports comparing messaging consistency across ANY HTML-based website (WordPress, Hugo, Next.js, React, Vue, static HTML, etc.), GitHub repositories, and local documentation. Detects mixed messaging without making changes.
              
                002-jeremy-yaml-master-agent
                Intelligent YAML validation, generation, and transformation agent with schema inference, linting, and format conversion capabilities
              
                003-jeremy-vertex-ai-media-master
                Comprehensive Google Vertex AI multimodal mastery for Jeremy - video processing (6+ hours), audio generation, image creation with Gemini 2.0/2.5 and Imagen 4. Marketing campaign automation, content generation, and media asset production.
              
                004-jeremy-google-cloud-agent-sdk
                Google Cloud Agent Development Kit (ADK) and Agent Starter Pack mastery - build containerized multi-agent systems with production-ready templates, deploy to Cloud Run/GKE/Agent Engine, RAG agents, ReAct agents, and multi-agent orchestration.
              
                agent-context-manager
                Automatically detects and loads AGENTS.md files to provide agent-specific instructions
              
                ai-commit-gen
                AI-powered commit message generator - analyzes your git diff and creates conventional commit messages instantly
              
          
        

      
      
          Tags
          
            granolameeting-notestranscriptionsummariesmeetingsai-notesmeeting-intelligence
          
        
    
  

  

    

    
    
        
            
                Stay in the Loop
                
                    
                    
                    
                
                No spam. Unsubscribe anytime.
            

            
                
                    Product
                    
                        Explore
                        Skills
                        Cowork
                        Compare
                        Tools
                    
                
                
                    Resources
                    
                        Docs
                        Changelog
                        Collections
                        Playbooks
                        Research
                        Learning
                    
                
                
                    Company
                    
                        Community
                        Spotlight
                        GitHub
                    
                
                
                    Legal
                    
                        Privacy
                        Terms
                        Acceptable Use
                    
                
            

            
                Tons of Skills by Intent Solutions. Marine. Citadel Grad. 20 years ops → self-taught dev → AI architect.
                © 2026 Tons of Skills | Intent Solutions