How to Save a Notion Page as Markdown (Toggles Expanded, Databases as Tables)

Notion’s native “Export as Markdown” looks like a real escape hatch until you open the zip. Toggles are collapsed. Inline databases come out as broken HTML. Callouts lose their emoji. Filenames carry UUID suffixes. Every internal link points to a path that no longer exists. And most third-party “Notion to Markdown” tools just dump the rendered HTML, which is worse --- you end up with <div> soup pretending to be a note.

This guide covers every method to convert a Notion page to clean Markdown --- from a single page to a full workspace migration.

Why Save Notion Pages as Markdown?

Markdown is the format that survives outside Notion’s walls:

• Migrate to Obsidian, Logseq, or plain files --- one folder, no proprietary blocks, full-text search across everything
• Feed it to an LLM --- Claude, ChatGPT, Gemini, and local models all read Markdown natively as context
• Escape vendor lock-in --- Notion’s block format is theirs, Markdown is yours, the day you decide to leave is the day this matters
• Build an AI knowledge base --- point Claude Projects or a local RAG pipeline at a folder of clean Markdown and it just works
• Archive a page before it gets restructured --- workspaces get reorganized, pages get deleted, your notes shouldn’t depend on a teammate’s spring cleaning

The use case driving most Notion-to-Markdown traffic in 2026 is the migration one: people who built their second brain in Notion in 2020 and now want it in a format they actually control.

Method 1: Minibase (Fastest, One Click)

Minibase is a Chrome extension that turns any Notion page into a Markdown file with one click. It reads the rendered page, expands every toggle, walks the database rows, and produces something that actually looks like a note --- not a dump of Notion’s block IDs.

How it works:

1. Open the Notion page in Chrome (workspace pages or public links both work)
2. Click the Minibase extension icon in your toolbar
3. A .md file downloads instantly (or lands in your Minibase Vault if connected)

What you get:

• Toggles fully expanded --- every collapsed section is opened and inlined, so nothing is hidden
• Inline databases as Markdown tables --- columns become headers, rows become rows, properties stay readable
• Full-page databases as a table of rows --- every entry walked, properties preserved across the row
• Callouts as styled blockquotes --- the emoji icon stays at the front of the quote so the visual cue survives the format
• Code blocks with language identifiers --- ```python, ```ts, ```bash --- syntax highlighting works the moment you paste it elsewhere
• Linked-to-page and backlink references --- internal links are preserved as Markdown links to the relevant slugs
• Page title, icon, and cover --- frontmatter captures the title, the icon, and the cover image URL so the metadata survives

What gets removed:

• Notion’s sidebar, breadcrumb, and top nav chrome
• The right-side comments panel (unless explicitly opted in)
• “Share” buttons, “Updates” indicator, and other UI cruft
• Empty placeholder blocks and Notion’s default “Untitled” leftovers
• UUID suffixes on filenames --- you get product-roadmap-q2.md, not Product-Roadmap-Q2-a1b2c3d4e5f6.md

Best for: Anyone migrating a Notion workspace, building an AI knowledge base from existing docs, or just trying to grab one page without firing up Notion’s export queue. Especially good for pages with heavy toggle and database use, which are exactly where Notion’s native export falls down.

Example Output

Saving a typical Notion product page with a toggle and an inline database produces:

---
title: "Product Roadmap Q2 2026"
icon: "🗺️"
cover: "https://www.notion.so/images/page-cover/woodcuts_1.jpg"
url: https://www.notion.so/Product-Roadmap-Q2-2026-a1b2c3d4e5f6
---

# Product Roadmap Q2 2026

## In Progress

### User Authentication Overhaul

- Migrate from JWT to session-based auth
- Add SSO support for enterprise customers
- Timeline: March 15 - April 30

> 💡 **Note:** This blocks the enterprise launch. Prioritize accordingly.

#### Implementation Details

The migration happens in three phases. Phase one ships the new session
store behind a feature flag. Phase two backfills existing JWTs into
sessions on next login. Phase three removes the JWT code path entirely.

```python
session = await create_session(user_id, ttl=86400)
response.set_cookie("sid", session.token, httponly=True)

Planned

API v2

