---
title: Import from Notion, Lark, Google Docs, Confluence and Evernote
description: Move a whole Notion workspace into Notes with an integration token, or bring a Notion export, Lark or Google docs, Word files, a Confluence space, Evernote notebooks or a folder of markdown, with nesting and links kept and a preview before anything is written.
section: globe
order: 35
audience: [user]
sources: [services/nodejs-cloud/components/globe/import, services/nodejs-cloud/lib/globe/importers/pages.ts, services/nodejs-cloud/lib/globe/importers/pages-read.ts, services/nodejs-cloud/lib/globe/importers/csv.ts, services/nodejs-cloud/lib/globe/importers/docx.ts, services/nodejs-cloud/lib/globe/importers/apps.ts, services/nodejs-cloud/lib/globe/importers/html.ts, services/nodejs-cloud/lib/globe/importers/xml.ts, services/nodejs-cloud/lib/globe/import-pages.ts, services/nodejs-cloud/app/globe/api/import/pages, services/nodejs-cloud/lib/globe/import-notion, services/nodejs-cloud/app/globe/api/import/notion, services/nodejs-cloud/app/globe/api/import/jobs, services/nodejs-cloud/lib/imports, services/nodejs-cloud/migrations/0306_globe_import_sources.sql]
features: []
---

Open **Import** from the upload button above the file tree in Notes, or go to `/globe/import` (workspace **Settings → Move
in** links here too). **Move in from Notion** at the top reads a whole Notion workspace on the server with a token you
paste. Every other card takes a file: choose it, or drop it on the card. Notes reads those files in your browser, shows
a preview, and writes nothing until you press **Import**; for them it never contacts Notion or any other service.

## Move in from Notion {#move-in}

