How to Import Data into Notion: Formats, Limits & Data Mapping

Notion supports native imports for CSV, Markdown, HTML, DOCX, XLSX/XLS, TSV/DSV, ODS, EPUB, OPML, PDF (beta), and ZIP bundles — plus direct connectors for Confluence, Evernote, Trello, Asana, and Google Docs. But knowing which format Notion accepts and knowing what survives the import are two different things.

Relations, rollups, and formulas are stripped. "Merge with CSV" appends rows instead of updating them. The API caps rich text at 2,000 characters per object. And large ZIP imports with 10,000+ files can fail silently.

This guide covers what actually happens when data enters Notion, what breaks, and how to engineer around the constraints.

For the reverse journey — getting data out — see our complete Notion export guide.

Supported Import Formats and What Each One Does

Notion's import menu lives at Settings → Import, or you can type /import on any page. Your choice of format dictates how Notion structures the incoming data — choose wrong and you'll spend hours on manual cleanup. (notion.com)

App-Specific Importers

Notion has direct connectors for several platforms. Each has scale ceilings worth knowing before you commit:

• Evernote: Notebooks import as pages; notes become database items. Only the standard Evernote edition is supported — not Evernote China or Evernote Business. Documented as reliable up to roughly 5,000 notes. (notion.com)
• Trello: Boards import as a Notion database, with cards as items and lists as groups. Documented as reliable up to roughly 5,000 cards per board, with a recommended ceiling of roughly 5,000 comments per board. (notion.com)
• Asana: Tasks import as database items. Documented up to roughly 6,000 tasks and 200 projects, with a workspace attachment rate limit of about 100–120 file attachments per day. (notion.so)
• Confluence: Upload a .zip file from Confluence's HTML space export. The ZIP import supports up to 5 GB. The API importer supports up to 30 GB and roughly 50k pages, and retains comments and user mapping. (notion.so)
• Monday.com: Imports projects and tasks into Notion databases. Recommended up to roughly 8,000 tasks and 100 projects. The assignee column must be named Owner, Assignee, or Person, and only one assignee-type column should exist on the board. (notion.so)
• Google Docs: Paste a Google Doc link or use /Google Docs — but you can only import one doc at a time. For bulk migration, export docs as .docx via Google Takeout and use the Word importer. (notion.com)
• Quip, Dropbox Paper, Hackpad, WorkFlowy: These are export-then-import routes. Quip pages export one at a time as Markdown or HTML. Dropbox Paper exports via Word. Hackpad exports via Markdown. WorkFlowy exports via plain text. (notion.com)

For a detailed comparison of Notion and Confluence architectures, see our Notion vs. Confluence guide.

Step-by-Step: Importing Files into Notion

Native imports run on desktop and web, not mobile. You can start from Settings → Import or slash commands like /csv, /pdf, and /zip. Monitor progress in Settings → Import, and expect some imports to land in the Private section before you reorganize them. (notion.com)

Importing a CSV (New Database)

1. Go to Settings → Import → CSV, or type /csv on any page.
2. Select your .csv file.
3. Notion displays a preview. Toggle "Use first row as headers" (on by default).
4. Map each column to a Notion property type (Text, Number, Date, Select, Multi-select, URL, etc.).
5. Click Import CSV. Notion creates a new database in your Private workspace.

Merging a CSV into an Existing Database

If you already have a database schema built in Notion and want to populate it with new records:

1. Open the target database as a full page.
2. Click •• at the top → Merge with CSV.
3. Select your CSV file.
4. Map CSV columns to existing database properties. Headers must match property names exactly — a typo, trailing space, or case mismatch will cause Notion to create a new property column instead of mapping to the existing one.
5. Notion appends the rows. It does not update existing rows.

Importing Markdown or HTML

1. Go to Settings → Import → Text & Markdown (or HTML).
2. Upload your .md, .txt, or .html file.
3. Each file becomes a separate Notion page.
4. For batch imports, zip the files first and use the ZIP importer.

Markdown imports support standard headings, lists, and code blocks, but not anchor links or tool-specific Markdown extensions. HTML imports preserve headings, links, simple tables, and images (if assets are bundled), but drop scripts, embeds, comments, and complex layout styling. (notion.com)

Importing a Word Document

1. Go to Settings → Import → Word.
2. Upload the .docx file.
3. Text, headings, lists, images, and basic tables transfer. Comments, tracked changes, SmartArt, WordArt, text boxes, and merged-cell tables do not. If formatting looks wrong, Notion specifically suggests trying an HTML export instead. (notion.com)

Importing from Evernote

1. Go to Settings → Import → Evernote.
2. Sign into your Evernote account and authorize Notion.
3. Select the notebooks to import and click Import.
4. Notebooks appear as pages; notes appear as items in a list database.
5. Expect long import times for large accounts — Evernote's own rate limits can force backoff periods.