Endpoint	Status	Owner	Target
/users	Spec complete	Alice	Apr 15
/billing	In review	Bob	Apr 22
/analytics	Not started	—	May 06

Related Pages

• Q1 Retrospective
• Auth Migration RFC

That file drops into Obsidian as a working note. Pasted into Claude, it gives the model the full context with the toggle content and database rows the native export would have buried.

## Method 2: Notion's Native Markdown Export

Notion ships a built-in "Export as Markdown & CSV" option in the page menu.

**Steps:**

1. Open the page, click the `...` menu in the top right
2. Choose **Export**, then format **Markdown & CSV**
3. Wait for the zip, download it, unzip, find your page among the UUID-suffixed files

**Problems with this approach:**

- **Toggles collapse to nothing** --- the content inside `▶ Toggle` blocks disappears from the export entirely on the older code path, or comes out as a non-standard `<details>` block that most editors don't render
- **Databases get split into separate CSV files** --- the page itself loses the inline table, you get a `.md` and a sibling `.csv` you have to manually re-stitch
- **Filenames have UUID suffixes** --- `My-Page-a1b2c3d4e5f6.md` --- which breaks links and looks ugly in any file browser
- **Internal links point to UUID paths** --- `[Other Page](Other-Page-b2c3d4e5f6a1.md)` --- so the whole link graph breaks unless you rewrite it
- **Callouts lose their styling** --- the emoji icon is dropped, the block becomes a plain paragraph
- **Cover images and icons are not in frontmatter** --- the metadata you actually want is gone

Workable for a single text-only page. Falls apart on anything that uses Notion's richer block types --- which is most real pages.

## Method 3: Notion API + Script

For full control, you can pull the page via the official Notion API and convert blocks to Markdown yourself.

