Disclosure: this post is from the team behind MinuteHaul, a paid exporter for tl;dv and Fireflies (Fireflies support is in beta). Drafted with AI assistance; Fireflies details come from its own help center and API docs (linked), last checked Oct 2026. Plans change, so double-check before relying on them.

Free means cancelling

Fireflies says the Downgrade option in Settings, Billing only steps Enterprise to Business or Business to Pro. To get to Free, you cancel the subscription (Fireflies: how to downgrade):

1. Go to Settings, Account, Subscriptions and click Cancel next to your plan, then confirm the prompts.
2. Your paid plan keeps running until the end of the billing cycle, then the account is on Free (Fireflies: how to cancel).
3. Only the billing admin can change the plan. If you just want fewer seats, Fireflies suggests removing teammates instead.

What changes on Free

Sources: downloads, account data export, API limits.

The short version: your meetings don't get deleted, but the easy way to get files out does.

What to export before the cycle ends

• Transcripts in a format you'll actually use (Markdown, a CSV index) for search, Notion or an AI assistant. The API route is fastest while you still have paid limits.
• Recordings you'll rewatch. Download them per meeting while you're still on Pro, or request the account data export, which includes MP3 and MP4.

Already on Free? The data export and the API still work, just slower.

The one-ZIP option

The MinuteHaul web exporter uses Fireflies' official API from your browser with your own key, and works on the Free plan too. You get one ZIP with a speaker-labeled Markdown transcript per meeting plus an index.csv. It exports transcripts and metadata, not audio or video. Your 10 most recent meetings are free, then $19 one-time with a 14-day refund.

Full guide with FAQ: Fireflies downgrade to Free: what you keep, what you lose.

Disclosure: this post is from the team behind MinuteHaul, a paid exporter for tl;dv and Fireflies (Fireflies support is in beta). Drafted with AI assistance; Fireflies details come from its own help center and API docs (linked), last checked Oct 2026. Plans change, so double-check before relying on them.

What Fireflies gives you natively

1. One transcript at a time as CSV. Open a meeting, click Download, choose Transcript, and pick CSV (PDF, DOCX, SRT, JSON and MD are also offered), with optional timestamps and speaker labels. Fireflies says downloads are on Pro plans and higher, and the button is disabled otherwise (Fireflies help).
2. The whole-account data export. Free for all users on request. A ZIP link arrives within 24 to 48 hours and stays valid for 7 days. It holds audio, video if available, TXT transcripts and summaries, attendee info and JSON metadata, but no CSV (Fireflies help).

So for a spreadsheet of everything you'd either download hundreds of files one by one or parse the JSON yourself.

Option: build it from the API

The API works on every plan with your own key. Per Fireflies' limits page, Free is capped at 30 requests per minute and 500 per day (your first 14 days as an API user run at Pro limits), Pro at 60 per minute and 5,000 per day. List transcripts, fetch each one, and write one row per meeting. Keep the full transcripts in separate files, since a whole call in one spreadsheet cell isn't useful.

Option: an exporter

The MinuteHaul web exporter runs in your browser with your own Fireflies API key and builds one ZIP with:

• index.csv, one row per meeting: id, title, date, duration_sec, organizer, participants, file, status. Meetings without a transcript are listed as skipped, not dropped.
• One speaker-labeled Markdown transcript per meeting, which the file column points to.
• Optional all-transcripts.txt and all.jsonl (one line per spoken segment, if you want a row per line).

It exports transcripts and metadata, not audio or video. Your 10 most recent meetings are free, then $19 one-time.

Full guide with FAQ: Export Fireflies transcripts to CSV.

Disclosure: this post is from the team behind MinuteHaul, a paid exporter for tl;dv and Fireflies. The steps work with any export method. Drafted with AI assistance; NotebookLM details come from Google's own help center (linked), last checked Oct 2026. Limits change, so double-check before relying on them.

The limits that matter

Google's help center now calls the product Gemini Notebook. Per its sources article and FAQ:

1. Supported uploads include TXT, Markdown (MD), CSV, PDF and DOCX.
2. Each source can be up to 500,000 words or 200 MB.
3. A notebook holds 50 sources on the free plan; paid plans list 100, 300, 500 or 600.

So 300 one-meeting files won't fit in a free notebook, but a handful of combined files will. As a rough estimate (ours, not Google's), conversation runs about 130 to 160 words per minute, so one 500,000-word source holds very roughly 50 or more hours of meetings.

Step 1: get the transcripts out as text

tl;dv's help center says it doesn't currently support bulk transcript downloads or exports. Your options are downloading meetings one at a time, scripting the tl;dv API, or using an exporter. API access needs the meeting organizer on tl;dv Pro, Business or Enterprise, per tl;dv's API docs.

Step 2: combine into a few big files

Merge the transcripts into text files that each stay under 500,000 words, with a clear header per meeting (title, date, participants) so the notebook can cite the right call. Keep a separate CSV index of meetings if you want date and participant lookups.

The MinuteHaul web exporter does steps 1 and 2 from your own API key: it writes an all-transcripts.txt split into parts of about 400,000 words, plus one Markdown file per meeting and an index.csv. Your 10 most recent meetings are free, then $19 one-time with a 14-day refund.

Step 3: load them

