Granola → markdown: the foundation everyone's missing

Export every meeting to markdown. Make it searchable in Claude. Unlock six workflows on top of it.

What you'll have when you're done

A pipeline where every Granola meeting lands as a markdown file in your notes folder, indexed by QMD, available to Claude Code on demand. From that one foundation, you can run a daily pipeline pull, track customer themes, keep promises you made on calls, run a sales coaching loop, generate board-prep digests, and onboard new hires, without setting any of those up as separate tools.

The setup is 30 minutes. The compounding is permanent.

Why this matters

Most of what you actually know about your business lives in conversations. Sales calls. Customer 1-on-1s. Candidate interviews. Board updates. Internal alignment with your team. Trapped in audio or locked inside a SaaS database, those conversations are inert: searchable only by your memory, retrievable only by listening to a recording.

Convert them to markdown and they become operating infrastructure. Your CRM doesn't store the customer's exact words. Your Slack doesn't surface the commitment you made on Thursday. A folder of markdown transcripts does. And once Claude can read it, every recurring CEO question becomes a single prompt.

The biggest source of leak at the $1-50M business stage is "the founder said they'd handle it and forgot." This workflow closes that leak.

What you need first

• A Granola subscription. Granola is an AI meeting-notes tool that records and transcribes your calls automatically. Sign up at granola.ai if you don't have it.
• The Claude memory workflow already installed. See the Claude memory workflow if you haven't done it. The rest of this article assumes QMD is indexing your notes folder.
• 30 minutes for the foundational install. Longer if you build any of the six use cases on top; those are 15-30 minutes each.
• Granola's plan tier checked. Manual markdown export works on every paid Granola plan. The API (used in Step 6 Option B for automated export) requires the Business plan or higher. Free and Pro plans don't include API access.

Step-by-step

Step 1Choose your destination folder

Use the same folder you indexed with QMD in the Claude memory workflow. If that folder is ~/notes, create a subfolder for meeting transcripts so they don't mix with your other notes:

mkdir -p ~/notes/granola

This creates the folder if it doesn't exist (-p means "no error if it's already there"). Future Granola exports go here.

Step 2Export from Granola to markdown manually

Granola has a built-in markdown export. For your first run, do this manually for ~10 recent meetings to seed the corpus:

1. Open Granola (Mac app or web)
2. Find a meeting from the last 30 days
3. Click the ⋯ menu (the three-dot overflow menu) on the meeting
4. Select Export → Markdown (the option may also be labeled "Copy as markdown" or "Download as .md" depending on your version)
5. Save the file to ~/notes/granola/. Give it a clear name like 2026-04-15-techcorp-discovery.md

Repeat for nine more meetings. The whole batch should take 10-15 minutes and gives you a feel for the format Granola uses.

Step 3Verify the export looks right

Open one of the exported files in any text editor (or in your terminal with cat ~/notes/granola/<filename>.md). You should see:

• A title line with the meeting name
• The date and attendees
• The transcript or AI-generated summary in markdown form
• Any action items or notes you added during the meeting

If the file looks empty, or only has metadata with no content, the export missed the body. Check whether Granola's export setting includes "transcript" or "AI notes"; toggle them on if needed.

Step 4Re-embed with QMD

Once the markdown files are in your notes folder, rebuild the QMD search index so they become searchable in Claude Code.

cd ~/notes
qmd embed

QMD detects the new markdown files automatically. The first re-embed of 10 transcripts takes about 10-30 seconds depending on length. Future re-embeds (after new meetings) are incremental and near-instant.

Step 5Test the search inside Claude Code

This is the proof the foundation works. Open a Claude Code session:

claude

Inside the session, ask something specific that you know is in one of your meetings:

/recall what did the customer at TechCorp say about pricing?

(Replace TechCorp with a real customer from your transcripts.) Claude should run the QMD search, pull the relevant meeting snippets, and summarize them in plain English with citations to which meeting each fact came from.

If it does, the foundation is in place. Move on to the use cases.

