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 r…

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:

1. System Settings > Privacy & Security > Screen & System Audio Recording
2. Enable Granola (this grants system audio access despite the misleading name)
3. System Settings > Privacy & Security > Microphone > Enable Granola
4. 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:

1. Settings > Privacy & Security > Microphone > Ensure Granola is enabled
2. Check that the correct audio device is set as default output
3. 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"

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:

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

1. Open Granola Settings > Templates
2. Click Create New Template
3. 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]

1. 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)

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):

1. Open the meeting note in Granola
2. Click Enhance Notes
3. Select your template (or accept the auto-matched one)
4. 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):

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

Notion (native integration):

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

HubSpot / Attio / Affinity (native CRM integration):

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

> Note: Native HubSpot integration does…

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

Cost comparison with competitors (per user/month):

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):

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

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:

1. Open the meeting note in Granola
2. Click the ... menu > Copy (copies as Markdown)
3. 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 = da…

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 …

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:

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

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:

1. Settings > Integrations > Notion > Connect
2. Authorize Granola in your Notion workspace
3. 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.

Integr…

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

Step 3 — Map SSO Groups to Roles

Configure in Organization Settings > Security > SSO > Group Mapping:

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

1. Join any video call — Zoom, Google Meet, Teams, Slack Huddle, or WebEx
2. Granola auto-detects the meeting from your synced calendar
3. A floating notepad appears showing the meeting title and attendees
4. 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

1. End your video call
2. Granola processes the transcript (typically 1-2 minutes)
3. Click Enhance Notes — Granola merges your notes with the transcript
4. 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…

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"

Scope assessment questions:

1. Is it just you, or are others affected too? → Ask in #granola-support
2. Is status.granola.ai showing an incident? → P1/P2 if yes
3. Was it working earlier today? → Recent change (OS update, permissions) likely
4. 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:

1. Click Granola menu bar icon > Start Recording (manual override)
2. 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:

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

1. Launch Granola
2. Click Sign up — authenticate with Google or Microsoft
3. 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

1. Granola Settings (avatar bottom-left) > Calendar
2. Connect Google Calendar or Microsoft Outlook
3. Select which calendars to sync (personal, work, shared)
4. 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

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 M…

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

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:

Step 2 — Create Workspaces

1. Navigate to Organization Settings > Workspaces
2. 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):

1. Organization Settings > Security > SSO
2. Choose SAML 2.0 or OIDC
3. 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

1. Test with a pilot user before enforcing org-wide

SCIM Provisioning:

1. Organization Settings > Security > SCIM
2. Generate SCIM token
3. Configure in your IdP:

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

1. Map IdP groups to Granola workspaces and roles:
…

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):

Step 2 — Define Key Metrics

Track these metrics to measure Granola's impact:

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,
   …

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):

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:

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

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
• [ ] Sharin…

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

> The free plan is essentially a trial — 25 meetings total, ever. After that, you must upgrade.

Business — $14/user/month

Enterprise — $35+/user/month

API Rate Limits

Enterprise API

• Rate limits are applied per workspace (not per user)
• When exceeded: HTTP 429 Too Many Requests response
• Retr…

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:

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:

Webhook payload data available:

• title — meeting title from calendar
• creator_name / creator_email — note creator
• attendees[] — array of {name, email} objects
• calendar_event_title — original calendar event name
• calendar_event_datetime — 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]

Path B — …

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

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…

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 …

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:

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
• 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…