1. Create a notebook.
2. Add each combined part as a source.
3. Optionally add index.csv as another source.

Full guide with FAQ: Load tl;dv transcripts into NotebookLM.

Disclosure: this post is from the team behind MinuteHaul, a paid exporter for tl;dv and Fireflies. Options 1 and 2 don't need it. Drafted with AI assistance; tl;dv, Zapier and Notion details come from their own docs (linked), last checked Oct 17, 2026. Integrations change, so double-check before relying on it.

Option 1: tl;dv's native Notion workflows (new meetings)

tl;dv has a native Notion integration under Integrations, then Notion. Per tl;dv's help article, its workflows run "when a recording is ready" and can create a page, append to a page, or add a database item with the title, AI notes, transcript, participants, date, URL and duration.

Because the trigger is a new recording, it covers meetings from now on. The article describes no backfill of past meetings.

Option 2: Zapier (also new meetings)

Zapier lists tl;dv triggers such as "Transcript Added" and templates like "Create pages in Notion for new tl;dv transcripts" (Zapier). These also fire on new events, not on meetings that already exist.

Option 3: your whole history, via a Notion ZIP import

Notion can import a ZIP: type /zip on a page, or go to Settings, then Import, then "Convert Zip to pages". Markdown files become pages and CSV files become databases (Notion Help). Notion notes that very high file counts (10,000+) may fail, so split big archives.

1. Export your transcripts as Markdown files: one by one, through the tl;dv API, or with an exporter.
2. Put them in one folder and zip the folder itself, not loose files.
3. In Notion, use "Convert Zip to pages".
4. Optionally import a CSV index separately to get a searchable database of every meeting.

tl;dv's help center says "Right now, we don't support bulk transcript downloads or exports", so step 1 is the hard part. If you don't want to script the API, the MinuteHaul web exporter produces that ZIP from your own API key: one Markdown file per meeting (title, date, participants, tl;dv link, speaker-labeled transcript with timestamps), an index.csv, and an optional all-transcripts.txt for ChatGPT, Claude or NotebookLM. Your 10 most recent meetings are free, then $19 one-time with a 14-day refund. API access needs the meeting organizer on tl;dv Pro, Business or Enterprise, per tl;dv's API docs.

Which one?

The usual setup is both: turn on the native workflow for new meetings, and do a one-time ZIP import for the backlog.

Full guide with FAQ: Export tl;dv transcripts to Notion.

Disclosure: this post is from the team behind MinuteHaul, a paid exporter for Fireflies and tl;dv. Options 1 and 2 don't need it. Drafted with AI assistance; Fireflies details come from Fireflies' own help docs and API docs (linked), last checked Oct 18, 2026. Plans change, so double-check before relying on it.

Why the button is greyed out

Fireflies' download guide answers "Why is the Download button disabled?" with "Check your plan - downloads require a Pro plan or higher". On Pro and above, a single meeting downloads as PDF, DOCX, SRT, CSV, JSON or MD. Source: How to download transcripts, summaries and recordings.

Option 1: the free account data export (everything, in 1 to 2 days)

Fireflies says it supports full data exports for all users on request (Fireflies guide):

1. Fill in Fireflies' data request form.
2. Approve the confirmation email (from fred@fireflies.ai, subject "Action Required – Confirm Your Data Export Request").
3. Within 24 to 48 hours you get a link to a ZIP with every meeting: TXT transcripts with speakers, AI summaries, audio (MP3), video (MP4 if recorded), attendee details and JSON metadata. The link expires after 7 days.

If you can wait a day or two, start here.

Option 2: the Fireflies API (free, needs a script)

Every plan gets API access. Free is limited to 30 requests a minute and 500 a day, and a Free user's first API request starts a 14-day trial at Pro limits (60 a minute, 5,000 a day) (Fireflies API limits). The key is under Integrations, then Fireflies API. The transcripts query returns up to 50 meetings per call; page with skip (API docs):

curl -s https://api.fireflies.ai/graphql \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  --data '{"query":"{ transcripts(limit: 50, skip: 0) { id title date sentences { speaker_name text start_time } } }"}'

Then fetch each transcript and write it to files yourself.

Option 3: no-code, files in minutes

If you don't want to write the script, the MinuteHaul web exporter (Fireflies source in beta) uses the same API from your browser with your own key. You get one ZIP: a Markdown file per meeting with speakers and timestamps, an index.csv, and an all-transcripts.txt for ChatGPT, Claude or NotebookLM. It takes about one API request per meeting, so the Free plan's 500 a day covers roughly 490 meetings. Your 10 most recent meetings are free, then $19 one-time with a 14-day refund.

Which one?

Full guide with FAQ: Download Fireflies transcripts on the Free plan.

Disclosure: this post is from the team behind MinuteHaul, a paid exporter for Fireflies and tl;dv. The integration route below doesn't need it. Drafted with AI assistance; Fireflies and Notion details come from their own help docs (linked), last checked Oct 18, 2026. Plans change, so double-check before relying on it.

On Pro or higher: the built-in integration

1. In Fireflies, open Integrations, search for Notion and click Connect.
2. Sign in to Notion, review the permissions, and either let Fireflies create a database from its template or pick an existing page to hold meetings as sub-pages.
3. Back in Fireflies, select the page or database. For a database, Fireflies adds missing columns and doesn't overwrite existing ones.
4. Turn on Save meeting summaries and Save meeting transcripts.
5. Click Create a sample note to check the setup.

