Skip to content
flowplanDocumentationCommunityMarketplaceStart page

Moving, import and export

Import, content archive and versions

Content comes in as Markdown, CSV or an archive and goes out again as Markdown, PDF or a complete archive. The version history brings back earlier states.

12 min read

On this page
  1. Import
  2. Frontmatter: records as Markdown files
  3. Content archive
  4. Version history

More on this topic: Export · Printing and PDF

Import

All imports are under Settings → Import & export → Import; at the top you choose the Target space once for all of them.

  • Markdown, text or HTML: Markdown, text or HTML files. Headings, lists, tasks, tables, code and formulas become blocks; Mermaid code (```mermaid, in HTML <pre><code class="language-mermaid"> or <div class="mermaid">) becomes a code block that shows the diagram – the code is one click away (preview). This applies to every import, including AFFiNE, Notion, Obsidian, Confluence (the language of code macros) and pasted Markdown. Image titles and Table:/Listing: lines become captions, in HTML <figure>/<figcaption> and <caption>. The AFFiNE import takes over the captions of images and code blocks.
  • Notion, AppFlowy or Markdown export: Notion, AppFlowy or Markdown export (ZIP) accepts a ZIP with Markdown and CSV files. Markdown becomes pages, CSV databases, days of a Flowplan journal (…/2026/10/2026-10-27.md below the journal) days of that journal again, Excalidraw and draw.io files whiteboards, folders sub-pages; linked images and files are uploaded, and Notion record pages are matched to their records. A Markdown export from Flowplan (a page or a space as ZIP) comes back with its page tree, titles and databases including their records; comments and earlier versions in the export are left out. Up to 100 MB, by default 10,000 pages (FLOWPLAN_IMPORT_MAX_DOCS) and 5,000 records per table; single files in the ZIP may be as large as the largest upload (at least 10 MB), and ZIPs inside it – such as the “Export-…-Part-1.zip” of large Notion exports – are unpacked too, as long as everything together fits the import's limits. You choose the target space beforehand.
  • Jira or Trello: Jira or Trello – see Projects, tickets and sprints.
  • Since 0.10.0 Anki: a deck (.apkg) or the collection (.colpkg) becomes flashcard databases – see Import and export flashcards.
  • CSV: in a database, choose Import CSV or Markdown and pick a CSV file; the rows become records. A CSV exported from Flowplan comes back as it was: text that looks like a formula (=…, +…, @…) gets a protective apostrophe on export, which the import removes again; tags containing a comma (such as “Night, Weekend”) stay one tag when the column's options include it. The import finds people, related records, files and sprints by their name (people also by e-mail address) and links them again – but only when the name is unique: if two records are called “Meeting”, the cell stays empty rather than linking the wrong one. Columns missing from the file are left out instead of being emptied.
    • Reading values: empty number cells stay empty (not 0), so sums and filters such as "is empty" still match after re-importing. Numbers may use a decimal comma and thousands separators ("1,5", "1.234,56"), checkboxes may also read Yes/No, x or ✓, dates also 05.11.2026. A file with a single column (say, a view that shows only the title), short rows and trailing commas work too; only a broken quote makes the file unreadable.
    • If a value does not fit a number, date or checkbox property (such as "2026-02-30"), Flowplan refuses the import and names the property – instead of dropping the value or storing it as text.
    • New options: values that a select or multi-select property does not have as options yet are added as new options; a different letter case uses the existing option. At most 100 new options per import – a free-text column mapped to a select property is refused rather than creating thousands of options. A notice says which options were added to which property.
  • Markdown with frontmatter into a database (such as notes from Obsidian): in the database, choose Import CSV or Markdown and pick one or more .md files or a ZIP – see below.
  • Content archive (see below).

Frontmatter: records as Markdown files

Notes from Obsidian, Logseq, Jekyll or Hugo carry their properties as YAML frontmatter at the top of the file:

---
para: Resource
area: House
tags: [heating, maintenance]
created: 2026-03-14
---
# Heating – maintenance
…

Import into a database: every file becomes a record. The title comes from title:, otherwise from the first # heading or the file name; the rest of the text becomes the record's document, linked images and files from the ZIP are uploaded, and links between the imported files become links to the new records. Keys are matched to properties of the same name (case does not matter):

  • select and multi-select take the values and add unknown ones as new options (so tags: lands in Tags);
  • relations find the linked record by its title (also as [[Title]]), people by name or e-mail;
  • dates are read as ISO dates, true/false as checkboxes, numbers as numbers;
  • aliases: (a list or one text, separated by commas) and alias: together fill the property of type Aliases, whatever its name; if there is none, Create missing properties adds one. A database without an aliases property but with a property named "aliases" gets the values there, as before;
  • computed properties (formulas, rollups, timestamps) are not overwritten.

When importing records (Markdown, CSV) into a multi-select with the workspace's tags, the values stay names; missing tags are created if you may create tags (members with edit rights) – otherwise such values are left out.

Before the import, a preview shows which properties match and which are missing. Create missing properties adds them with a fitting type: list → multi-select, ISO date → date, true/false → checkbox, number → number, address → URL, a few recurring values → select, otherwise text. Up to 5,000 files and 100 MB per import.

Export: in the ZIP export, every record under records/ starts with title: and its properties: select as text, multi-select and relations (titles of the linked records) as lists, dates as ISO dates. Aliases are written under Obsidian's key aliases: as a list, so they survive a trip to Obsidian and back. Computed values and the record's id are below flowplan: and are skipped on import. When a record exported this way is imported into the same database again, the preview offers update instead of adding: the record with the same id gets the file's properties and text, and the previous state stays as a version. Without this choice it is added as a new record.

Pages: a page's aliases, tags and properties are written by the Markdown export (single page, space export, scheduled export and Git export) as frontmatter at the top of the file – the way Obsidian reads them:

---
tags:
  - Customer
  - Offer
Status: Sent
Budget: 12500
Due: 2026-12-01
Owner: Emil Example
---
# Offer Müller Ltd

People appear by name, multi-selects as a list, checkboxes as true/false; the automatic properties (created at …) are left out. Pages without aliases, tags and values keep no frontmatter.

When importing Markdown files, Markdown ZIPs and Obsidian vaults under Settings → Import & export, aliases:/alias: becomes the new page's aliases and tags: (or tag:, as a list or “a, b”) its tags; missing tags are created. Further keys become properties: if the workspace already has a property with that name, the page gets its value there. Unknown keys are created as new properties only by workspace owners – the type follows the value (true → checkbox, number → number, 2026-12-01 → date, list → multi-select, URL, email, otherwise text). Keys of publishing tools (cssclass, publish, permalink, layout, slug, draft …) never become properties. When the whole frontmatter is taken over, it disappears from the text; otherwise it stays in the text as before. The Git export reads aliases, tags and values of changed pages back from the repository.

Where to export: in a database's toolbar, Export opens a menu with CSV (current view), Markdown with files (.zip), Markdown (.md) and As Word (DOCX). A single record is exported from the … menu in its header: Export as Markdown (.md) (with frontmatter), Markdown with files (.zip), As Word (DOCX) (properties as a table, then the document) or Print / PDF – with the same print options; Properties there means the record's fields.

CSV (current view) writes the view's visible columns in their order (board, gallery and other card views always with the title) and the values as the table shows them: people (also Created by / Edited by) by name, related records by title, uploaded files by name (links stay links), sprints by name. Numbers, dates and checkboxes are written as stored. If a person's name isn't unique, their e-mail address is written instead. The CSV in the Markdown ZIP still holds all properties.

From Obsidian: links in the text are read as standard Markdown links. Convert wikilinks ([[…]], ![[…]]) first – in Obsidian, Settings → Files and links, turn off “Use [[Wikilinks]]” and choose relative paths.

Content archive

Under Settings → Import & export → Export → Workspace as ZIP you download a ZIP of your workspace. To bring it back – also into another Flowplan instance – use Backups → Restore a Flowplan archive: the archive is created as a copy in new private spaces.

Backing up the whole instance (with accounts and permissions) is up to the administration: Administration → Storage & backup. The card Trash & retention leads to the trash and says how long things are kept: deleted pages and spaces until someone deletes them permanently, deleted database records 30 days; how long earlier versions stay is set by the administration.

It contains: accessible pages including the trash, databases with views and records, document content, relations, templates, comments, versions, favourites and form options, plus all files with checksums. Also the settings of databases (done rule, workflow, automations, sprints, story points – never the Git token), time entries and the status history behind burndown charts, the settings and trackers of journals with each day's values and place, handwriting on PDFs and your home page (applied only when the person importing has none of their own yet).

The workspace's tags and properties (unused ones too) and every page's tags and values come along as well. Importing creates missing tags, and missing properties only if you own the target workspace; existing ones with the same name are reused.

The workspace's appearance with its uploaded fonts and its automatic links come along as well (the JSON export holds both, without the font files): on restore only an owner of the target workspace takes them over – link rules in addition to the existing ones (an existing rule with the same pattern stays, at most 50), the appearance only where Flowplan's own look still applies. Whatever fails the settings' checks (an invalid rule, not a font file, over 5 MB, more than 20 fonts, storage quota full) is left out and counted in the message without stopping the import.

The archive only holds what you may see yourself: other people's private records with their comments and files are left out, as are journals behind a PIN you have not unlocked right now. Versions of a database are included only for owners, because they contain every record. Each version holds the whole database; when not all of them fit into the archive of a large database, the newest come along and older ones stay behind – the current records are always included.

  • Importing creates new IDs; internal links and relations are rewritten – embedded whiteboards, synced blocks, metrics, drawing blocks and records on whiteboard cards too.
  • If the archive comes from someone else, their assignments and mentions become yours; tasks in documents show under My tasks right away.
  • Older archives import as before; older servers skip what they do not know.
  • Imported spaces and templates are private, shares and forms are not active.
  • A failed import is rolled back completely.
  • Limits: 2 GB ZIP, 20,000 files, 50,000 pages, 200,000 records per database and 64 MB for pages, records, comments and versions without the files (the file flowplan.json in the archive) – depending on the content, enough for around 100,000 records. The same limit applies to export, import and restore; database versions only go along as long as they fit.

Accounts, sessions and sign-in are not part of it – operations back them up every day with the whole instance.

Version history

Page actions → Version history:

  • Documents save automatically at most every five minutes, databases before the first change after ten quiet minutes.
  • Save current version creates a state at any time; manually saved versions are kept permanently.
  • Changes compares a version with the current state or with any other version (Compare with): added and removed text, for databases new, changed and removed records and properties.
  • The comparison in detail: it walks the document block by block – headings, paragraphs, list items, table cells, quotes and code stay recognisable as such – and marks the single words inside a changed block: additions green, deletions red and struck through; unchanged blocks are dimmed. A summary states how many words came and went (for example "+120 words · −35 words"), and the arrows jump from change to change, also by keyboard. The same applies to the versions of a record document. Very long documents (more than 60,000 words on both sides together) or versions that differ in too many places are reported as too large to compare; they can still be restored.
  • Bring back single paragraphs: compared with the current state, every removed or changed paragraph has a Restore button. The paragraph returns to its old place with its formatting; the rest of the page stays as it is.
  • Restore sets the page back to that state. The authors view then starts over; the restored text appears as "earlier".
  • Databases come back with properties, options and records – and with the settings that name options: done rule, workflow, automations and the issue sync's status mapping, as they were then. So restoring the version from before an option rename doesn't leave the done rule on the new name. An automation that comes back changed then acts for the person who restored it. Older and imported versions leave the settings as they are.

Automatic versions are thinned out to one per day after seven days and deleted after 180 days (adjustable in the administration).

Was this helpful?
YesThanks!
No – tell us what's missing

Found a mistake or something missing?Edit on GitHub