Import and export

Repeto can import and export Anki .apkg deck packages. Treat transfer as a reviewable operation: inspect the package summary, warnings, templates, and media before depending on the imported collection.

Import an Anki package

Open Import, then drop or choose an .apkg file. Repeto uploads the package as a resumable background job and prepares a preview before writing it to your collection.

The preview lists:

• decks and their note/card counts;
• note models found in the package;
• media count;
• whether scheduling data is present;
• package-specific warnings.

You can optionally replace the package’s top-level deck name. A package with several decks keeps its hierarchy unless you provide an enclosing target name.

Choose what to preserve

When scheduling data exists, Keep scheduling and review history is enabled by default. Turn it off when you want the material but intentionally want a fresh learning state.

Use Repeto styling is also enabled by default. It lets Repeto’s theme shell control the card colors while preserving the imported content and template structure. Turn it off when the package’s original visual design is essential, then check both light and dark modes.

Media is matched through the package manifest and stored as durable collection media. A later import can restore missing media even when the corresponding cards already exist.

Re-import an updated .apkg

When package notes match existing notes by GUID and note type, choose one explicit policy: Update existing notes, Ignore existing notes, or Add everything as new. Repeto blocks identity conflicts rather than guessing that two incompatible note types are the same.

A compatible update preserves the existing note, card, field, and template identities along with card placement, schedule, FSRS state, flags, and review history. It updates the imported content and can add genuinely new siblings without resetting the established cards. Add everything as new creates independent identities and fresh schedules.

Long-running imports

Large packages continue as jobs. Repeto stores the current import ID locally and restores the preview or result after navigation or reload. Do not upload the same file repeatedly while a job is processing; open the existing job page first.

If the browser reports a package error, export the deck again from its source application and retry with the new file. Corrupt SQLite data, unsupported compression, and missing media entries should appear as warnings or an import failure rather than partially trusted cards.

Export a deck

Open a deck and choose Export .apkg. Repeto downloads the deck with its nested names, notes, cards, note types, templates, media, and supported scheduling data.

Use the downloaded package to:

• keep an independent snapshot before structural changes;
• move a deck to another compatible application;
• share a deck privately;
• test import/export round trips.

Not every Anki desktop feature has a Repeto equivalent. Filtered-deck execution state, buried state, add-ons, custom template scripts, and unsupported scheduler metadata may not round trip exactly. Review the exported package in the destination before deleting the source.

Import structured text

Open Import, choose CSV or TSV, then choose or drop a UTF-8 .csv, .tsv, or .txt file. The web importer accepts files up to 5 MiB and 10,000 data rows. Preview detects common delimiters, handles a byte-order mark, quoted multiline fields, escaped quotes, and row-width problems.

Before preview, choose the note type and deck, optional tags, delimiter and HTML handling, duplicate policy, and whether duplicate matching is limited to the note type or also to the selected deck. The importer understands #separator, #html, #notetype, #deck, #tags, #columns, and GUID, note-type, deck, and tags column directives before the first data row; explicit choices in the screen override matching file directives.

After preview, map each source column to one note field, tags, GUID, per-row deck or note type, or Ignore column. You can treat the first row as headings. Repeto shows diagnostics and a row plan describing every create, update, skip, or invalid row. Duplicate handling is explicit: Update the matching note, Skip the imported row, or Add another note. A GUID update preserves the existing cards, schedules, and review history and never performs an implicit note-type conversion.

Changing the file, mappings, or settings makes the plan stale and requires another preview. Commit is enabled only after you confirm that you reviewed the exact row plan. It accepts only the file and choices represented by the user-bound preview token, reconstructs the plan, applies it atomically, preserves existing card IDs, schedules, due dates, intervals, scheduler state, and review history when a note is updated, and makes an exact retry idempotent.

The browser stores the selected file, options, and preview locally so a reload can restore an uncommitted plan or safely retry an interrupted commit. Keep the page open if the browser reports that local preview recovery is unavailable.

You may stage up to 100 flat image or audio files with the text import: 10 MiB per file and 50 MiB total. Repeto validates their content signatures and rewrites supported references to stable collection-media identities. It does not scan directories or accept arbitrary media formats.

The importer accepts at most 1,000 columns. Export CSV and Export TSV produce deterministic, self-describing note data for the collection or a deck subtree, including GUID, note type, deck, tags, and fields. Text export is notes-only: it does not include media bytes, card placement for siblings split across decks, scheduling state, or review history.

Export or inspect an Anki collection package

GET /v1/collection/export.colpkg produces a real legacy schema-11 .colpkg containing the live Anki-representable collection and verified media. It is an interoperability export, not Repeto’s exact backup. Repeto-specific sync identity, generation metadata, some extended scheduler state, undo snapshots, and active filtered-deck execution state have no lossless legacy representation.

Empty or delete active filtered decks before JSON-manifest or legacy .colpkg export. Those narrower formats reject an active filtered-deck execution state instead of silently producing a misleading snapshot.

In Import → Import an Anki collection, choose a .colpkg to inspect it without writing. The preview reports checksum, format/schema, scheduling/history/media counts, warnings, blockers, and whether exact replacement is available. Replacement is enabled only when the identical bytes contain a fully representable schema-11 collection, including schema 11 inside an anki21 wrapper. You must type the exact replacement phrase; Repeto revalidates the proof, replaces atomically, and requires connected clients to perform a fresh sync.

Modern normalized/protobuf anki21b, dynamic decks, parked filtered state, unsupported queues or review types, unsafe media, and any other losslessness blocker remain preview-only. Legacy export and schema-11 replacement are interoperability boundaries, not a lossless round trip for Repeto UUIDs, tombstones, private deck-copy metadata, extended FSRS state, undo, streak, or filtered execution.

Update a Marketplace deck safely

Marketplace versions are immutable and their package and media hashes are verified. A safe update preserves matching cards and their schedules/history, adds new content, and retires tracked removed content. Non-overlapping local edits merge automatically. If both you and the publisher changed the same tracked content, Repeto stops and offers an explicit conflict choice: overwrite the conflicting Marketplace content, or keep your edited copy as a fork and install the current publisher snapshot separately.

Takedown blocks new acquisition and updates but does not silently delete an installed local copy. The web conflict dialog currently summarizes the conflict count rather than showing an itemized diff, and older installations without a baseline may support only the fork path.

Other exports

The Stats page can export its displayed statistics as CSV. The API also exposes a deterministic, checksummed JSON collection manifest for inspection and engineering workflows. That manifest does not contain media bytes and is not a restore format; use the native archive for exact recovery.

Marketplace publishing is different from backup export: a published deck is a shareable content package, not a private copy of your full review history.

Safe migration checklist

1. Keep the original package until the migration is verified.
2. Import with scheduling preserved when continuity matters.
3. Open representative cards from every note type.
4. Check images and audio.
5. Compare due counts and a sample of intervals.
6. Create a Repeto-native backup before deleting or replacing a source collection.
7. Export the imported deck from Repeto and test that package independently.

The remaining timed-backup, modern .colpkg, and broader portability work appears in the parity roadmap.