Source: How to integrate Fireflies with Notion.

Old meetings: Push past meetings

New meetings sync once the integration is on. For older ones, open the Notion integration page, click Push past meetings, pick the last 7, 14, 30, 60 or 90 days or a custom range, choose which meetings, and push. You need at least one push configuration set up first (same Fireflies guide).

On the Free plan: go through files

Since transcripts to Notion need a paid plan, Free accounts can use files instead:

1. Export each transcript as Markdown through the Fireflies API. Every plan has API access, and Free allows 30 requests a minute and 500 a day (Fireflies API limits).
2. Zip the folder and use Notion's import, which accepts Markdown files and ZIP archives (Notion help). Each file becomes one Notion page.

You can script step 1 yourself, or use the MinuteHaul web exporter (Fireflies source in beta). It runs in your browser with your own API key and builds one ZIP: a Markdown file per meeting, an index.csv and an all-transcripts.txt, ready for Notion's import. Your 10 most recent meetings are free, then $19 one-time with a 14-day refund.

More detail: Fireflies to Notion guide.

MinuteHaul is independent and not affiliated with Fireflies or Notion.

Disclosure: this post is from the team behind MinuteHaul, a paid exporter for Fireflies and tl;dv. Two of the three routes below don't need it. Drafted with AI assistance; every Fireflies detail comes from Fireflies' own help center and API docs (linked), last checked Oct 18, 2026. Plans change, so double-check before relying on it.

Cancel vs delete

Sources: How to cancel your Fireflies subscription and How to delete your Fireflies account.

If you only want to stop paying, cancel. If you want to delete, export first.

Three ways to save everything

1. Fireflies' account data export (everything, 1 to 2 days). Fill in Fireflies' data request form and approve the confirmation email. Within 24 to 48 hours you get a link to a ZIP with transcripts (TXT, with speakers), AI summaries, audio, video where available, attendee details and JSON metadata. The link is valid for 7 days (Fireflies guide). It's the only route that includes recordings, so request it before you delete.

2. Download meetings one at a time (Pro or higher). Each meeting downloads as PDF, DOCX, SRT, CSV, JSON or MD on a paid plan (Fireflies guide). Fine for a handful, slow for hundreds.

3. The API (minutes, works on Free). Every plan gets API access; Free allows 30 requests a minute and 500 a day (Fireflies API limits). At one request per meeting, roughly 490 meetings fit in one UTC day on Free; split bigger accounts by date range. You can script it yourself, or use the MinuteHaul web exporter (Fireflies source is in beta), which runs from your browser and builds one ZIP: a Markdown file per meeting, an index.csv and an all-transcripts.txt. It exports transcripts (plus overview, action items and keywords if you tick that box), not audio or video. Your 10 most recent meetings are free, then $19 one-time with a 14-day refund.

Checklist before you click Delete

1. Request the Fireflies data export if you want recordings, and wait for the email.
2. Export transcripts as files so you have a searchable copy right away.
3. Compare the number of exported meetings with the count in Fireflies, and open a few files to check speakers and timestamps.
4. Store the archive somewhere you control (a drive, Notion or Obsidian).
5. Revoke your API key from anything that used it, then delete the account under Settings, Account, Delete my account (Fireflies guide).

More detail: Before you delete Fireflies: save every transcript.

MinuteHaul is independent and not affiliated with Fireflies.

Disclosure: this post is from the team behind MinuteHaul, a paid exporter for tl;dv and Fireflies. The steps below work without it. Drafted with AI assistance; every plan detail comes from tl;dv's own help center (linked), checked Oct 27, 2026. Plans change, so double-check before relying on it.

What tl;dv's help center says

One gap worth knowing: tl;dv's help center doesn't spell out how recordings you made while on Pro are treated after a downgrade. Since deletion is announced only 4 weeks ahead and there's no download outside that window, the safe assumption is that everything falls under Free retention.

If you're still on Pro or Business

Export before the plan ends, because the API stops working on Free.

1. Transcripts, in bulk. The app has no bulk transcript download; the API is the bulk route. Get a key under Settings, Personal settings, API keys, then run our free single-file CLI (Node 18+, MIT):

curl -O https://minutehaul.haullabs.dev/cli/minutehaul.mjs
export TLDV_API_KEY=your_key
node minutehaul.mjs --out ./tldv-export --notes

You get one Markdown file per meeting, an index.csv and an all-transcripts.txt.

2. Recordings you'll actually rewatch. Download them one at a time as MP4 from each meeting.

3. Team meetings. API access follows the organizer's plan, so each paid organizer exports their own meetings before the team downgrades.

Then downgrade: Settings, Plan & Billing, Manage subscription, then Cancel or pause plan on the Stripe page (tl;dv).

If you're already on Free and got the deletion email

Download the affected recordings inside the 4-week window tl;dv opens before the deletion date. Outside that window, Free-plan recordings can't be downloaded, even by a Pro user.

No-code option

If you'd rather not run a script, the MinuteHaul web exporter uses tl;dv's official API from your browser and builds one ZIP (Markdown per meeting, index.csv, all-transcripts.txt). It needs Pro or Business API access too. Your 10 most recent meetings are free, then $19 one-time for everything, with a 14-day refund.

