Name: reMarkable Tagged Sync – Obsidian Plugin · Obsidian Stats
Rating: 48 (8 reviews)
Author: Thomas Hochbichler

by Thomas Hochbichler

Score: 48/100

Install Code

Description

Sync tagged reMarkable notebooks as searchable Markdown notes, routed to folders by tag.

Reviews

No reviews yet.

Stats

stars

272

downloads

forks

days

133

total PRs

open PRs

closed PRs

126

merged PRs

total issues

open issues

closed issues

187

commits

Latest Version

1.7.0

a day ago

Changelog

Added

A better model to read your handwriting on your own machine, and nothing taken away if you already have one. A new install now downloads Qwen3-VL-8B, which reads the fifteen public reference pages at 1.8 % character error against the previous model's 4.3 % -- and does it in 8 GB of memory rather than 15, so it is offered on Macs with 16 GB, which the old model's memory requirement shut out entirely. If you already downloaded the old model, it keeps working and nothing replaces it behind your back: the settings screen shows you the newer one with both error rates beside each other and the download size, and fetches it only if you press the button. The old model stays on disk afterwards as the way back, and there is a button to remove it when you no longer want the 5.5 GB. Notes you have already transcribed are not re-read; Re-transcribe all synced notes is there if you want them redone with the better model. (#143)
A Mac with 8 GB of memory can now read handwriting locally. Until now those machines had Apple's built-in recognition and nothing else. A third model, Qwen3-VL-2B, reads the fifteen public reference pages at 6.6 % character error against Apple's 15.7 % — less than half the mistakes — in 2.9 GB while it works and a 1.6 GB download. It is what a fresh install on such a Mac now gets, and it is offered nowhere it would not fit. Windows on ARM keeps a 16 GB requirement for it: the only Windows memory figure anyone has measured is the largest model's, and the number derived from it lands too close to the line to gate on. (#146)
You can pick which local model runs, and the plugin picks well if you do not. Where more than one model fits your machine, the settings screen lists them by how well each read the fifteen public reference pages, with the memory each uses while a page is read, and any model your Mac is too small for is named with the reason. The most accurate one your machine can run is marked default and is what you get unless you pick another; on a fresh install the pick decides which model is downloaded, and on an install that already has a model the card offers to fetch the one you picked beside it. Your choice is remembered, and it is a preference rather than a fact — if the model it names is deleted or you move to a smaller machine, the plugin decides again instead of stopping. (#145)
One bad transcript no longer costs a whole-vault run. A new command, Re-transcribe this note, re-reads just the note you have open. Because it works on one note, it can be more careful than the whole-vault command: it names the notebook's page count before spending anything on a metered backend, it asks first if you have corrected that note by hand, and it refuses a PDF whose margin notes are kept as a digest before any page is read rather than after. The old Re-transcribe all synced notes is unchanged and still there for a backend switch. (#135)
A synced note now says how many pages it covers, and what that costs. With Frontmatter properties on, each note carries remarkable-pages: the pages of that note -- all of them for a note made from a notebook tag, one for a note made from a page tag. It is also the cost signal, since a transcription backend is asked once per page, so sorting a Dataview or Bases view by it shows which notebooks are the expensive ones before you start a large sync. A page note additionally says which page it is, as remarkable-page; a notebook note covers pages 1 to n and carries no such key, which makes the key itself the filter for "page notes only". (#107)
remarkable-note-id: an identity you can key automation on. remarkable-uuid is the document on your tablet, and two notes made from one document share it -- so it was never a per-note identity, and a script using it as one could touch notes it should not. Every synced note now also carries its own id. Neither field is ever changed or regenerated once a note has it: not when the document syncs again, not when you rename the mapped tag, not when you move the note. The README says exactly what the two promise, and what the one case they do not cover is. (#109)

Existing notes pick both up by themselves: the first sync after updating brings them to the new property set, with nothing to toggle.
Settings now says when a model reasons before answering. Some vision models -- Ollama's default qwen3-vl tag among them -- think through an answer before writing it. They transcribe far more slowly, and a long enough answer runs past what the model may return, which drops that page. The live check under the model field now says so on a second line, wherever the provider will answer the question: Ollama and LM Studio (0.4.0 or newer) locally, OpenRouter and Anthropic in the paid build. It is a hint, never a block -- the model is your choice. Where a provider reports nothing, settings stays quiet rather than guessing. (#116)
A page dropped for running too long is now reported at the end of the sync. It was dropped before too -- half a page read as a whole one is a permanent loss -- but only a console message said so, and a notebook that lost three pages out of five looked like a clean sync. The end-of-sync notice now names how many pages were left out, why, and that they will not come back on their own: switch to a model that does not reason and run "Re-transcribe all notes". The same goes for a server that did not answer within ten minutes, and for one that refused. (#116)

The Anthropic backend reported nothing until now -- not this, not a dead connection, not a rejected key. It has the same three-part report as every other backend, and its page ceiling has been raised from 4096 to 16384 tokens so a reasoning pass stops eating the room a transcript needs.

Changed

The downloaded model is in the Backend list before it is downloaded. It used to appear only once the download had finished, and the card that explained what to do sat under whatever backend you had selected — so a fresh install looked as if the entry was missing. Pick it, and its card says not downloaded with the button; until the download is done, a sync writes the notes without a transcript and says so at the end. The entry is called Downloaded model (managed by this plugin) now, beside Ollama (your own server) and Apple Vision (built into macOS) — all three used to say local, and the word did not separate them.
The model list says what its number is. Beside a download button naming 1.6 GB, a bare 2.9 GB read as a second size for the same download; it is the memory the model holds while a page is read, and the entry says memory now, in the same unit the card's own Memory line uses — the two used to divide by different powers and show 2.9 and 3.1 for one figure.
What the transcripts will look like is said in the Backend setting itself, as its second sentence, rather than on a loose line under it that belonged to nothing. And it is said for the backend you chose: with LM Studio selected it used to read "Apple Vision: flat text only … choose an LLM backend".
A page you scrolled is now read in pieces, and comes back far better. A scrolled page is one very tall image -- one in the reference set is 852 by 7469 pixels -- and every transcription backend shrinks an image before reading it, so the writing arrived at a fraction of the size it needs to be legible and the model guessed. The page is now cut where there is no ink, at the blank bands between blocks of writing, and each piece is read on its own. Measured on that page: GPT-4o went from 50.2 % character error to 4.3 %, Claude from 11.3 % to 8.3 %, Gemini from 3.7 % to 1.3 %, and the local model from 4.3 % to 1.0 %. Every backend improved and none got worse. Ordinary pages are untouched -- the cut only applies to a page whose writing runs more than three times its own width, which the widest ordinary page in the reference set does not approach. No stroke is ever divided, so nothing is cut through the middle of a letter, and a page that would need more than six pieces is read whole as before. On a metered backend a cut page costs one request per piece. (#144)
Whether a scrolled page is cut before reading is now decided per downloaded model. Cutting a very tall page at its blank bands helps most backends enormously — GPT-4o goes from 39.5 % character error to 4.0 % — but it is not universal: a model that handles a tall image natively reads it better whole, and one was measured going the other way, from 1.0 % to 10.6 %. The two larger models the plugin ships still cut, which is what their measurements say; the 2B for 8 GB Macs reads a tall page whole, which is what its measurement says. Every other backend — the cloud providers and a server of your own — cuts. (#145)
Only the pages you changed are transcribed again. Adding one page to a long notebook used to read the whole notebook back, every time -- so the cost of capturing one new meeting grew with how long you had been keeping the notebook. One measured case: a single page added to a 100-page notebook was around six and a half minutes of a laptop GPU, for one page of new handwriting. Now a page whose ink has not moved keeps the text it already has, and only the pages you actually wrote on go to the transcription backend.

Changing the backend or the model discards what was kept, so a note is never a mix of two models reading it — taking the offer of a newer downloaded model counts as a model change. So does a plugin release that changes how pages are read. To read everything again on purpose, use Re-transcribe all notes -- it still reads every page, and now leaves the saved text behind it, so the sync after it is quick.

The first sync of each notebook after this update still reads it whole, once. Nothing was saved before now, so there is nothing to keep yet -- and that run is the one that used to read the whole notebook anyway. Every sync of that notebook after it is the cheap one. (#117)

One thing this repairs on the way: a notebook synced while the transcription backend was unreachable used to come back with its transcript removed. The pages that were already read stay in the note now, and the page that could not be reached says so.
Transcripts from a local server are now reproducible. Requests to Ollama, LM Studio and a custom OpenAI-compatible server carry temperature: 0, which is the sampling the plugin's own measured 7.6 % character error was taken at, and what the built-in local model has always used. The same page now reads the same way twice. Cloud providers are deliberately left alone: several current models reject a non-default temperature outright. (#116)

Fixed

Fetching a newer model beside the one you have no longer deletes its own download. The settings card tidies away half-downloaded models of versions this plugin can no longer finish, and it judged them by the name of the model in use — so the newer model's own download, in its own directory, was read as one of those and removed on its first progress tick, then started again from zero on the next. Every model this plugin can fetch is left alone now.
A model that was verified no longer shows as Download paused over a Discard 6.5 GB button. A leftover partial file from an attempt the finished download had overtaken made the card read the model as incomplete — and the Discard button would have deleted the verified model along with the leftover. A verified, full-size model is ready whatever sits beside it, and the leftover is removed.
A page dropped or a server that did not answer is now said at the end of the sync. The sentence existed, but it went into Copy diagnostics and nowhere else, so a notebook that lost three pages of five still reported Synced 1 note. It is raised as a notice now, in the backend's own words.
A server that was down for one sync no longer throws away the pages already read. Any warning from the backend emptied the per-page store, so the next edit to that notebook re-read all of it. The pages the backend marked as failed were never stored anyway; the ones it read are kept.
A failure while bringing old notes up to the current properties no longer swallows the sync's own report — the notice about pages left out, the last synced time and the reuse figures — for notes that had already been written. It is its own line in diagnostics now.
Picking the downloaded model before its download no longer ends the first sync with "Text transcription needs macOS 13 or later". That sentence was for a Mac that cannot run Apple Vision, and it was shown once and then never again. A sync with the model not yet on disk now says how many notes went without a transcript and what to do: download it in settings, then run Re-transcribe all synced notes for the notes synced meanwhile.
Picking a model that is not on disk now offers to download it. The pick used to sit in the list over a card running a different model, doing nothing, because a working model is never displaced until the picked one is installed. The card now offers the picked model the way it offers a better one, with both error rates and the download size.
The card no longer takes the whole settings page with it while a model downloads. Each tick of the progress bar redrew the card into an emptied page, so after the first tick nothing but the card was left — and the redrawn card did not move again. It redraws only itself now.
A scrolled page's lower blocks are no longer folded onto its last row and lost. The renderer drew a page scrolled far past one screen at the height of one screen; the writing below it landed on top of the last row. The page is drawn at its full height. (#136)
The background-transcription switch is now called Allow automatic sync with this backend, and says what it does. It used to be Transcribe during background sync, which promised it was about transcription — so beside Enable automatic sync it looked like a second switch for the same thing under a different name. It is not about transcription: while it is off, automatic sync does nothing at all for that backend and a sync you start yourself brings everything. The description says that first and the cost second, and it no longer mentions fans — most Macs this runs on either have none or never spin them audibly, so the thing you actually notice is the battery. The downloaded model, a local server and a paid provider all say it under the same name — the paid one used to be Automatically transcribe during background sync, which promised a sync without transcripts and delivered no sync at all — and only one of them is asked on any screen.
The model check now sits with the model field. The green or red line saying whether your model can read images was drawn underneath the field's box rather than inside it, so it floated in the gap between two settings and looked like it belonged to neither. It now sits in the field's own description, directly under it.
The Backend setting now describes the backend you chose. It explained all three families at once — Apple Vision, a model on your own machine, and the cloud providers — so whichever one you had picked, most of what you were reading was about the other two. It now makes one promise: the one belonging to the backend in the box beside it.
Settings no longer jumps to the top when you change something. Nearly every control on the settings page redraws the page in place, and the redraw was throwing you back to the top — so choosing a transcription backend, which sits well down a long page, took you away from the very setting you had just touched. The page now keeps your place.
Starting a download no longer says another vault is transcribing. A download fetches the 12 MB transcription engine first and the model second, and for that first minute the plugin read its own download as somebody else's work: pressing Resume was refused with "another vault is transcribing right now", and a sync started in that window skipped transcription for a reason that was not true. Both halves of a download are recognised now.
A download no longer outlives the plugin that started it. Reloading the plugin while one ran — an update, or switching it off and on again — left the transfer going with nothing able to stop it, and the freshly loaded plugin could only read the growing file as "Being downloaded in another vault", on machines with one vault open. A download now stops when the plugin unloads, keeps every byte it had already fetched, and comes back as Download paused with the amount named and a Resume button. The card also stops claiming a vault it cannot see: the lock the plugin writes carries a timestamp and nothing else, deliberately, so where a download really is running somewhere else it now says only that a download is running, with the progress it can see, and names both of the ways that happens.
Typed text now sits where you typed it, not at the end of the page. On a page with handwriting above and below a block of typed text, the block was appended after everything the transcription backend read, so the line you wrote under it came back in the middle. The page's ink is now split where the typed lines sit and read in parts, and the transcript follows the page: handwriting, typed block, handwriting. A page with no typed text on it still costs one request, unless it is a scrolled page cut into pieces (see above). Apple Vision was never affected -- it knows where each line sits and has always placed them.

See all version on GitHub

README file from

Github

Tagged Sync for reMarkable

taggedsync.com — the short version, in pictures.

Disclaimer: Tagged Sync for reMarkable is an unofficial, community-built plugin. It is not affiliated with, endorsed by, or supported by reMarkable AS. "reMarkable" is a trademark of reMarkable AS, used only to describe compatibility.

Tag a notebook or a PDF on your reMarkable, and it lands in the vault folder you mapped — your handwriting transcribed, your highlights quoted.

Your handwriting never leaves your machine. Rendering and transcription run on your own computer — no upload, no account with us. The plugin is free; Pro is an optional add-on for €24 once, no subscription.

A notebook you wrote in

The pages as you drew them, embedded in the note, plus a searchable transcript underneath — split by page, so a long notebook stays navigable.

Writing a note on the reMarkable, tagging it sync, running Sync now in Obsidian, and the note arriving with the handwriting render and a searchable transcript split by page

A PDF you marked up

Every passage you highlighted or underlined, quoted with the sentence around it and filed under the section it came from. Each quote carries a block ID, so you can link a single passage from anywhere in your vault. None of it goes through transcription, so this works the same on Windows and Linux as it does on a Mac.

Highlighting and underlining passages in a PDF on the reMarkable, tagging it sync, and the digest arriving in Obsidian as quotes grouped by section, each linking back to its page

PDF shown: Kang et al., ACON: Optimizing Context Compression for Long-horizon LLM Agents, CC BY 4.0.

Desktop only · one-way (reMarkable → Obsidian) · never writes back to your tablet.

What makes it different

Every feature at a glance, Free against Pro. Most rows link to the section that explains them.

Feature	Free	Pro
Direction & safety
reMarkable → Obsidian sync	✓	✓
One-way by design — never writes to your tablet	✓	✓
No reMarkable Connect subscription needed	✓	✓
Sync straight from the tablet, without the reMarkable cloud	—	✓
Your edits are never silently overwritten	✓	✓
Never deletes a synced note	✓	✓
Stop a running sync	✓	✓
What arrives in your vault
Handwritten notebooks, page render embedded	✓	✓
Handwriting → searchable text	✓	✓
PDF highlights extracted as quotes, with the sentence around them	✓	✓
Pen marks — underline, circle — count as annotations	✓	✓
Margin notes transcribed and placed at the passage they point at	✓	✓
Block IDs — every quote linkable on its own	✓	✓
Typed text (Type Folio) kept exact, never transcribed	✓	✓
Notebook highlights from the tablet	✓	✓
EPUB books, with their own chapter names	✓	✓
Transcription backends
Apple Vision — zero set-up on macOS	✓	✓
A local server you run yourself (Ollama, LM Studio)	✓	✓
Managed local model — one click, checked hashes	✓	✓
Cloud transcription with your own API key	—	✓
Re-transcribe notes you already synced	✓	✓
Repair one note without re-running the whole vault	✓	✓
Organization
Tag → folder routing	1 tag	unlimited
Selective sync — only what you tag	✓	✓
A tagged folder hands its tag to everything inside	✓	✓
Sync behaviour
Automatic sync — on launch, plus an interval	✓	✓
Incremental sync	✓	✓
Platforms
Windows, macOS, Linux	✓	✓
reMarkable 1, 2, Paper Pro, Paper Pure	✓	✓

Pro is €24, once — no subscription. See Tagged Sync Pro.

Works with

Device / accessory	Status
reMarkable 2	✓
reMarkable 1	✓
reMarkable Paper Pro	✓ — its larger canvas, its colour palette, and the shader highlighter are all handled; the fixes came from Paper Pro users' own files
reMarkable Paper Pure	✓
Type Folio (typed text)	✓ — taken from the file exactly as you typed it, never transcribed
"Read on reMarkable" browser extension	✓ — a sent article counts as a document to mark up
EPUB books	✓ — read as the book the device made of them, not as ink on blank pages

Obsidian itself must be the desktop app — see Limitations.

Before you install
How it works
Install and set up
Handwriting transcription
Typed text and the Type Folio
Tagged Sync Pro
Syncing without the cloud
Annotated PDFs
What gets synced
Limitations
Privacy and permissions
Support
Reporting a problem
Requesting a feature

Before you install

Two limits, so you know them up front:

The plugin syncs one tag. You map one reMarkable tag to one vault folder. You can change or remove that mapping at any time. Syncing more than one tag is what Tagged Sync Pro is for — €24 once, with a 14-day trial. Everything else in this README works without payment, cloud transcription aside.
Text transcription is built in on macOS 13 or later. Everywhere else — Windows, Linux, older Macs — you can transcribe by pointing the plugin at a local AI server you run yourself (Ollama, LM Studio, or any OpenAI-compatible server), or by using the optional managed local model where your machine qualifies. With none of those set up, your notes still sync with the full handwriting render embedded — but there is no transcript. Marked-up PDFs and typed documents are unaffected: both are read from the file itself and need no transcription at all, so they work everywhere.

How it works

Tag a notebook, a PDF, a single page, or a whole folder on your reMarkable — e.g. sync.
It syncs to the reMarkable cloud as usual — or, with Pro, the plugin reads it straight off the tablet and the cloud never comes into it.
In Obsidian, map that tag to a vault folder in the plugin settings.
Run Sync now (or let automatic sync do it).
You get a Markdown note with the render embedded, and either a searchable transcript or a digest of your marks below it.

Install and set up

You need Obsidian 1.5.7 or later on desktop (Windows, macOS, or Linux — Obsidian on mobile is unsupported), and a reMarkable account with cloud sync switched on — unless you sync straight from the tablet, which needs no account at all.

In Obsidian, open Settings → Community plugins → Browse, search for Tagged Sync for reMarkable, and click Install, then Enable.
Open Settings → Tagged Sync for reMarkable, and follow the "Connect" link to my.remarkable.com/device/browser/connect to get a one-time code. Enter it and click Connect. Codes expire after a few minutes, so get a fresh one if it is refused.
Click Discover tags to scan your reMarkable notebooks, pages and folders for tags, then map the tag you want to sync to a vault folder. Only a mapped tag is synced — an unmapped tag is simply not selected, not lost.
Click Sync now.

Sync is also available from Obsidian's command palette (Ctrl/Cmd + P) as Tagged Sync for reMarkable: Sync now.

The plugin settings: reMarkable connection, OCR backend, tag mapping, and the Sync now button

Stopping a sync

While a sync is running, the status bar shows a turning icon. Click it and confirm, or run Tagged Sync for reMarkable: Stop sync from the command palette. This works for an automatic sync and for re-transcribing too.

Stopping is safe rather than instant: the note being transcribed right now is finished first, so it can take a moment — the status bar says stopping… meanwhile. Everything already written is kept, and the next sync carries on from where it left off.

Automatic sync

Off by default. Under Automatic sync you can turn on a sync when Obsidian launches, plus an interval backstop while it stays open. A manual sync pushes the next automatic one out rather than triggering a redundant run.

Re-transcribing

Two commands, depending on how much you want re-read.

Tagged Sync for reMarkable: Re-transcribe this note re-reads just the note you have open. Use it to repair a single garbled transcript: on a paid backend it tells you how many pages that notebook is before it sends any of them, and if you have corrected that note by hand it asks first, because re-transcribing replaces what you wrote there. It says no in three cases — the open note was never synced from reMarkable, its notebook is no longer on your tablet, or it is a PDF whose margin notes are kept as a digest rather than as a transcript.

Tagged Sync for reMarkable: Re-transcribe all synced notes does the same for every synced note in the vault. That is the one to run after switching backends. It asks for confirmation first.

Both re-fetch the notebook and rewrite only the transcript region, leaving your own notes and the embedded render untouched.

Re-transcribing is also the way to fill in a transcript that never arrived — a note synced while the local model was still downloading, or while its engine was missing, keeps its render and no text, and nothing refills it on its own. Re-transcribing does. With the local model selected, the whole-vault confirmation tells you how long the run will take on your machine, measured from your own pages.

Handwriting transcription

A synced note in Obsidian: the two handwritten pages rendered on top, the searchable transcript below them

Three backends can read your handwriting entirely on your own machine — no account, no API key, no page image or text ever leaving the device. They are free, and they are the default. Whichever you pick, each page is rendered to a temporary PNG under your OS temp directory (os.tmpdir()) and deleted as soon as it has been read.

Backend	Where it runs	Set-up
Apple Vision	macOS 13 or later	none, it is the default there
A local server you run yourself	everywhere	install Ollama or LM Studio
Managed local model	Apple Silicon, Windows on ARM	one opt-in click, a 1.6 to 6.2 GB download depending on the model

Four cloud backends are also available, with Tagged Sync Pro. Those are the one case where a page image leaves your device: you choose them, they use your own API key, and they are off unless you turn them on.

Apple Vision aside, you name the model yourself. The Model field starts empty on every backend, local and cloud alike, and the plugin suggests nothing: a model id shipped inside a plugin goes stale the day its provider retires it, and the error you then get reads like a problem with your API key rather than what it is. Take a current name from your provider's own list. Until you do, settings says so, and a sync reports "No model is set for this OCR backend" rather than quietly producing no transcript.

On Windows and Linux nothing transcribes by default: notes sync with the handwriting render embedded and no ## Transcript text, until you set up one of the other two local backends. You can also set the backend to Off on purpose if you only want the render.

Apple Vision (macOS)

The default on macOS 13 or later, and nothing to configure. It auto-detects language and reads cursive well, but produces flat text — no headings, lists, task lists, or tables. Its structured API is macOS Swift-only and unavailable here. It can also misread; see Writing your own notes.

For transparency: the page PNGs are transcribed by invoking the built-in /usr/bin/osascript binary, which drives Apple's Vision framework. This runs on your machine with no network egress.

A local server you run yourself

If you already run — or are willing to install — a local AI server, the plugin can send each page to it and get the text back. Nothing leaves your machine, and there is no account or key. This is the one route that works everywhere, including Windows on x64 and Linux.

Install and start Ollama, LM Studio, or any other server that speaks the OpenAI /chat/completions API, and load a vision model into it.
In the plugin settings, set Backend to that server and enter the model's name. The address is pre-filled for Ollama and LM Studio; change it only if yours runs elsewhere.

Which model you use is your choice. For what it is worth: I measured Qwen2.5-VL-7B at 7.6 % character error — about three times more accurate than Apple Vision on the same pages — but I measured it running the model directly, not through one of these servers, so treat it as a starting point rather than a promise. That number is the 7B build: a smaller variant of the same family is a different model, and I have measured none of them. Issue #116 carries a user's own measurements of the smaller ones, with the caveats they put on them.

Two things settings will tell you about the model you name, where the server can be asked. A text-only model cannot read a page image at all. And a model that reasons before answering transcribes far more slowly and can lose a page: the answer runs past what the model may return, and that page is left out rather than saved half-read. If that happens, the sync says so at the end — switch to a model that does not reason (often the -instruct build of the same family) and run Re-transcribe all synced notes, because a later sync will not pick those pages up on its own.

The reasoning hint needs Ollama, OpenRouter, or LM Studio 0.4.0 or newer; other servers expose nothing to read it from, and then settings says nothing rather than guessing.

If the server is not running, settings says so, and a sync that hits it leaves the notes with their render and reports it at the end rather than failing quietly.

Local model (optional, opt-in)

On some machines you can switch the backend to a local AI model instead. It reads handwriting about three times more accurately than Apple Vision and keeps headings and lists, and like Vision it runs entirely on your machine. It is never a default: a fresh install downloads nothing, and Apple Vision stays the default on macOS.

Choosing it downloads 1.6 to 6.2 GB of model files plus a 12 MB program, after an explicit opt-in in settings — three models ship, and settings offers the ones your machine can run, with the most accurate marked as the default. Both files are checked against a SHA-256 published in the plugin before anything runs. It is slow compared with Vision — roughly 15 seconds a page on a fast Mac against Vision's 0.4 — and it holds between 3 and 9 GB of memory while it runs, depending on the model.

Offered only on:

	Requirement
macOS	Apple Silicon, 8 GB of memory or more; 16 GB for the most accurate model
Windows	ARM (Snapdragon X and similar), 16 GB of memory or more; 24 GB for the most accurate model

Intel Macs, Windows on x64 and Linux do not get the option, and settings says why on the machine itself. Windows x64 is excluded because Windows Defender quarantines the engine — the llama.cpp builds for x64 have been flagged as Trojan:Win32/Wacatac.B!ml for years, the builds are unsigned, and nothing this plugin does to its own download changes what a malware scanner decides about someone else's binary. Windows on ARM uses a different build, which is not flagged.

Like any transcription it misreads sometimes, and it misreads differently: Vision's mistakes usually look broken on the page, while this model writes its mistakes as fluent text. Check anything that matters against the handwriting.

Typed text and the Type Folio

Not everything on a reMarkable is ink. Text you type with the Type Folio — or send over with the "Read on reMarkable" browser extension — is stored inside the notebook as text, not as strokes. The plugin treats it accordingly:

Typed text is never transcribed. It is taken from the file exactly as you typed it, so no typed word can come out misspelled.
Where it lands in a transcript depends on the backend. Apple Vision reads one page at a time and knows where each line sits, so your typed text stays where it is on the page, between the handwriting around it — a typed heading over handwritten notes stays a heading over those notes. The other backends transcribe without those positions, so typed text is added at the end of its own page instead.
A typed page you marked up is a document. A page whose typed text reads like a document — an article sent from the browser, prose you typed with the Type Folio — is treated like a PDF: what you highlight or underline on it arrives as a digest, quotes, sections, block IDs and all. A typed line or two inside a handwritten page stays part of the transcript instead; the plugin tells the two apart by how the text is set, not by guessing.
Page by page, not notebook by notebook. One such page does not make the whole notebook a document. Its handwritten pages are still transcribed, and the note then carries a ## Digest and a ## Transcript together. A typed page the digest has nothing to show for is named in the transcript — Page 4 is typed text — see the embedded page. — rather than read back by a transcription backend, since its words are already legible in the embedded page above.
Such a page needs no transcription at all. Its digest is read from the file, exactly as a marked-up PDF's is, so it arrives on Windows and Linux with no transcription backend set up.
Highlights on typed text reach your vault like any other highlight.

Tagged Sync Pro

Everything described above is free and stays free. Two things are paid:

Cloud transcription — Anthropic, OpenAI, Google and OpenRouter as transcription backends, with your own API key and a model you name yourself.
Unlimited tag mappings. The plugin syncs one tag; Pro syncs as many as you like.
Syncing without the reMarkable cloud — the plugin reads your tablet directly over USB or Wi-Fi.
Frontmatter properties — each synced note carries its reMarkable tags and metadata as Obsidian properties, for Dataview and Bases queries.

€24, once. No subscription, no renewal, no expiry. The licence is for one person, on up to 50 devices, at home and at work.

Every future Tagged Sync Pro feature is included — no upgrade fee, ever.

Try it for 14 days — one click in the plugin settings, no key and no email needed. Nothing is sent anywhere to start a trial.

Buy a licence — you get your key on the page straight after paying, and by email as a backup. Paste it into the plugin settings.

14 days, no questions asked — just write to me. One person, up to 50 devices.

The licence is granted by me; the sale itself is handled by Polar, who are the seller. See LICENSE-COMMERCIAL.md, PRIVACY.md and IMPRESSUM.md.

What I do not control

This plugin talks to the reMarkable cloud. I do not work for reMarkable. I have no contract with them and no advance warning of their plans. They can change or switch off their cloud at any time. This already happened: in April 2026 a format change broke every tool in this space.

If it happens again:

I will work on a fix as fast as I can. I cannot promise a date.
Your notes are safe. Everything already synced is plain Markdown and PDF in your own vault. It stays there. Nothing is deleted.
I do not refund for the days the sync is broken, because the cause is not mine.
If reMarkable shuts the cloud down for good, or changes it so that no fix is possible, I will say so in public and stop selling licences. I will not take money for something that cannot work.

The same applies to the transcription providers (Anthropic, OpenAI, Google, OpenRouter, Ollama, LM Studio). They set their own models, prices and rules. I do not control those either.

Updates come through the Obsidian plugin store, to everyone, for as long as the plugin is sold. What I promise is effort, not dates.

None of this changes your rights as a consumer under EU law.

Syncing without the cloud

Tagged Sync Pro.

Everything above goes through the reMarkable cloud, which works well and has one weakness worth being honest about: the interface it uses is not documented or promised by reMarkable. It has been worked out by reading what the official apps do. That is how every tool of this kind talks to a reMarkable account, and it means a change on their side can break syncing for everybody at once.

So Pro can skip it. The plugin connects to the tablet itself — over the USB cable, or over your Wi-Fi — and reads the notes off it. Nothing in between: no reMarkable account, no server of mine, no internet connection needed at all. On a slow line it is also simply faster, because the notes travel across your desk instead of twice across the world.

Switching costs nothing. The plugin works out the same fingerprints for your notes as the cloud does, so a vault that has been syncing through the cloud for a year can switch to the cable and carry straight on. Nothing is re-rendered, nothing is transcribed again, and no cloud API bill is run up doing it. You can also switch back whenever you like.

You can set a second source as a fallback: sync from your tablet and fall back to the cloud when it is asleep, or the other way round when your internet is out. A background sync checks whether the tablet is awake before it starts, so a device in a drawer is a quiet skip and not a failure.

What your tablet needs

reMarkable 1 and reMarkable 2 — nothing to turn on. They accept these connections as they come out of the box.

reMarkable Paper Pro and Paper Pure — read this before you buy Pro for this feature. These devices only allow the connection in Developer Mode, and turning Developer Mode on erases the tablet. Your notes come back from the reMarkable cloud afterwards, and the tablet shows a warning screen every time it starts from then on. That is reMarkable's decision, not something this plugin can work around. If that trade is not worth it to you, the cloud sync works exactly as before — and the plugin says all of this in the settings, before it asks you for anything.

Pairing asks for the root password, which is on the tablet under Settings → Help → About → Copyrights and licenses, at the end of the GPLv3 section. It is used for that one connection, to install a key for your vault, and is never stored.

The tablet identifies itself, and the plugin remembers it. Before anything is installed, pairing shows you the tablet's own key fingerprint and pins it to this vault. If a device at that address ever answers with a different key, the sync stops and says so, instead of handing your notes to whatever picked the address up.

Whether you need the cable depends on the firmware. Newer reMarkables keep Wi-Fi access switched off until something turns it on, so the first pairing goes over USB; the plugin then offers to switch it on for you, and after that the cable is never needed again. It asks first, and saying no keeps the tablet cable-only. Older reMarkables accept Wi-Fi straight away, and the plugin uses whichever address answers.

Windows note: recent Windows versions have been dropping support for the driver the USB connection uses, so Wi-Fi is the more reliable route there.

Annotated PDFs

A PDF you marked up gets a ## Digest in place of the transcript: your marks, quoted with the sentence around them, grouped under the section of the document they came from.

A digest in Obsidian: the annotated PDF embedded on top, below it the quotes grouped under their section headings, each linking back to its page

Both the highlighter and the pen count. A passage you marked with the highlighter — or with the Paper Pro's shader — and one you underlined or circled with the pen arrive the same way: a quote with its surrounding sentence, the section it sits under, and a link to the page. Marking with the pen used to reach your vault as nothing at all.

None of this goes through transcription. The words come from the PDF's own text, not from a picture of it, so the digest works the same on Windows and Linux as it does on a Mac — and no marked word can come out misspelled.

Every quote is linkable on its own. Each entry ends with a block ID — Obsidian's anchor for one single block of text — so an annotation can be embedded anywhere in your vault: ![[My Book^hl-d449a3]] pulls in that one quote and nothing else. The IDs are stable across syncs.

The document's note is its digest. There is no separate digest note collecting every document — the marks live in the note of the document they belong to, in the folder you mapped.

Books you read as EPUB

A book you tagged arrives as the book, with everything above true of it. A reMarkable has no EPUB reader: it converts the book to a PDF on the tablet and reads that. Tagged Sync reads the same PDF, so a highlight in a book comes through as the quote it is, under the chapter it sits in — the chapter named the way the book's own table of contents names it.

One thing to know before you start, and it is the device's doing rather than the plugin's. Changing a book's font, its size, or its margins makes the reMarkable lay the whole book out again and rebuild that PDF. Measured on a real tablet: every mark survived that — and every mark kept its exact position while the text moved out from under it. A highlight that had covered one sentence covered a different one after the change.

Tagged Sync mirrors what the device holds, so it cannot put those marks back where they belong. What it does is tell you it happened: a book whose page count has changed since its notes were written is reported after the sync, and so is a note that comes back with fewer highlights than it had. Nothing else would ever flag it — a quote you never marked reads exactly like one you did.

So: settle the font before you start annotating, which is the advice reMarkable readers give each other anyway.

The notes you write in the margin

Switch them on under Settings → Handwritten notes, and what you wrote beside the text arrives with what you marked. They are off until you say otherwise: transcribing handwriting is work your machine does per note, and it needs a transcription backend — the same one a handwritten notebook uses.

Each note is printed where you wrote it: under the section heading it sits in, or beside the sentence it points at, with a link to its page. And you can look at the handwriting itself. The eye in the corner of an entry draws the strip of page the note sits on, cut out of the PDF the note already embeds — it appears when you press it and not before, and no image is ever written to your vault.

A margin note in Obsidian: the quoted sentence above, the transcribed note below it, and the clipping of the page showing the highlighted passage next to the handwriting it was written beside

A note whose handwriting could not be transcribed says so rather than standing empty, and keeps its anchor and its page link.

Three things worth knowing before you rely on it:

Without margin notes switched on, the digest is built from what you marked, not from what you wrote. Handwriting then stays in the render where you wrote it — no text is extracted from it, and a PDF you only wrote on syncs with the render and no text at all.
It reads the PDF's own text layer. A scanned page without one gives less: highlights arrive as the words your tablet recorded, and pen marks are not recognised as marks at all.
Marker colour is not carried over. Every mark reads the same in the note; the colours stay in the embedded render.

Section headings come from the PDF's own outline where it has one, and from a font-size guess where it does not — so a document without bookmarks can file a quote under the wrong heading.

What gets synced

A notebook tagged with a mapped tag syncs as one note for the whole notebook.
An individual page tagged with a mapped tag syncs as its own note, independent of any notebook-level tag.
A folder tagged with a mapped tag hands that tag to everything inside it — every notebook and PDF, and the ones in folders nested below as well. Each of them then syncs exactly as if you had tagged it yourself. One tag can therefore bring in a great deal at once, so look at how much sits under a folder before you tag it — with a cloud backend, transcribing all of it costs money.
A handwritten notebook's note has the rendered PDF embedded, then a ## Highlights section (one quote callout per page, if you highlighted anything on the tablet), then the ## Transcript. If transcription is off, fails, or finds nothing, the note is still created with the render and no ## Transcript section — the render is never lost. An annotated PDF gets a ## Digest instead, and a notebook with typed pages among handwritten ones can carry both.
Typed text is taken from the file, never transcribed, and joins the transcript of the page it is on — at the position it sits at with Apple Vision, at the end of the page with the other backends. A typed page that reads like a document gets the digest treatment instead, like a PDF.
The transcript is split by page. Each page that produced text gets its own heading linking into that page of the embedded PDF, so a long notebook stays navigable. Pages with nothing to read are named once at the end instead of taking a heading each, and a page transcription could not read says so where it happened. Notes synced before this keep the transcript they have — run Re-transcribe all synced notes to bring them over.
A synced note carries no frontmatter by default — no YAML block at the top. Everything the sync needs to track lives in the plugin's own data.json, not in your notes. If you want your notes queryable, Frontmatter properties (Pro) writes the device's tags and metadata into each note's properties — opt-in, and your own frontmatter lines are never touched.
Removed or untagged units are never deleted. The plugin stops updating them and leaves the note exactly where it is, so nothing you already have can disappear.
A page note is named after the page's position in the document at the time it was written. Insert a page on the tablet and everything after it moves down one — but a note whose own page did not change is not rewritten, so it keeps the name it had. Its contents stay right: the links inside it address the page of the source PDF, which insertion does not renumber. Only the file name can go stale, and only until that page changes and the note is written again. A note that would land on a name already taken gets a suffix rather than overwriting anything.
A book laid out again on the tablet is reported. Its page count changes when its font, size or margins do, and marks made before that keep their place while the text moves — so their quotes may no longer be the sentences you marked. Said once per book, when the sync first sees the new count.
A note that comes back with fewer highlights than it had is reported. The sync mirrors the device, so a mark you removed on the tablet leaves the note too — but a mark that went missing without you removing it is worth hearing about while a backup of the note is still recent. The notice says how many notes; Copy diagnostics in settings says which.

Frontmatter properties (Pro)

Turn on Frontmatter properties in the plugin settings (under Vault output) and every synced note gets a small block of Obsidian properties, straight from the device:

---
tags:
  - remarkable/projekt-x
remarkable-modified: 2026-08-25T16:20
remarkable-synced: 2026-08-25T17:02
remarkable-folder: Work/Projekt X
remarkable-type: notebook
remarkable-pages: 12
remarkable-pinned: true
remarkable-uuid: aaaa0002-0000-0000-0000-000000000000
remarkable-note-id: 3f9a1c04-0000-0000-0000-000000000000
---

remarkable-pages is how many pages this note covers, which is also what it costs to transcribe: a backend is asked once per page. Sorting by it before a large sync tells you which notebooks are the expensive ones. A note made from a page tag covers one page, and says which one:

remarkable-pages: 1
remarkable-page: 7

A note made from a notebook tag covers pages 1 to n and so carries no remarkable-page at all — which makes the key itself the filter for "page notes only".

Every document tag — the sync tag included — arrives namespaced under remarkable/, so each synced note answers FROM #remarkable. With Dataview, your latest five synced notes are:

```dataview
TABLE remarkable-synced AS "Synced", remarkable-folder AS "Device folder"
FROM #remarkable
SORT remarkable-synced DESC
LIMIT 5
```

The same fields drive tag filters (FROM #remarkable/meeting), favourites (WHERE remarkable-pinned = true), grouping by source type, or a "synced this week" view — and Obsidian's built-in Bases can query them too.

The plugin manages only its own lines: frontmatter you write yourself is preserved byte-for-byte, and the plugin's keys mirror the device (hand edits to them are overwritten on the next sync). Turning the setting on writes the properties into every already-synced note, so views are complete from day one; turning it off removes exactly what the plugin added and leaves your own frontmatter alone. When a plugin update adds a property, one sync brings your existing notes up to date — you do not have to toggle anything.

Identity: what you can key automation on

Two of these fields are meant to be relied on by scripts, so here is exactly what they promise.

remarkable-uuid is the document on your reMarkable. Several notes can carry the same one: a document routed by two mapped tags produces two notes, and a page note carries its notebook's id. It is the document's identity, not the note's.
remarkable-note-id is this one note. No two notes share it.

While Frontmatter properties is on, every note the plugin writes carries both. Neither is ever changed or regenerated for a note that already has one — not when the document is synced again, not when you rename the mapped tag, and not when you move the note somewhere else in your vault.

One limit, so it does not surprise you: a note whose tag mapping you removed is no longer written by the plugin, and keeps whatever it had at its last write. It is not given the keys after the fact. Automation that looks for them will pass such a note by — which is the safe direction to fail in.

Writing your own notes

A synced note belongs to the plugin: every sync rewrites it from scratch. Each note says so at the top, in a collapsed callout. So keep your own writing in a note of your own, and link back to the synced one.

If you do edit a synced note — for example to fix a misread word — the plugin notices and refuses to overwrite it, telling you how many notes it skipped. Your edit is never silently erased; that note simply stops updating until you undo the change.

Notes synced by earlier versions had a free area below the sync block. Anything you wrote there stays where it is and is still preserved on every sync — new notes just no longer offer it.

Limitations

Desktop only. Obsidian on mobile is unsupported.
One-way sync: reMarkable → Obsidian only. Nothing is ever written back to your tablet.
One tag → folder mapping.
Transcription with Apple Vision requires macOS 13 or later, and its transcripts are flat text — no headings, lists, task lists, or tables.
The optional local model keeps headings and lists, but needs Apple Silicon with 8 GB of memory or Windows on ARM with 16 GB, and a download of 1.6 to 6.2 GB depending on the model. Tables come out as plain lines.
Windows on x64 and Linux get the render and no handwriting transcript out of the box — a local server you run yourself is the only route there. The digest of a marked-up PDF and of a typed document are unaffected and work everywhere: both are read from the file, not transcribed. Typed text on a handwritten page needs a backend like any other transcript, since it is the transcript it joins.
A PDF you only wrote on syncs with the render and no text. The digest quotes what you marked; handwriting on the page is not read.
The reMarkable cloud API used here (via rmapi-js) is reverse-engineered and unversioned; firmware changes on reMarkable's side can break sync. See below. Syncing straight from the tablet avoids that interface entirely, and is what Pro buys you as a way out — on a Paper Pro or Paper Pure at the cost of a factory reset.

What I do not control

This plugin talks to the reMarkable cloud. I do not work for reMarkable. I have no contract with them and no advance warning of their plans. They can change or switch off their cloud at any time. This already happened: in April 2026 a format change broke every tool in this space.

If it happens again:

I will work on a fix as fast as I can. I cannot promise a date.

Syncing without the cloud does not go through any of this. It reads the tablet on your own network, so a change to their cloud cannot stop it.

Your notes are safe. Everything already synced is plain Markdown and PDF in your own vault. It stays there. Nothing is deleted.

Privacy and permissions

Network use

This plugin makes network requests to exactly one place by default:

reMarkable cloud (required) — the plugin authenticates to my.remarkable.com via a one-time device code, then reads your notebook/page list, tags, and content over the reMarkable cloud API to sync it into your vault. This is read-only; nothing is written back to your reMarkable account.

Your tablet, over your own network — only if you set it up (Syncing without the cloud, Tagged Sync Pro):

An SSH connection to your reMarkable, at the address you pair with — the USB address (10.11.99.1) or the tablet's address on your Wi-Fi. The plugin reads the notes directory over SFTP and runs two commands on the device: one to list the files with their sizes and times, and sha256sum to hash them so it can tell what changed. It is read-only apart from pairing, which appends one public key to /home/root/.ssh/authorized_keys, and — only if you agree when asked — runs rm-ssh-over-wlan on so the tablet keeps accepting connections over Wi-Fi.

This connection stays on your network. It goes to your tablet and nowhere else; no server of mine and none of reMarkable's is involved, and with it configured a sync needs no internet connection at all. The root password you type while pairing is used for that one connection and is never stored.

A transcription backend you choose yourself. Which of these is contacted, if any, depends entirely on the backend selected in settings:

Apple Vision and a local server you run yourself — nothing leaves your machine.
A cloud backend (Anthropic, OpenAI, Google, OpenRouter — Tagged Sync Pro) — the page image is sent to that provider, using your own API key, and the transcript comes back. This is the one case where a page image leaves your device. You choose it, you pay for it, and it is off unless you turn it on. The provider's own terms apply.

Two more hosts are contacted only if you opt in to the local model (see above), once, to download it — never during a sync, and never again once the files are on disk:

huggingface.co — the two model files, from Qwen/Qwen3-VL-8B-Instruct-GGUF, Qwen/Qwen3-VL-2B-Instruct-GGUF or ggml-org/Qwen2.5-VL-7B-Instruct-GGUF, each pinned to one commit.
github.com — the llama.cpp engine, from release b10295 of ggml-org/llama.cpp (11–12 MB depending on platform).

Nothing is uploaded to either.

The licence check — polar.sh, and only if you own or are trialling Tagged Sync Pro. It is called only when you use a paid feature, and at most once every 7 days; a valid answer is remembered in between. It carries your licence key, the activation id of this vault and the plugin's public organization id — no email address, no vault name, no note content. A free user never causes this call. Details in PRIVACY.md.

No telemetry or analytics of any kind are collected or sent by this plugin.

Accessing files outside of Obsidian vaults

Two things, both only on the paths your OS reserves for exactly this:

Page images during transcription. Each page is written as a temporary PNG under your OS temp directory (os.tmpdir()) — never under Documents/Desktop/Downloads/iCloud — and deleted as soon as the page has been read.
The local model, if you opt in to it. The model files (1.6 to 6.2 GB) and the engine are written to the standard per-application data directory — ~/Library/Application Support/remarkable-tagged-sync/ on macOS, %LOCALAPPDATA%\remarkable-tagged-sync\ on Windows — and read from there when you transcribe.

They live outside your vault on purpose: inside it they would go through Obsidian Sync and every vault backup, once per vault, and several gigabytes is not something to put in someone's backup without saying so. The price is that uninstalling the plugin does not delete them. The Delete the model button in settings does, and settings names the exact size before you agree to download anything.

Other permissions this plugin uses

Two behaviours show up in Obsidian's automated plugin review, so they are spelled out here:

Clipboard — write only. The Copy diagnostics button in settings writes your plugin version, Obsidian version, platform, selected OCR backend, number of mapped tags, and last sync time to the clipboard, so you can paste them into a bug report. The plugin never reads your clipboard, and nothing is sent anywhere — you choose where to paste it.
Vault folder list. The tag-routing settings read the list of folders in your vault to fill the "map this tag to a folder" dropdown. Only folder paths are read; note contents are never scanned for this, and the list never leaves your machine.

Support

Found a bug or have a question? Open a GitHub issue. I read every issue.
This is a one-person project. I answer as time allows, and I promise effort, not dates.
Payment, invoices and refunds are handled by Polar.
If your licence key did not arrive, or your report contains private data, email me at [email protected].

Support is the same whether you paid or not. The money buys the feature, nothing else.

Reporting a problem

Open an issue at github.com/thomas-hochbichler/obsidian-remarkable-tagged-sync/issues.

Before you write it, press Copy diagnostics in the plugin settings and paste the result into the issue. It contains your plugin and Obsidian versions, your OS, whether Apple Vision is available, and the last error — nothing is sent anywhere by pressing it.

Requesting a feature

Suggest a feature by opening a feature request. Vote on existing requests with a 👍 reaction — the most-wanted features rise to the top.

Development

npm install
npm run dev      # watch build
npm run build    # typecheck + production build
npm test         # vitest

License

Apache-2.0 for the plugin, except pro/, which is under the PolyForm Strict License 1.0.0 (noncommercial purposes only) — see LICENSE and pro/LICENSE. Paid commercial use is granted by LICENSE-COMMERCIAL.md. Third-party notices are in NOTICE.

reMarkable Tagged Sync