```bash
# Using notion-to-md (popular community library)
npm install notion-to-md @notionhq/client

# Set NOTION_TOKEN env var (integration token from notion.so/my-integrations)
node convert.js PAGE_ID > page.md

Best for: Engineering teams running scheduled exports, building a sync pipeline from Notion into a docs site, or anyone who needs programmatic control over how each block type maps to Markdown.

Problems with this approach:

• Requires creating a Notion integration, granting it page access, and managing the token
• The conversion library (e.g. notion-to-md) handles common blocks but lags behind newer ones --- synced blocks, AI blocks, and recent additions often come out broken
• Database properties (formulas, rollups, relations) require custom handling because the API returns them as raw references, not resolved values
• You’re writing and maintaining a converter, which is a real piece of software
• Rate limits and pagination need to be respected on large workspaces

The right method if you’re building a pipeline. Overkill for one page or even a small migration.

Method 4: Third-Party Migration Tools (Loom, super.so, etc.)

A small ecosystem of paid tools targets Notion migration specifically --- some focus on moving to a specific destination (Obsidian, Roam), others publish Notion pages to the web (super.so, Potion).

Best for: Teams doing a one-shot bulk migration who want a service to handle the long tail of block types and don’t mind paying per workspace.

Problems for the Markdown use case:

• Output is often tied to a specific destination (Obsidian vault, Roam graph) rather than clean portable Markdown
• Most are paid services with per-workspace or per-page fees
• Quality varies wildly --- some tools just call the Notion export under the hood, so you inherit all of its problems with extra steps
• Slow turnaround for large workspaces because they batch operations
• Designed for one-time migration, not for ad-hoc “save this page right now” use

If you’re moving an entire workspace and don’t want to touch a script, evaluate one of these. If you want one clean page in five seconds, they’re the wrong tool.

Which Method Should You Use?

Scenario	Best Method
Paste a Notion page into Claude or ChatGPT	Minibase --- one click, toggles expanded
Migrate one page to Obsidian	Minibase --- clean filename, working links
Build an AI knowledge base from your workspace	Minibase --- consistent Markdown across pages
Archive a page before a teammate reorganizes it	Minibase --- captures what you see right now
Bulk-export an entire workspace, one-shot	Notion native export --- accept the cleanup tax
Build an automated Notion → docs site pipeline	Notion API + script --- programmatic and stable
Pay a service to do the migration for you	Third-party tool --- if quality holds up

For most people --- especially anyone using Notion content as AI context or migrating to a Markdown-native tool --- Minibase is the answer. It produces the cleanest Markdown with zero setup, and it handles toggle-heavy and database-heavy pages without any of the structural loss the native export imposes.

Edge Cases Minibase Handles

• Nested databases inside pages. A page with a database, where one of the rows links to another page that itself contains a database --- Minibase expands the top-level table and links out to the nested pages, doesn’t try to inline the world. Recursion is opt-in for the rare case you want the whole tree.
• Sub-pages and linked pages. Internal links are preserved as Markdown links. If you save the parent and the children separately, the links resolve. If you save just the parent, the links stay as references you can resolve later.
• Synced blocks. Resolved to their actual content. The Markdown contains the resolved text, not a placeholder pointing to the source block.
• Comments. Off by default. Toggle them on in the extension settings if you want the discussion thread captured alongside the page content (useful for archival, noisy for AI context).
• Templates and template buttons. The template content is captured as it appears when rendered. Template buttons themselves are dropped since they’re interactive elements with no static representation.
• Wiki pages and gallery views. Wiki home pages keep their child page list. Gallery views become a table of entries with the visible properties as columns.
• Database properties (formulas, rollups, relations). Formula and rollup values are captured as their rendered text. Relations are preserved as Markdown links to the related pages.
• Public vs private pages. Minibase sees what your logged-in browser sees. If you can read the page, Minibase can convert it --- works on workspace pages, shared pages, and public links the same way.
• Long pages with hundreds of blocks. The extension chunks the conversion so the browser doesn’t freeze. Output is one continuous Markdown file regardless of page length.

Pair It With Your Workflow

The Markdown output works wherever you need it:

• Obsidian --- drop the file in your vault, the link graph rebuilds automatically as you save more pages
• Logseq --- same story, page properties become Logseq properties
• Claude / ChatGPT / Gemini --- paste the file in, ask follow-up questions, use it as context for a Project
• Apple Notes --- clean import via the Markdown share extension
• Plain folder + ripgrep --- if you went minimalist, a folder of Markdown plus rg is a faster search than Notion ever was
• Minibase Vault --- if you’ve connected one, every Notion save lands there automatically with backlinks and tags, so the whole workspace becomes searchable as it migrates

FAQ

Does Minibase work on private workspace pages? Yes. Minibase runs in your logged-in browser, so anything you can read --- workspace pages, shared pages, public links --- Minibase can convert.

Will Minibase break my Notion data? No. Minibase is read-only. It reads the rendered page in your browser tab and writes a Markdown file to your computer. It never modifies Notion, never calls the Notion API, never touches your workspace.

What about images and file attachments? Images are referenced as Markdown image links pointing to Notion’s S3 URLs. Those URLs are signed and expire, so for long-term archival, pair Minibase with an “embed images locally” pass --- ask the extension to download images alongside the Markdown.

Does it preserve toggles? Yes, and this is the main differentiator versus Notion’s native export. Every toggle on the page is opened and its content is inlined. You see everything that’s actually on the page, not just the headlines.

Can I bulk-export a whole workspace? The extension is one-page-at-a-time today. For full-workspace migration, the workflow most people use is: save the workspace’s top-level wiki page (which captures the page tree), then save the pages you actually want one by one. Faster than it sounds because each save is one click.

Does it work on Notion mobile? Desktop Chrome only. On mobile, copy the URL and open it on desktop, or use the Minibase Vault URL handler on Mac.

How does it compare to notion-to-md and other scripts? The output quality is comparable on simple pages. On pages with toggles, callouts, and inline databases, Minibase’s output is cleaner because it reads the rendered DOM rather than walking the raw block tree --- which means newer block types just work without waiting for a library update.

How much does it cost? Minibase has a free tier so you can try it on a few pages. After that, a small subscription covers the conversion costs.

Related Minibase Guides

• Save Google Docs as Markdown --- comments, suggestions, and formatting preserved
• Export Confluence to Markdown --- the enterprise wiki equivalent, with the same migration pain
• Save ChatGPT Conversations as Markdown --- every turn, with code blocks intact
• Save YouTube Videos as Markdown --- transcript, summary, timestamps, ready for Claude