More detail: tl;dv downgrade to Free: what you keep and what gets deleted.

MinuteHaul is independent and not affiliated with tl;dv.

Disclosure: this post is from the team behind MinuteHaul, a paid exporter for tl;dv and Fireflies (not affiliated with either). Everything below works without our product. Drafted with AI assistance and checked against each vendor's own help center and API docs; plans and limits change, so double-check before you cancel anything.

Side by side

If you use Fireflies

Can you wait a day or two? Use the free account data export first. It's the most complete thing you'll get (it includes audio and video). Use the API only if you need the files now, filtered by date, or in a different shape:

curl -X POST https://api.fireflies.ai/graphql \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  --data '{"query":"{ transcripts(limit: 50, skip: 0) { id title date sentences { speaker_name text start_time } } }"}'

Increase skip by 50 until you get an empty list. Remember the export link expires after 7 days, so download it promptly.

If you use tl;dv

There's no bulk button, so it's copy-paste or the API:

GET /v1alpha1/meetings                          -> list meetings (paginated)
GET /v1alpha1/meetings/{meetingId}/transcript   -> transcript per meeting

Page until no meetings come back, write each transcript to a file, and back off on rate limits. If you organize meetings on the Free plan, the API won't return them, so export what you need before you downgrade.

The order that avoids losing anything

1. Export first, cancel second, so the plan (and its download or API access) doesn't end before the export does.
2. Check that the file count matches the meeting count in the app.
3. Keep one plain-text copy (TXT or Markdown). It opens anywhere and works in ChatGPT, Claude or NotebookLM.

If you don't want to write the loop

MinuteHaul runs the API loop in your browser for tl;dv (and Fireflies, in beta) and gives you one ZIP: a Markdown file per meeting plus an index.csv. It stores no meeting data. Your 10 most recent meetings are free; $19 one-time unlocks the rest.

Full guides with sources:

• How to bulk export Fireflies transcripts
• How to bulk export tl;dv transcripts
• Fireflies before-you-cancel checklist
• tl;dv before-you-cancel checklist

Disclosure: this post is from the team behind MinuteHaul, a paid no-code exporter for tl;dv and Fireflies. Both scripts below are free (MIT) and don't need our product. Drafted with AI assistance; limits taken from each vendor's help center (linked below); they change, so double-check.

1. Export every tl;dv transcript as Markdown

tl;dv has an official REST API. Its docs list API access on the Pro, Business and Enterprise plans, and it depends on the meeting organizer's plan. Get a key under Settings > Personal settings > API keys, then run our single-file CLI (Node 18+, zero dependencies):

curl -O https://minutehaul.haullabs.dev/cli/minutehaul.mjs
export TLDV_API_KEY=your_key
node minutehaul.mjs --out ./tldv-export --notes