Importing from Confluence

1. In Confluence: Space Settings → Content Tools → Export → HTML export (Custom Export, uncheck comments).
2. Download the .zip file.
3. In Notion: Settings → Import → Confluence. Upload the full .zip — do not unzip it.
4. Notion processes the archive and recreates the page hierarchy.

If you're migrating from Confluence, read Confluence to Notion Migration: Limits, Macros & Broken Links before you assume macros will survive.

Importing a PDF (Beta)

1. Type /import on a page and select PDF, or go to Settings → Import → PDF.
2. Upload your PDF. Notion converts the text content into a searchable page.
3. Expect formatting loss: tables become simple tables, bullet lists and numbered lists inside tables are unsupported, and images may not transfer cleanly. Scanned or image-only PDFs should be OCR'd first. (notion.com)

If the real source data is tabular, extract the table to CSV instead of relying on PDF import.

Data Mapping, Structure Behavior, and Formatting Loss

Notion maps imports to its own block/page/database model, not to the source application's full behavior model. That's why imports often preserve content but not system logic.

CSV → Database Property Mapping

When you import a CSV, Notion maps the structure as follows:

• Each row becomes a page in the database.
• Each column becomes a property.
• The first column is mapped to the Title property (which does not support formatting).
• Notion auto-detects property types but often misidentifies them. Numbers with $, %, or negative signs should be mapped to Text to avoid import errors. (notion.com)
• Select / Multi-Select: Notion automatically creates tags for new values. If the case doesn't match (e.g., "Active" vs "active"), Notion creates two separate tags. Values containing commas will be split into multiple options unless you map the column to Text instead.
• Checkboxes: Must be mapped from clear boolean values (true/false).
• Dates: Should be formatted as MM/DD/YYYY or ISO-8601 to ensure Notion recognizes them as Date properties rather than text strings.

If a column contains mixed data types, Notion will default the entire property to "Text" to prevent data loss.

What CSV Imports Cannot Recreate

• Relations between databases — you cannot map a CSV column into a Relation property during import (notion.com)
• Rollups that aggregate across linked databases
• Formulas (the logic, not just the output — Notion uses its own proprietary formula language)
• Created by / Last edited by (auto-generated by Notion)

You need to rebuild all of these manually after import. If you're migrating a multi-table system (e.g., a CRM with Contacts, Companies, and Deals), import each entity as a separate database, then create relation properties and link them — either manually or via the API.

HTML and Markdown Mapping

• HTML headings map to Notion headings. H4 and deeper all collapse to H3.
• Lists and paragraphs map to Notion list and text blocks.
• Code blocks are preserved in Markdown imports.
• Complex styling, scripts, embeds, and comments are dropped.
• Images transfer only if assets are bundled in the same folder or ZIP.
• Google Docs checklists become bullets instead of Notion to-dos. (notion.com)

App-Specific Mapping Behavior

• Evernote: Notebooks become pages, notes become list-database items. Tags don't map neatly to Notion's structure. Ink notes and audio recordings may not transfer.
• Trello: Boards become databases, cards become items, lists become database groups. Custom Power-Up data and automations won't transfer.
• Asana: Projects and tasks map into related Notion databases.
• Confluence: Pages become Notion pages. Many macros flatten to the nearest Notion block type.

What Gets Lost Across All Formats

Regardless of import format, these are never preserved:

• Comments and discussion threads
• Permissions and sharing settings
• Revision/edit history
• Embed blocks (YouTube, Figma, Miro, etc.)
• Advanced layouts (columns, synced blocks, callouts from non-Notion sources)
• App-specific automations, macros, and plugins

For a deeper look at how Notion properties translate to other platforms, see our guide on mapping Notion databases to SharePoint Lists.

Notion Import Limits: File Size, API Constraints, and Rate Limits

These are the hard constraints that determine whether a self-serve import will work at scale.

File Size Limits

(notion.com)

ZIP file count matters as much as size. Notion warns that ZIPs with 10,000+ files are likely to fail or partially import, even when under the 5 GB size limit. Hidden folders (like .DS_Store on macOS) can also cause failures. (notion.com)

Native Import Rate Limits

• HTML and Markdown imports: Approximately 120 file imports per 12 hours. (notion.com)
• Google Docs: One document at a time.
• Evernote: Evernote's own rate limits can force long backoff periods during import.

API Constraints (for Programmatic Imports)

If you're building scripts or using automation tools (Zapier, Make, n8n) to push data into Notion via the API, these limits apply to all pricing tiers with no option to pay for higher limits:

• Rate limit: An average of 3 requests per second per integration. Exceeding this triggers HTTP 429 errors requiring exponential backoff. (developers.notion.com)
• Rich text: Each rich text object is capped at 2,000 characters. Longer text must be chunked into multiple objects.
• Children array: Maximum 100 blocks per array.
• Total blocks per request: Maximum 1,000 blocks.
• Nesting depth: Only 2 levels of nested children per request.
• Payload size: Maximum 500 KB per request.
• Relation values: Capped at 100 related pages per request. (developers.notion.com)

// Example: chunking text for Notion's 2,000-char rich text limit
function chunkText(text, size = 2000) {
  const chunks = [];
  for (let i = 0; i < text.length; i += size) {
    chunks.push({ type: 'text', text: { content: text.slice(i, i + size) } });
  }
  return chunks;
}
 
// Use in a page creation request
const page = await notion.pages.create({
  parent: { database_id: dbId },
  properties: {
    Description: { rich_text: chunkText(longDescription) }
  }
});

These limits compound quickly. A page with 200 paragraph blocks requires at minimum 2 API calls (100 blocks each). A deeply nested outline with 5 levels of bullet lists requires recursive requests — the first call creates the top 2 levels, then subsequent calls add children at levels 3, 4, and 5. At 3 requests per second, a workspace with thousands of pages can take hours of wall-clock time.

Edge Cases: Duplicates, Encoding Errors, and Scale Problems

These are the failure modes that catch teams off guard in real migrations.

Duplicate Records from CSV Merges

Notion's Merge with CSV has no concept of a unique key. Every merge operation appends. If your workflow requires periodic data syncs — say, importing an updated CRM export every week — you will accumulate duplicates unless you delete existing rows before each import or use an external tool.

To update existing records without creating duplicates, you cannot use the native UI. You must either use the API to query the database, find matching records, and issue PATCH requests, or use a third-party tool. Open-source tools like csv2notion-neo treat the first column as a merge key and offer flags like --fail-on-duplicates to validate before writing. Spaceloadr lets you select a unique identifier (email, ID) to update existing records instead of duplicating them.

UTF-8 Encoding Issues

Notion expects CSV files encoded in UTF-8. Files exported from older Excel versions or regional systems (ANSI, Windows-1252, Shift-JIS) produce garbled characters — accented letters, currency symbols, and CJK characters are the usual victims.

Fix: Before importing, re-export as UTF-8. In Excel: File → Save As → CSV UTF-8 (Comma delimited). Or open the file in Google Sheets and download as CSV. (notion.com)

Multi-Tab Spreadsheets

Notion's CSV importer only processes the first sheet/tab. If your Excel workbook has multiple tabs (e.g., Contacts, Companies, Deals), export each tab as a separate CSV and import them individually.

Large Dataset Performance

Notion databases don't enforce a strict row cap, but performance degrades as databases grow. Databases with 10,000+ rows become noticeably slower to load, filter, and sort in the UI. Imports of very large CSVs can time out or partially complete without clear error messages.

Best practice: Split large datasets into multiple databases or import in batches. If your dataset exceeds 10,000 rows, consider whether Notion is the right storage layer or whether a synced view from an external database would serve better.

Missing Images and Attachments

For HTML and Quip exports, image assets must travel with the import bundle. Broken relative paths are a common reason media disappears after import. Bundle images in the same folder or ZIP, and download any externally referenced images before importing. (notion.com)

Scanned PDFs

Notion's PDF import works best with text-based PDFs. Scanned or image-only PDFs produce unstructured or empty pages. Run OCR before importing. (notion.com)

Preparing Data Before Import

Clean data before it enters Notion. Fixing formatting problems after import — inside a block-based editor with no bulk-edit tools — is painful.

For CSV / Spreadsheet Imports

• Deduplicate before import. Notion won't do it for you.
• Ensure UTF-8 encoding. Re-save from Google Sheets if in doubt.
• Use unique, descriptive column headers. Notion rejects duplicate column names.
• Keep data types consistent within each column. Mixing dates and text in one column causes misdetection.
• Remove empty rows and columns. They create blank pages or phantom properties.
• Strip formula columns. Export calculated values, not formulas. Notion can't interpret external formula syntax.
• Map your target schema first. Create the Notion database structure before using Merge with CSV.
• Add a stable External ID column. This gives you a deterministic key for QA, deduplication, rollback analysis, and later API upserts.
• Normalize dates as MM/DD/YYYY. This is the format Notion documents for CSV imports.

External ID,Company,Status,Owner Email,ARR,Renewal Date
acct-1001,Acme,Active,owner@example.com,12500,04/30/2026
acct-1002,Globex,At risk,csm@example.com,9800,05/15/2026

For Markdown / HTML Imports

• Flatten deeply nested structures. Notion handles 3–4 levels of nesting well; deeper hierarchies become difficult to navigate.
• Bundle images in the same folder. If images reference external URLs that may expire, download them first.
• Remove scripts and dynamic content. Notion ignores <script> tags, iframes, and embedded widgets.
• Test with a small batch first. Import 5–10 representative files before committing to a full migration.