Step 6(Optional but recommended) Automate the export

Doing manual exports forever defeats the point. Two paths to automate, in order of effort:

Option A · A weekly batch reminder (lowest effort, no API needed). Set a recurring 15-minute calendar block on Friday afternoons. During the block: export the week's meetings to ~/notes/granola/ and run qmd embed. This is the cheapest reliable path. Most CEOs will live here forever.

Option B · Granola API + Claude Code Routine (most automated). Requires a Business or Enterprise Granola plan. The Free and Pro plans don't include API access.

Generate a Granola API key

1. Open the Granola desktop app
2. Go to Settings → Connectors → API keys
3. Click Create new key
4. Copy the key (it'll start with grn_). Save it somewhere secure; you'll paste it into your Routine config in a moment.

What the API returns

The relevant endpoints, all under base URL https://public-api.granola.ai:

GET /v1/notes
   → list of all notes (meetings) with their IDs
GET /v1/notes/{note_id}?include=transcript
   → single note with title, summary, transcript array, attendees

Auth on every request: Authorization: Bearer grn_YOUR_KEY.

The API returns JSON, not pre-formatted markdown, so the Routine has to convert each note's title, summary, and transcript array into a clean markdown file. Claude Code writes that script for you (see prompt below).

A single test call to verify your key works (run this in Terminal, replacing the key):

curl "https://public-api.granola.ai/v1/notes" \
  -H "Authorization: Bearer grn_YOUR_KEY_HERE"

You should get back JSON with a list of your meeting notes. If you get a 401, the key is wrong. If you get a 403, your plan tier doesn't include API access.

Set up the Routine

Open Claude Code (or claude.ai/code/routines; see the Claude routines workflow for the full setup). Create a new Routine with this prompt:

Every hour:

1. Call GET https://public-api.granola.ai/v1/notes with my Granola API
   key in the Authorization header. Compare the returned note IDs against
   the list of files already in ~/notes/granola/.

2. For each note I don't have yet, fetch it via:
   GET /v1/notes/{note_id}?include=transcript

3. Convert the JSON response into a clean markdown file with this shape:

   # {title}
   *{date} · {attendees joined with commas}*

   ## Summary
   {summary}

   ## Transcript
   {transcript array, one block per speaker turn, formatted as
   "**{speaker}:** {text}"}

4. Save it to ~/notes/granola/{YYYY-MM-DD}-{slugified-title}.md

5. After all new notes are saved, run `qmd embed` from the ~/notes folder
   to update the search index.

6. Post a one-line confirmation to #notes-sync in Slack:
   "Granola sync: N new meetings indexed."

   Skip the Slack post if N is zero.

Connectors needed: my Granola API key (paste below), Slack workspace.
Trigger: scheduled, every hour.

Claude Code will ask for your API key (paste it into the connector setup), then walk you through scheduling. Once the trigger is live, every meeting you have flows into your notes folder automatically. No Friday batch ever again.

Build on top: 6 workflows once meetings are markdown

Each workflow below is either a single Claude Code prompt or a small Routine. None of them require new installs; they all run on top of the foundation you just built.

1 · Daily pipeline summary

Every Monday morning, Claude scans the prior week's meetings, identifies which ones touched a deal, and posts a summary to Slack: deal name, stage, last move, next step, risk flags.

/recall sales meetings from the last 7 days

For each meeting that mentions a deal, list:
- Deal name
- Stage (discovery, demo, eval, close)
- Last move + date
- Next step + who owns it
- Any risk flags: budget concerns, timeline issues, competitor mentions

Post the summary to my #pipeline channel.

Make this a Routine (workflow #2) and you've replaced the Monday pipeline-review meeting.

2 · Customer-theme tracking

Once a month, surface what's actually coming up across customer conversations:

/recall customer calls in the last 30 days

What are the top 3 themes? For each:
- The theme in one sentence
- 3 representative quotes (anonymized)
- Which feature, pricing question, or process it points to
- How many distinct customers raised it

Run it on the first of every month. The patterns you'll see are usually different from what your team thinks is happening.

3 · Promise-keeping

The single highest-leverage workflow on this list. Every customer call you have, you make small promises: "I'll follow up on X." "We can probably ship Y by Q3." "Let me check with the team." Most of those promises die quietly.

/recall every customer commitment I made in the last 14 days

For each, list:
- The customer
- The promise (verbatim if possible)
- The deadline (explicit or implied)
- Has it been delivered? (check related meetings, Slack, email if connected)

Run it every Friday afternoon. Forwarding the output to your assistant or your COO closes the loop.

4 · Sales coaching loop

Once a quarter, pick one win and one loss. Have Claude compare them:

/recall every meeting with [winning customer name] and every meeting with [losing customer name]

Compare:
- Length: how long was each from first contact to decision?
- Buyer language: what did the buyer say in each meeting before they decided?
- Decision points: where did the conversations diverge?
- Pattern: what specific moves can we replicate next quarter?

This is the cheapest sales-coaching engine you'll ever run. It doesn't replace a real sales coach. It does replace the busywork that prevents you from learning from your own deals.

5 · Board-prep digest

The week before a board meeting, surface every conversation that touched a board-relevant metric:

/recall all conversations in the last 90 days mentioning revenue, churn, headcount, runway, or pipeline coverage

Group by metric. For each:
- Latest data point (with source meeting)
- Direction (up / flat / down) versus the prior quarter
- One representative quote that adds operating context

Pair this with your usual KPI dashboard and you'll have the qualitative color the dashboard misses: the why behind the numbers.

6 · Onboarding new hires

The most underused application. A new hire's first week, hand them this prompt:

/recall the most important customer conversations from the last 6 months

Summarize each in 3 bullets:
- Who the customer is and what they do
- What they want from us
- The decision (or open question) we have on our side

Group by customer. Sort by deal size or strategic importance.

That single prompt is more useful than a week of "let me catch you up." It also forces the new hire to read in the operator's voice, not in the polished pitch deck.

How you'll know it's working

Three checks, in order:

1. New Granola meetings land in ~/notes/granola/ as markdown files, manually (for now) or via the Routine in Step 6.
2. /recall <topic from a recent meeting> returns the right snippet in Claude Code, with a citation to which meeting it came from.
3. You can run any of the six workflows above without a new install. Each is just a prompt against the corpus you've built.

When it breaks

• Granola export is missing some meetings. Probably an export-scope issue: by default Granola may only export meetings you hosted, not ones you were invited to. Check the export settings.

• Old meetings show up in /recall but new ones don't. You exported new meetings but didn't re-run qmd embed. Run it: cd ~/notes && qmd embed. (Or set up the Routine in Step 6 so it's automatic.)

• /recall returns generic results. The search is working but your prompt is too vague. Be specific: name the customer, the date, the topic. "What did TechCorp say about pricing on the April 15 call?" beats "pricing concerns."

• The Granola API rejects your requests with a 401 / 403. A 401 means your API key is wrong or expired. Regenerate it at Granola desktop app → Settings → Connectors → API keys → Create new key. A 403 means your plan tier doesn't include API access (Free and Pro don't; Business and Enterprise do). Upgrade or stick with the manual weekly-batch path in Option A.

• Auto-export is too noisy; short meetings are cluttering the index. Add a length filter to the Routine: skip meetings under 10 minutes (those are usually scheduling holds or no-shows).

Where this fits in your harness

This is the capture layer of your harness. Memory (workflow #1) made your written notes searchable. Routines (workflow #2) made recurring work autonomous. This one, Granola → markdown, turns every conversation you have into the same compoundable asset class as your notes.

By the end of the third week, every meeting, every customer call, every internal sync becomes infrastructure. That asset doesn't appreciate linearly. It appreciates exponentially, because each new workflow you build on top of it benefits from every prior conversation you've ever recorded.

The CEOs who win the next 18 months treat their conversations the way smart founders treat their cap table: documented, indexed, retrievable. This workflow is the install.