You get tldv-export/transcripts/ with one YYYY-MM-DD-title-id.md file per meeting (speaker and timestamp per line, plus tl;dv's AI notes with --notes), an index.csv, and one unsplit all-transcripts.txt. My earlier post walks through how the script works.

That single all-transcripts.txt is fine for a small archive, but a big one blows past the per-source limits below, so step 2 splits it.

2. The limits you're working around

So the target is: a handful of files, each under 500,000 words. The script defaults to 400,000 words per part for headroom.

3. The merge script

Save as merge-for-ai.mjs (Node 18+, no dependencies):

// merge-for-ai.mjs: combine per-meeting Markdown files into a few large .txt files
// sized for NotebookLM (500,000 words per source), ChatGPT and Claude Projects.
// Usage: node merge-for-ai.mjs ./tldv-export/transcripts ./ai-ready [maxWords]
import { readdir, readFile, writeFile, mkdir } from "node:fs/promises";
import { join } from "node:path";

const IN = process.argv[2] || "./tldv-export/transcripts";
const OUT = process.argv[3] || "./ai-ready";
const MAX = Number(process.argv[4] || 400_000); // headroom under NotebookLM's 500k

const files = (await readdir(IN)).filter((f) => f.endsWith(".md")).sort(); // date-first names sort by date
await mkdir(OUT, { recursive: true });

let part = 1, words = 0, buf = [], total = 0;
const flush = async () => {
  if (!buf.length) return;
  await writeFile(join(OUT, `all-transcripts-part${part}.txt`), buf.join("\n\n=====\n\n"));
  console.log(`part${part}: ${buf.length} meetings, ${words} words`);
  part++; words = 0; buf = [];
};

for (const f of files) {
  const text = await readFile(join(IN, f), "utf8");
  const n = text.split(/\s+/).filter(Boolean).length;
  if (words + n > MAX) await flush();
  buf.push(`SOURCE FILE: ${f}\n${text}`);
  words += n; total++;
}
await flush();
console.log(`Done: ${total} meetings in ${part - 1} file(s) in ${OUT}`);

Run it on your export folder:

node merge-for-ai.mjs ./tldv-export/transcripts ./ai-ready

You get all-transcripts-part1.txt, part2 and so on, in date order. Each meeting keeps its title, date and file name, so you can ask the AI to cite them.

4. Load and ask

• NotebookLM: new notebook, add each part as a source.
• ChatGPT: create a Project and add the parts as project files.
• Claude: create a Project and upload the parts; if one is over 30 MB, rerun with a smaller word limit (third argument).

Prompts that work well on a meeting archive:

• "List every pricing objection customers raised, with the meeting title and date for each."
• "Which feature requests came up in more than one meeting? Rank them by how often."
• "Summarize every meeting with [company] in date order and list open action items."

Privacy note: transcripts contain other people's words and often personal data. Check your company's policy and the AI tool's data settings before uploading.

Don't want to run code?

MinuteHaul does the export and the merge in your browser: one ZIP with a Markdown file per meeting, an index.csv, and all-transcripts.txt split at about 400,000 words. Your 10 most recent meetings are free and unlimited is $19 one-time. Tool-specific walkthroughs: tl;dv to ChatGPT, tl;dv to Claude and tl;dv to NotebookLM.

Cancelling Otter doesn't delete your conversations. It moves you to the free Basic plan, where only your 25 most recent conversations stay accessible and older ones are archived (Otter help). And bulk export is only available on the Business and Enterprise plans (Otter help).

So the order matters: export first, cancel second.

If you're on Business or Enterprise: bulk export now

1. Go to My Conversations (or the Channel, Direct Message or Folder that holds the transcripts).
2. Tick at least one conversation. The Select all checkbox only appears after that.
3. Scroll down until every conversation has loaded. Otter says Select all only selects the conversations loaded on the current page. This is the step people miss.
4. Click Select all, then the Export icon, choose formats and settings, and click Export.
5. Otter emails you a link to a ZIP file.

Two notes from Otter: bulk audio export isn't available in Channels or Direct Messages, and adblockers can break exports, so turn yours off if an export fails.

On any plan: one conversation at a time

Open the conversation, click the three dots, then Export. Formats are TXT, DOCX, PDF, SRT or Clipboard, but Basic users can export TXT only. Audio is a separate toggle and downloads as MP3 (Otter: Export conversations). Outlines and Action Items can't be exported as files; copy them from the Summary.

Already cancelled? Archived isn't gone

Otter says archived conversations aren't automatically deleted, and you can export an archived conversation without unarchiving it or upgrading (Otter help). Also: archiving follows the owner's plan, so people you shared conversations with lose access once those are archived.

Free script: turn the export into AI-ready files

Once you have a folder of TXT files, you probably want to ask questions across all of them in NotebookLM, ChatGPT or Claude. Uploading hundreds of small files is painful, so this Node script (Node 20+, no dependencies) merges them into a few big files, each under 400,000 words to stay below NotebookLM's 500,000-words-per-source limit.

// merge-otter-for-ai.mjs: combine the per-conversation TXT files from an Otter export
// into a few large .txt files you can upload to NotebookLM, ChatGPT or Claude.
// Usage: node merge-otter-for-ai.mjs ./otter-export ./ai-ready [maxWords]
import { readdir, readFile, writeFile, mkdir } from "node:fs/promises";
import { join } from "node:path";

const IN = process.argv[2] || "./otter-export";
const OUT = process.argv[3] || "./ai-ready";
const MAX = Number(process.argv[4] || 400_000); // headroom under NotebookLM's 500k words per source

const files = (await readdir(IN, { recursive: true }))
  .filter((f) => f.toLowerCase().endsWith(".txt"))
  .sort();
await mkdir(OUT, { recursive: true });

let part = 1, words = 0, buf = [], total = 0;
const flush = async () => {
  if (!buf.length) return;
  await writeFile(join(OUT, `otter-transcripts-part${part}.txt`), buf.join("\n\n=====\n\n"));
  console.log(`part${part}: ${buf.length} conversations, ${words} words`);
  part++; words = 0; buf = [];
};

for (const f of files) {
  const text = await readFile(join(IN, f), "utf8");
  const n = text.split(/\s+/).filter(Boolean).length;
  if (words + n > MAX && buf.length) await flush();
  buf.push(`CONVERSATION FILE: ${f}\n${text}`);
  words += n; total++;
}
await flush();
console.log(`Done: ${total} conversations in ${part - 1} file(s) in ${OUT}`);

Run it:

unzip otter-export.zip -d otter-export
node merge-otter-for-ai.mjs ./otter-export ./ai-ready

Each conversation keeps a CONVERSATION FILE: header, so the AI can tell you which meeting an answer came from.

Pre-cancel checklist

• Check your plan. On Business or Enterprise, bulk export now.
• Scroll My Conversations to the bottom before Select all.
• Need DOCX, PDF or SRT? Export them while you're still paid; Basic is TXT only.
• Want recordings? Turn on the Audio (MP3) toggle.
• Check Channels and Direct Messages separately.
• Disable your adblocker.
• Spot-check old and new conversations in the ZIP before cancelling.
• Copy any Summaries, Outlines and Action Items you need.

The full version with FAQ is here: How to export your Otter.ai transcripts before you cancel.

Moving from tl;dv or Fireflies instead? MinuteHaul exports the whole archive in one go, free for your 10 most recent meetings. If you'd use a one-click Otter exporter, email bulktranscripts@mail.grokbot.com; requests decide what we add next.

Fireflies can download a single meeting as Markdown on Pro and higher plans, but there's no button for "all of them." If you keep notes in Obsidian, you probably want every meeting as its own note, with properties you can filter on: date, length, who was there, and a link back to Fireflies.

The Fireflies GraphQL API gives you all of that on every plan, including Free. Here's a script that writes one Obsidian note per meeting with YAML frontmatter.

What you get

Each meeting becomes a file like 2026-10-21 Weekly sync.md:

---
title: "Weekly sync"
date: 2026-10-21
duration_min: 34
organizer: "you@company.com"
participants: ["you@company.com", "sam@company.com"]
source: "https://app.fireflies.ai/view/..."
tags: [meeting, fireflies]
---

# Weekly sync

**Sam** [00:00:04]: Okay, let's start with the launch...

Obsidian reads the frontmatter as note properties, so you can sort by date, search by participant, or build a Dataview table of every meeting with a given person.

The script

You need Node 18 or newer (for built-in fetch) and your API key from Fireflies, under Integrations, then Fireflies API.

// fireflies-to-obsidian.mjs: every Fireflies transcript as an Obsidian note with YAML frontmatter.
// Usage: FIREFLIES_API_KEY=xxx node fireflies-to-obsidian.mjs "/path/to/vault/Meetings"
import { mkdir, writeFile } from "node:fs/promises";
import { join } from "node:path";

const KEY = process.env.FIREFLIES_API_KEY;
const OUT = process.argv[2] || "./Meetings";
if (!KEY) { console.error("Set FIREFLIES_API_KEY"); process.exit(1); }
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

async function gql(query, variables) {
  for (;;) {
    const res = await fetch("https://api.fireflies.ai/graphql", {
      method: "POST",
      headers: { "Content-Type": "application/json", Authorization: `Bearer ${KEY}` },
      body: JSON.stringify({ query, variables }),
    });
    if (res.status === 429) { console.log("429, waiting 60s"); await sleep(60_000); continue; }
    const json = await res.json();
    if (json.errors) throw new Error(JSON.stringify(json.errors));
    await sleep(2_100); // ~28/min: safe on the Free plan's 30/min
    return json.data;
  }
}

const LIST = `query($limit:Int,$skip:Int){transcripts(limit:$limit,skip:$skip){id title date duration organizer_email participants transcript_url}}`;
const ONE = `query($id:String!){transcript(id:$id){sentences{speaker_name text start_time}}}`;

const safe = (s) => (s || "Untitled").replace(/[\\/:*?"<>|#^[\]]/g, " ").replace(/\s+/g, " ").trim().slice(0, 80);
const q = (s) => JSON.stringify(String(s ?? ""));
const ts = (sec) => new Date(sec * 1000).toISOString().slice(11, 19);

await mkdir(OUT, { recursive: true });
let skip = 0, saved = 0;
for (;;) {
  const { transcripts } = await gql(LIST, { limit: 50, skip });
  if (!transcripts?.length) break;
  for (const t of transcripts) {
    const { transcript } = await gql(ONE, { id: t.id });
    const day = new Date(Number(t.date)).toISOString().slice(0, 10);
    const people = (t.participants || []).filter(Boolean);
    const front = [
      "---",
      `title: ${q(t.title)}`,
      `date: ${day}`,
      `duration_min: ${Math.round(Number(t.duration) || 0)}`,
      `organizer: ${q(t.organizer_email)}`,
      `participants: [${people.map(q).join(", ")}]`,
      `source: ${q(t.transcript_url)}`,
      "tags: [meeting, fireflies]",
      "---",
    ].join("\n");
    const lines = (transcript?.sentences || []).map(
      (s) => `**${s.speaker_name || "Speaker"}** [${ts(s.start_time)}]: ${s.text}`
    );
    await writeFile(join(OUT, `${day} ${safe(t.title)}.md`), `${front}\n\n# ${t.title}\n\n${lines.join("\n\n")}\n`);
    console.log(`saved ${++saved}: ${t.title}`);
  }
  skip += 50;
}
console.log(`Done: ${saved} notes in ${OUT}`);

Run it with the output pointed straight into your vault:

FIREFLIES_API_KEY=your_key node fireflies-to-obsidian.mjs "$HOME/Vault/Meetings"

Things to know before you run it

• Rate limits. Fireflies documents 30 requests a minute and 500 a day on Free, and 60 a minute and 5,000 a day on Pro. The script spends about one request per meeting plus one per 50 listed, and pauses about 2 seconds between calls to stay under the Free per-minute cap. On Free, an archive bigger than about 490 meetings needs a second run the next day (the daily limit resets at midnight UTC), so add a skip for files that already exist if you're in that spot.
• Duration comes from the API in minutes, and the script rounds it.
• File names strip characters Obsidian or your OS won't accept, like / : # ^ [ ]. Two meetings with the same title on the same day would overwrite each other; add t.id to the name if that happens to you.
• Summaries aren't included. Add summary{overview action_items} to the ONE query and write them under the title if you want them.

A Dataview query to try

With the Dataview plugin installed, this lists every meeting with one person, newest first:

TABLE date, duration_min AS "min"
FROM "Meetings"
WHERE contains(participants, "sam@company.com")
SORT date DESC

If you'd rather not run code

MinuteHaul does the same export from your browser: paste the API key, and it builds a ZIP with one Markdown file per meeting, an index.csv, and an all-in-one text file for AI tools. Your 10 most recent meetings are free; unlimited is $19 one-time. There's a longer walkthrough in our Fireflies to Markdown and Obsidian guide.

Disclosure: this post is from the team behind MinuteHaul, a paid no-code exporter for Fireflies and tl;dv. The script below is free and doesn't need our product. Drafted with AI assistance; limits taken from each vendor's help center (linked below); they change, so double-check.

1. Get your transcripts as files first

If you don't have them yet, my previous post has a 50-line script that exports every Fireflies transcript to Markdown through the Fireflies API (which works on every plan, including Free, within Fireflies' rate limits). It writes one YYYY-MM-DD-title-id.md file per meeting.

2. The limits you're working around

So the target is: a handful of files, each under 500,000 words. The script defaults to 400,000 words per part for headroom.

3. The merge script

Save as merge-for-ai.mjs (Node 18+, no dependencies):

// merge-for-ai.mjs: combine per-meeting Markdown files into a few large .txt files
// sized for NotebookLM (500,000 words per source), ChatGPT and Claude Projects.
// Usage: node merge-for-ai.mjs ./fireflies-export ./ai-ready [maxWords]
import { readdir, readFile, writeFile, mkdir } from "node:fs/promises";
import { join } from "node:path";

const IN = process.argv[2] || "./fireflies-export";
const OUT = process.argv[3] || "./ai-ready";
const MAX = Number(process.argv[4] || 400_000); // headroom under NotebookLM's 500k

const files = (await readdir(IN)).filter((f) => f.endsWith(".md")).sort(); // date-first names sort by date
await mkdir(OUT, { recursive: true });

let part = 1, words = 0, buf = [], total = 0;
const flush = async () => {
  if (!buf.length) return;
  await writeFile(join(OUT, `all-transcripts-part${part}.txt`), buf.join("\n\n=====\n\n"));
  console.log(`part${part}: ${buf.length} meetings, ${words} words`);
  part++; words = 0; buf = [];
};

for (const f of files) {
  const text = await readFile(join(IN, f), "utf8");
  const n = text.split(/\s+/).filter(Boolean).length;
  if (words + n > MAX) await flush();
  buf.push(`SOURCE FILE: ${f}\n${text}`);
  words += n; total++;
}
await flush();
console.log(`Done: ${total} meetings in ${part - 1} file(s) in ${OUT}`);

Run it on your export folder:

node merge-for-ai.mjs ./fireflies-export ./ai-ready

You get all-transcripts-part1.txt, part2 and so on, in date order. Each meeting keeps its title, date and file name, so you can ask the AI to cite them.

4. Load and ask

• NotebookLM: new notebook, add each part as a source.
• ChatGPT: create a Project and add the parts as project files.
• Claude: create a Project and upload the parts; if one is over 30 MB, rerun with a smaller word limit (third argument).

Prompts that work well on a meeting archive:

• "List every pricing objection customers raised, with the meeting title and date for each."
• "Which feature requests came up in more than one meeting? Rank them by how often."
• "Summarize every meeting with [company] in date order and list open action items."

Privacy note: transcripts contain other people's words and often personal data. Check your company's policy and the AI tool's data settings before uploading.

Don't want to run code?

MinuteHaul does the export and the merge in your browser: one ZIP with a Markdown file per meeting, an index.csv, and all-transcripts.txt split at about 400,000 words. Your 10 most recent meetings are free, unlimited is $19 one-time, and Fireflies support is in beta. The full walkthrough is in the Fireflies to ChatGPT, Claude and NotebookLM guide.

Disclosure: this post is from the team behind MinuteHaul, a paid no-code exporter for Fireflies and tl;dv. The script below is free to copy and doesn't need our product. Drafted with AI assistance and checked against the Fireflies API docs.

1. Get your API key

Log in at app.fireflies.ai, open Integrations, then Fireflies API, and copy the key (Fireflies docs). Treat it like a password.

2. Know the rate limits

Fireflies documents these API limits (docs):

• Free: 30 requests a minute, 500 a day (a Free user's first API request starts a 14-day trial at Pro limits)
• Pro: 60 a minute, 5,000 a day
• Business and Enterprise: 60 a minute per paid seat, pooled, no daily cap

The script uses one request per 50 meetings listed plus one per transcript, and waits about 1.1 seconds between calls, which stays under 60 a minute. On a 429 it waits a minute and retries. If you're on Free past the trial, raise the sleep to about 2.1 seconds.

3. The script

Save as fireflies-export.mjs (Node 18+, no dependencies):

// fireflies-export.mjs: save every Fireflies transcript as Markdown.
// Usage: FIREFLIES_API_KEY=xxx node fireflies-export.mjs ./out
import { mkdir, writeFile } from "node:fs/promises";
import { join } from "node:path";

const KEY = process.env.FIREFLIES_API_KEY;
const OUT = process.argv[2] || "./fireflies-export";
if (!KEY) { console.error("Set FIREFLIES_API_KEY"); process.exit(1); }
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

async function gql(query, variables) {
  for (;;) {
    const res = await fetch("https://api.fireflies.ai/graphql", {
      method: "POST",
      headers: { "Content-Type": "application/json", Authorization: `Bearer ${KEY}` },
      body: JSON.stringify({ query, variables }),
    });
    if (res.status === 429) { console.log("429, waiting 60s"); await sleep(60_000); continue; }
    const json = await res.json();
    if (json.errors) throw new Error(JSON.stringify(json.errors));
    await sleep(1_100); // ~55 requests/minute, under Pro's 60
    return json.data;
  }
}

const LIST = `query($limit:Int,$skip:Int){transcripts(limit:$limit,skip:$skip){id title date duration}}`;
const ONE = `query($id:String!){transcript(id:$id){sentences{speaker_name text start_time}}}`;

const slug = (s) => (s || "untitled").toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 60);
const ts = (sec) => new Date(sec * 1000).toISOString().slice(11, 19);

await mkdir(OUT, { recursive: true });
let skip = 0, saved = 0;
for (;;) {
  const { transcripts } = await gql(LIST, { limit: 50, skip });
  if (!transcripts?.length) break;
  for (const t of transcripts) {
    const { transcript } = await gql(ONE, { id: t.id });
    const day = new Date(Number(t.date)).toISOString().slice(0, 10);
    const lines = (transcript?.sentences || []).map(
      (s) => `**${s.speaker_name || "Speaker"}** [${ts(s.start_time)}]: ${s.text}`
    );
    const md = `# ${t.title}\n\nDate: ${day}\n\n${lines.join("\n\n")}\n`;
    await writeFile(join(OUT, `${day}-${slug(t.title)}-${t.id}.md`), md);
    console.log(`saved ${++saved}: ${t.title}`);
  }
  skip += 50;
}
console.log(`Done: ${saved} transcripts in ${OUT}`);

Run it:

FIREFLIES_API_KEY=your_key node fireflies-export.mjs ./fireflies-export

You get one file per meeting, named YYYY-MM-DD-title-id.md, with speaker names and timestamps.

4. Ideas to extend it

• Add summary{overview action_items keywords} to the transcript query to keep Fireflies' AI notes.
• Track saved IDs in a JSON file so re-runs skip what you already have.
• Write CSV instead of Markdown if you're importing into a spreadsheet.

Don't want to run code?

MinuteHaul does the same thing in your browser (requests go straight from your browser to Fireflies), can include the AI summaries, and gives you one ZIP with a Markdown file per meeting and an index. You can try it free on 10 meetings; after that it's $19 one-time. Fireflies support is in beta. There's also a step-by-step Fireflies bulk export guide.

We wrote a small MIT-licensed script for this. It's a single file, has zero dependencies and needs Node 18+ (built-in fetch).

What you need

• Node.js 18 or newer
• A tl;dv API key from Settings > Personal settings > API keys (https://tldv.io/app/settings/personal-settings/api-keys). tl;dv's API docs list API access on the Pro, Business and Enterprise plans, and it depends on the meeting organizer's plan.

Run it

curl -O https://minutehaul.haullabs.dev/cli/minutehaul.mjs
export TLDV_API_KEY=your_key
node minutehaul.mjs --out ./tldv-export --notes
# optional date range and a JSONL dump:
node minutehaul.mjs --out ./tldv-export --from 2026-01-01 --to 2026-06-30 --jsonl

Use the env var rather than --key so the key doesn't land in your shell history.

What you get

tldv-export/
  transcripts/*.md      one Markdown file per meeting, speaker + timestamp per line
  index.csv             meeting id, title, date, duration, organizer, participants, status
  all-transcripts.txt   everything in one file (handy for feeding an LLM or NotebookLM)
  all.jsonl             optional, raw records (--jsonl)

--notes adds tl;dv's AI notes to each Markdown file. Meetings that don't have a finished transcript show up as "skipped" in index.csv, so you can see what's missing instead of silently losing it.

How it works

The script pages through the meetings list endpoint 100 at a time, then fetches each meeting's transcript and (optionally) notes. A few details that matter on a large archive:

• Retries with backoff. On HTTP 429 or 5xx it honors Retry-After when present, otherwise backs off exponentially (up to 6 attempts).
• 404 means "no transcript yet", not a fatal error.
• Safe filenames. Titles are stripped to word characters and capped at 60 chars, so a meeting called Q3 / pricing ??? doesn't break your filesystem.

It only talks to tl;dv's API (pasta.tldv.io) and writes to your disk. Nothing is sent anywhere else. It's 143 lines, so read it before you run it: https://minutehaul.haullabs.dev/cli/minutehaul.mjs

There's also beta support for Avoma (--source avoma, with AVOMA_API_KEY=CLIENT_KEY:CLIENT_SECRET), tested only against a mock of Avoma's published API so far.

No terminal?

Disclosure: the script comes from MinuteHaul, a small tool from our team that does the same export in the browser and hands you a ZIP. It's free for your 10 most recent meetings and $19 one-time for everything: https://minutehaul.haullabs.dev/?utm_source=devto&utm_medium=article&utm_campaign=cli

The CLI itself is free with no meeting cap. If you hit an endpoint quirk, the field reference we keep is here: https://minutehaul.haullabs.dev/guides/tldv-api-field-reference.html

MinuteHaul is independent and not affiliated with tl;dv. This post was drafted with AI assistance and checked against the script's source.