For App-Specific Imports

• Confluence: Use HTML export (not XML). Audit file count — if the space has thousands of attachments, you may exceed the 10,000-file threshold. Split large spaces before export.
• Evernote: Expect long import times for large notebooks due to Evernote's own rate limits. Images may need manual cleanup.
• Trello: Custom Power-Up data and automations won't transfer.
• Google Docs: For bulk migration, repeated native imports can fail intermittently. Exporting through Google Takeout as .docx and importing in smaller batches is the safer fallback. (notion.com)

Real Migration Scenarios

Migrating a CRM from Google Sheets

A RevOps team has a Google Sheets CRM with three tabs: Contacts (4,000 rows), Companies (800 rows), and Deals (2,500 rows). Each tab has columns that reference the others.

Approach:

1. Export each tab as a separate UTF-8 CSV. Add an External ID column if one doesn't exist.
2. Create three empty Notion databases with the target schema, including relation properties linking Contacts ↔ Companies and Deals ↔ Companies.
3. Import Companies first (fewest rows, referenced by others).
4. Import Contacts using Merge with CSV. The relation column values must match existing Company names exactly.
5. Import Deals the same way.
6. Verify that relations populated correctly. For large datasets, use the API to backfill.

What breaks: Formulas (VLOOKUP, SUMIF) don't transfer. Conditional formatting is gone. Cell references across tabs become plain text.

Importing Blog Content from a CMS

A content team has 200 blog posts exported as HTML files from a headless CMS.

Approach:

1. Ensure all image assets are bundled in the same directory as the HTML files.
2. Zip the entire folder.
3. Import via Settings → Import → HTML (upload the ZIP).
4. Each HTML file becomes a Notion page.
5. Manually review for formatting issues: images that didn't transfer, headings collapsed from H4 to H3, and broken internal links.

What breaks: Embedded media (YouTube, CodePen). SEO metadata (title tags, meta descriptions). CMS-specific shortcodes or widgets.

Moving from Evernote to Notion

An individual has 15 Evernote notebooks with 3,000+ notes, including clipped web pages and annotated PDFs.

Approach:

1. Use the native Evernote importer: Settings → Import → Evernote.
2. Sign in, select all notebooks, and import.
3. Expect the import to take several hours for large accounts due to Evernote's rate limiting.
4. After import, audit image rendering (Evernote web clips often produce broken formatting) and manually clean up.

What breaks: Evernote tags don't map neatly to Notion's structure. Ink notes and audio recordings may not transfer. The importer only supports the standard Evernote edition.

When Native Import Is Not Enough

Notion's built-in import tools work for straightforward, one-time moves of small-to-medium datasets. They fail when:

• You need to preserve cross-database relations across thousands of records. CSV import can't map to Relation properties, and there's no deduplication.
• Your dataset exceeds comfortable UI thresholds. Databases over 10,000 rows degrade in performance, and large ZIP imports with 10,000+ files fail silently.
• You need incremental syncs, not one-time imports. Merge with CSV only appends — there's no update or delta sync.
• Rich text fields exceed 2,000 characters. Automation tools like Zapier and Make hit this limit regularly, causing truncation or failures.
• You need to map complex nested hierarchies. The API's 2-level nesting limit and 100-block-per-array cap mean deeply structured documents require recursive, rate-limited API calls.
• You need zero downtime. A botched import that creates thousands of duplicate rows or partial pages in a live workspace has real operational consequences.

Zapier and Make are row-by-row automation tools, not bulk importers. They expose create/update actions but still hit every Notion API constraint. In practice, they're better suited to low-volume automations than historical backfills. (help.zapier.com)

For these cases, you need custom scripts that handle Notion's API constraints (chunking, rate limiting, retry logic, deduplication) or a team that has done it before.

For an in-depth look at the trade-offs of flat-file migrations across SaaS platforms, see our guide on using CSVs for SaaS data migrations.

Making the Right Call

Notion's native import is capable for simple migrations — a CSV with 500 rows, a folder of Markdown files, a small Evernote account. The column-mapping UI for CSV imports works well. The Confluence and Trello importers save significant manual work.

But the moment your migration involves relational data across multiple databases, datasets larger than a few thousand rows, or ongoing sync requirements, the native tools hit hard limits. The API is powerful but punishing: 3 requests per second, 100 blocks per array, 2,000 characters per text object, 2 levels of nesting per call. Building reliable scripts that handle all of these constraints is a multi-week engineering project.

Use native import when the destination can tolerate a flat, append-heavy landing zone. Add stable external IDs, pilot with real edge cases, and assume you'll rebuild logic after content lands. If you want the workspace to stay portable later, structure the import with future exports in mind — our guide on how to export data from Notion is worth reading before you lock in your schema.