1. **Create an integration and share pages with it.** In Notion, open **Settings → Integrations** (or
   [notion.so/profile/integrations](https://www.notion.so/profile/integrations)), create an internal integration for
   your workspace with **Read content**, and copy its secret. Then share the pages to bring with it: a page's **••• →
   Connections → your integration**. Sharing a top-level page shares everything under it. The integration sees only
   what you share.
2. **Paste the secret and press Check.** The preview is read from Notion's search and needs no decisions: the
   workspace's name, how many pages, databases and database rows the integration sees, the titles that land at the top
   of the vault, what does not come over, and about how long it takes (Notion answers about three requests a second).
   It goes into the vault you have open when you can write it, else your own. The preview also says how many more
   notes the vault can take (a vault holds 20,000) and warns when Notion has more than that; the import then stops
   cleanly when the vault is full, with what fit. **Adjust** has two choices: bring files and images (on), and how
   much to store (200 MB unless you change it, up to what your organisation's file storage has left). Nothing is
   written yet.
3. **Press Import.** The import runs on the server: it finds every page, lists every database's rows, plans where
   each lands, creates the databases, then reads and writes the pages, and last turns links to pages that could not be
   written back into Notion links. A progress bar shows the phase and the counts; you can close the page and come back,
   **Pause** and **Resume** it, or **Cancel** it (what came over is kept). It ends with the counts and notes on what
   could not be brought.

**Sync.** After an import finishes, **Sync again** asks for the secret again. Pages Notion has not changed since the last
run are not read again; changed pages are read and their notes updated. Notion gives edit times to the minute, so a
page last edited in the same minute the last run read it is read again and written only if what it becomes changed.
A note edited in Notes after the import wrote it is not overwritten: it is counted as "changed here, kept". A page
Notion no longer lets the integration read keeps the text an earlier run brought. Nothing is duplicated, files are
not stored twice, and a note you moved stays where you put it. Pages deleted in Notion are not deleted here. There is
no schedule; a sync runs when you press it.

Notes from an earlier **Notion export** (zip) import are not matched: moving in over them makes new notes beside them
(with a ` 2` after the name where the path is taken). Delete the zip-imported notes first, or move in into another
vault or folder.

### What comes over {#move-in-fields}

| Notion | Becomes |
|---|---|
| Pages | notes, nested as in Notion: a page's subpages live in a folder named after it; a page whose parent the integration cannot see lands at the top of the vault |
| Headings, text, lists, to-dos, quotes, code, dividers, equations | the same in markdown (bold, italic, strikethrough, inline code and links kept) |
| Toggles and callouts | a bold list item with its contents indented; a quote with the callout's emoji |
| Tables | markdown tables |
| Columns | their contents in order, one column after the other |
| Synced blocks | their contents, where they appear |
| Child pages, links to pages, page mentions | `[[links]]` to the notes; a link to a page the integration cannot see stays its Notion link |
| Mentions of people and dates | the person's name; the date |
| Bookmarks, embeds, link previews | links |
| Images and files uploaded to Notion | downloaded during the import and stored as Notes files in the same vault, at most 25 MB each and up to the import's size limit (200 MB unless you chose otherwise); past the limit each file is a line, `*(file not imported: over the import's size limit: name)*`, counted in the summary. Notion's links expire within the hour: a link that expired while the import worked is asked from Notion again. A file is stored once: a retry or a later sync reuses it (by its Notion block and by its content). An external image or file stays a link |
| Databases | Notes databases over a folder of their rows; each row is a note with its values as properties |
| Database properties | title, text, number, select, multi-select, status (with its groups), date, checkbox, URL, email, phone and files keep their type; people, created by and edited by become text with names; relations become text with `[[links]]` to the related rows; formulas and rollups become text holding the value they had in Notion (they do not recompute here); unique ids become text like `TSK-12`; created and edited times become dates |

**Not brought:** comments, database views (each database gets the default table of Notes), page icons and covers, buttons
and other property types Notes has no form for (named in the notes), and anything not shared with the integration.
Nothing is dropped silently; each of these is a visible line where it was, counted in the summary:

| Line | When |
|---|---|
| `*(unsupported Notion block: type)*` | a block type Notes has no form for |
| `*(Notion block not shared with the integration)*` | Notion would not give a block's contents (a synced block copied from a page not shared with the integration, say); the rest of the page comes over |
| `*(deeper nested content was not imported)*` | content nested more than 20 levels deep |
| `*(rest of this page was not imported)*` | a page over 5,000 blocks (the first 5,000 come over), a page that still had not been read after 8 steps of the import (what was read comes over), and a note longer than Notes holds |

A big page is read over several steps: each step carries on where the last stopped. A page Notion keeps refusing
(three tries) is skipped with a note naming it and the reason; the import goes on. A page or database title too long
for a note's path (300 characters) is shortened, with a note. A relation, people or text property with more than 25
values in Notion brings the first 25 (what Notion gives with a page), with a note. Text and titles are checked for
key-shaped strings (API keys, tokens, private keys), which are replaced with `[secret removed]` before anything is
stored. Notion's text stays text: characters markdown would read as a link, a `[[wikilink]]`, math, HTML, a table
border, a heading or a list are escaped, and only `http`, `https` and `mailto` addresses become links. A later sync
does not change a database's properties.

Each database's rows are listed with Notion's database query (`POST /v1/databases/{id}/query`), since Notion's search
can leave rows out. A database Notion keeps as several data sources (Notion's newer API) may refuse that query at the
version Venom uses; the import then notes it and brings the rows the search found.

### The token, and what Venom Cloud calls {#move-in-token}

Venom Cloud calls `api.notion.com` (Notion-Version `2022-06-28`) only after you paste a secret and press Check or
Import. It downloads files only from the addresses Notion returned for files uploaded to Notion: https, on Notion's
file storage (`prod-files-secure.s3.us-west-2.amazonaws.com`, `file.notion.so` and Notion's content hosts), public
addresses, at most 25 MB, no redirects. Those links are already signed by Notion, so the secret is never sent with
them.

The background job needs the secret while it runs, so it is sealed in the vault (the same encryption as the
organisation's provider keys, bound to the organisation and the job) when you press Import. It is deleted when the
import finishes, fails for good or is canceled, and in any case 24 hours after it started. It is never shown again or
written to a log, an error or the audit log. If it is deleted while a job is paused, cancel and move in again with a
new secret: nothing is duplicated.

Only an internal integration's secret works today. Connecting with Notion's OAuth needs a public Notion integration
registered for your Venom Cloud; the import takes any bearer token, so that can be added without changing it.

A job is seen and controlled by the member who started it and by those who manage Notes, with one exception: an import
into someone's own vault shows others only that it exists, its state and its counts (no titles, notes or preview), and
only its starter can pause, resume or cancel it. One Notion import runs at a time per vault, so two members can each
move their own Notion in at once; starting a second into the same vault says whose import is running there. The org
vault needs the `org:manage` permission, as for the other imports.

### Agents {#move-in-agents}

Agents follow and steer an import over MCP with `globe_import_job_list`, `globe_import_job_get` and
`globe_import_job_update` (pause, resume, cancel). There is no tool to start one: that takes the secret, and a secret
in a tool argument stays in the agent's transcript.

### API {#move-in-api}

| Route | What |
|---|---|
| `POST /globe/api/import/notion/check` | `{token, vault?}`: the preview. Reads Notion, writes nothing, keeps nothing |
| `POST /globe/api/import/jobs` | `{source: "notion", token, vault?, files?, fileBytes?}`: starts the job (201). `fileBytes` is the import's file size limit (default 200 MB, held to the organisation's storage left). 409 `import_running` while an import into the same vault runs, `import_finishing` while a canceled one's last step ends |
| `GET /globe/api/import/jobs` | your imports, newest first (never the token); for those who manage Notes, everyone's, with someone else's personal-vault import reduced to its state and counts |
| `GET /globe/api/import/jobs/[id]` | one import: status, phase, counts, notes |
| `PATCH /globe/api/import/jobs/[id]` | `{action: "pause" \| "resume" \| "cancel"}` |
| `POST /globe/api/import/jobs/[id]/step` | works on a running import for up to about 40 seconds; the open page calls it, and the imports cron (`/api/cron/imports`, every minute) carries on without it |

## Notion export (a zip) {#notion-export}

The offline way: no token, nothing fetched from Notion.

1. In Notion, open **Settings → General → Export all workspace content**, or use a page's **••• → Export**.
2. Choose **Markdown & CSV** and tick **Include subpages**. Download the zip.
3. On the Notion card, choose the zip. A large export arrives as several zips: choose them all at once.

What you get in Notes:

- **Pages become notes** and keep their nesting. A page with subpages becomes a note beside a folder of the same name.
  Notion's 32-character ids are dropped from names, and the page title heading is dropped because the note's name is
  its title.
- **Databases become Notes databases.** Each CSV becomes a database over the folder of its rows. Notes guesses a type
  for every column from its values: checkbox (`Yes`/`No`), number, date (including ranges and times), URL, email, select
  and multi-select (a short list of repeated values), otherwise text. The row pages become the row notes, with the
  values stored as the note's properties. Notion's relation and rollup columns come across as text.
- **Links between pages become `[[links]]`**, including links to other pages by their notion.so address. A link to a
  database becomes plain text. A link to a page that is not in the export becomes plain text and is counted.
- **Callouts** (`<aside>`) become quotes and toggles keep their title in bold.
- **Images and files are not imported.** A note says where each one was (`image not imported: name.png`), and the
  preview counts them.

## Lark / Feishu Docs, Google Docs and Word

Download your documents as Word files and choose them on the **Lark / Feishu Docs** or **Google Docs and Word** card:

- Lark or Feishu: open a doc, then **••• → Download as → Word (.docx)** or **Markdown**.
- Google Docs: **File → Download → Microsoft Word (.docx)**, or **Web page (.html, zipped)**. For many documents use
  [Google Takeout](https://takeout.google.com) and choose Drive; the zip of `.docx` files can be chosen as it is.
- Word: choose the `.docx` files.

Each document becomes one note named after the file. Headings, bold, italic and strike-through, links, bullet and
numbered lists with nesting, and tables come across. A first paragraph in the Title style is dropped because the note's
name is its title. Images are not imported and are counted in the preview. Comments and tracked changes are left out.

## Confluence

In the space, open **Space settings → Content tools → Export → HTML**, download the zip and choose it on the
**Confluence** card. A page's place under its parents becomes folders (a parent page is a note beside a folder of its
children), links between pages become `[[links]]`, and tables, lists, code and quotes are converted. Attachments and
images are not imported.

## Evernote

Select a notebook (or notes) in Evernote and use **File → Export** with the ENEX format, then choose the `.enex` files on
the **Evernote** card. Each notebook becomes a folder and each note a note in it, with its tags, dates and source address
as properties. Lists, tables, to-dos (`- [x]`) and formatting are kept; attachments and images are not imported.

## Markdown folder

Choose a zip of `.md` files, or select several `.md` files. This works for Bear, Logseq, Joplin, Docusaurus, a GitHub
wiki, or notes you wrote by hand. Folders are kept, front matter becomes the note's properties, `[[wikilinks]]` are left
alone and relative links such as `[plan](/docs/plan.md)` become `[[links]]`. Hidden folders (such as `.obsidian`) and
non-markdown files are skipped.

For an Obsidian vault use the **Obsidian vault** card. It sends the zip to Notes, which keeps attachments out, updates
notes at the same path and keeps your links.

## The preview

After reading, Notes shows how many pages, databases and rows it found, how many links it rewrote, how many it could not
resolve and how many attachments it left out. It says how many notes already exist at the same path and would be
updated (their old text is kept in each note's history). **Put everything in this folder** is filled in with `Notion`
for a Notion import; clear it to import into the top level of the vault, or type another name. The counts and the links
update as you type.

Press **Import** to send the notes in batches. **Stop** halts after the current batch. If something goes wrong you can
choose the files again: notes already imported at the same path are updated, not duplicated, and a folder that already
holds a database is left as it is and listed in the summary.

## Limits

| What | Limit |
|---|---|
| One text file (page or CSV) | 8 MB; a note's body is at most 200 KB, larger pages are skipped and counted |
| One request | 400 notes, about 4 MB. The page batches for you |
| A Word file | 50 MB |
| Read in the browser | 400 MB of text in total; images and other files are never read |

You need write access to the vault. Importing into the org vault needs the `org:manage` permission. Anything that looks
like a secret is refused and counted as skipped. The routes are in the [Venom Notes API](/docs/cloud/globe-api.md#pages-import).
To bring in your ChatGPT and Claude history, see [Import from ChatGPT and Claude](/docs/globe/import-from-ai.md).
