reMarkable MCP Server

Access a reMarkable library from MCP clients such as Claude, VS Code Copilot, OpenWebUI, and other compatible tools.

Features

• Browse folders and recent documents.
• Search names, tags, and extracted text.
• Read typed text, PDF and EPUB text, highlights, and annotations.
• Render notebooks and annotated PDFs as PNG or SVG.
• Export one document as a complete PDF or sectioned Markdown resource.
• Run handwriting OCR through Google Vision or Tesseract.
• Upload files and manage folders in supported transports.
• Render Markdown as PDF and upload it to the tablet.
• Open an interactive canvas in clients that support MCP Apps.
• Serve MCP over stdio or local Streamable HTTP.
• Serve MCP 2026-07-28 and every earlier SDK-supported revision from one stable SDK 2.x MCPServer.

---

Quick Install

Prerequisite: install uv

The commands below use uvx, which is included with uv. Page images are rasterized with PyMuPDF; no system Cairo, browser, or graphics runtime needs to be installed on macOS, Linux, or Windows.

macOS and Linux

Use the official standalone installer:

curl -LsSf https://astral.sh/uv/install.sh | sh

Or install with Homebrew:

brew install uv

Windows

Use the official standalone installer from PowerShell:

powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

Or install with WinGet:

winget install --id=astral-sh.uv -e

Choose a connection

Start with the first mode that fits your setup.

Order	Mode	Setup	Writes	Use when
1	USB web	Connect the tablet and enable USB web	Upload; destination chosen by tablet	You want the shortest setup without a subscription or developer mode
2	Local directory	Install and sign in to the desktop app	No	You want offline, device-free reads from the desktop cache
3	Cloud	Register once; Connect subscription required	Full document and folder management	You need wireless or remote access
4	SSH	Enable developer mode and configure SSH	Full management and native authoring	You need direct filesystem access or native ink writes

USB Web Interface

Connect via USB and enable the web interface in your tablet's Storage Settings.

1. Connect your reMarkable via USB
2. On your tablet, open Settings > Storage and enable USB web interface
3. Install via the button above

Add to .vscode/mcp.json:

{
  "servers": {
    "remarkable": {
      "command": "uvx",
      "args": ["remarkable-mcp", "--usb"],
      "env": {
        "GOOGLE_VISION_API_KEY": "your-api-key"
      }
    }
  }
}

• Make sure your reMarkable is connected via USB and unlocked
• Verify USB web interface is enabled in Settings > Storage
• The tablet should be accessible at http://10.11.99.1

---

Local Directory Mode

Read the official reMarkable desktop app's sync folder from disk. This mode is offline and read-only. The desktop app controls synchronization.

Add to .vscode/mcp.json:

{
  "servers": {
    "remarkable": {
      "command": "uvx",
      "args": ["remarkable-mcp", "--local-dir"]
    }
  }
}

With no path, the desktop app's data folder is auto-detected:

• macOS (current app): ~/Library/Containers/com.remarkable.desktop/Data/Library/Application Support/remarkable/desktop
• macOS (legacy app): ~/Library/Application Support/remarkable/desktop
• Windows: %APPDATA%\remarkable\desktop
• Linux: ~/.local/share/remarkable/desktop

Or point at any xochitl-style directory (e.g. a tablet backup):

{
  "servers": {
    "remarkable": {
      "command": "uvx",
      "args": ["remarkable-mcp", "--local-dir", "/path/to/xochitl-data"]
    }
  }
}

• Content freshness depends on the desktop app. Keep it running and signed in.
• This mode is read-only. Direct writes could bypass synchronization and corrupt the app cache.
• If the directory can't be found and a cloud token is configured, the server falls back to cloud mode for read access (the server remains read-only because it was launched in local-directory mode)

---

Cloud Mode

Cloud mode works without a device connection and requires a reMarkable Connect subscription.

It fetches metadata in parallel and caches content-addressed blobs on disk. See Cloud performance and caching for configuration.

1. Get a One-Time Code

Go to my.remarkable.com/device/desktop/connect and generate a code.

2. Convert to Token

uvx remarkable-mcp --register YOUR_CODE

Registration saves the token to ~/.rmapi. When your MCP client runs the server as the same user on the same machine, remarkable-mcp reads that file automatically, so you do not need to put a token in the client configuration. Set REMARKABLE_TOKEN only when ~/.rmapi is unavailable, such as when the server runs under another user or on another machine.

3. Configure your MCP client

Minimal client-neutral server definition

Add this server definition using the MCP configuration UI or wrapper required by your client:

{
  "command": "uvx",
  "args": ["remarkable-mcp"]
}

No env entry is needed when the server can read the token from ~/.rmapi.

VS Code

VS Code's .vscode/mcp.json uses a top-level servers object. The saved ~/.rmapi credential means no token input is required:

{
  "servers": {
    "remarkable": {
      "command": "uvx",
      "args": ["remarkable-mcp"]
    }
  }
}

Claude Desktop and other clients

Claude Desktop and many other MCP clients use a top-level mcpServers object and literal values in env; they do not use VS Code's inputs array. With the token available in ~/.rmapi, the minimal configuration is:

{
  "mcpServers": {
    "remarkable": {
      "command": "uvx",
      "args": ["remarkable-mcp"]
    }
  }
}

If the token file is unavailable, add "env": {"REMARKABLE_TOKEN": "your-token"} to the remarkable server entry. Consult your client's documentation if it uses a different outer key or secret-storage mechanism.

---

SSH Mode

SSH provides direct filesystem access and native notebook authoring. It requires developer mode, which factory-resets the tablet when enabled. Use this mode only when USB web, local directory, or cloud mode does not provide the operation you need.

{
  "servers": {
    "remarkable": {
      "command": "uvx",
      "args": ["remarkable-mcp", "--ssh"]
    }
  }
}

See the SSH setup guide for authentication and device setup.

---

---

Connection Modes

All modes support reading, rendering, and single-document export. Cloud and SSH support full library management. USB web supports upload but does not accept a destination folder. Local directory mode is read-only.

Mode	Setup	Subscription	Offline	Tablet required	Raw source	Upload	Folder operations¹
Local directory	Desktop app installed	No²	Yes	No	PDF and EPUB	No	No
USB web	Enable in Settings	No	Yes	Yes	PDF	Root only	No
Cloud	One-time registration	Connect	No	No	PDF and EPUB	Yes	Yes
SSH	Developer mode	No	Yes	Yes	PDF and EPUB	Yes	Yes

¹ Folder ops = create folder / move / rename / delete. Upload and folder ops are enabled by default; pass --read-only to expose a read-only server. Deletes move items to the trash and prompt for confirmation when your client supports elicitation, and are refused without it unless REMARKABLE_SKIP_CONFIRM=1 is set.

² The desktop app itself signs in to the reMarkable cloud to sync; local directory mode just reads whatever the app has already synced to disk.

Automatic cloud fallback

If a selected device transport is unavailable and a cloud credential is configured, the server falls back to cloud mode. A server launched with --local-dir remains read-only after fallback. remarkable_status reports the effective transport and sets fell_back_to_cloud.

Pass --no-cloud-fallback (or set REMARKABLE_DISABLE_CLOUD_FALLBACK=1) to disable this and fail instead when the device is unreachable.

The transport is resolved once per server process. Restart the MCP server after connecting a device or starting the desktop app if the process already fell back to cloud.

Detailed setup:

• USB web setup
• SSH setup
• Cloud performance and caching

---

OpenWebUI (Streamable HTTP)

OpenWebUI's native MCP connection uses Streamable HTTP. Start remarkable-mcp on the same machine:

uvx remarkable-mcp --http

Then add http://127.0.0.1:8000/mcp as the MCP server URL in OpenWebUI. The HTTP transport combines with --usb, --ssh, and --read-only; for example:

uvx remarkable-mcp --usb --http

The bind address and port can also be set with --host / --port or REMARKABLE_MCP_HOST / REMARKABLE_MCP_PORT.

The server uses MCP Python SDK 2.x's dual-era endpoint. Modern 2026-07-28 requests are sessionless; older clients continue to use the initialize handshake and legacy MCP sessions on the same /mcp route. The reMarkable token and selected tablet transport remain process-local CLI/env configuration and are never inferred from MCP HTTP authorization headers.

[!WARNING] Streamable HTTP has no built-in authentication. It binds to 127.0.0.1 by default. Keep that default unless you control the network boundary. Wildcard binds such as 0.0.0.0 and :: are rejected because they cannot provide a strict Host allowlist. A concrete non-loopback address is allowed but exposes every enabled tool, including writes, to clients that can reach the port.

Remote access through an authenticated reverse proxy

Keep remarkable-mcp on its default loopback bind and put the proxy on the same host. MCPServer's DNS-rebinding protection only permits loopback Host and Origin values by default. A proxy that forwards its public hostname unchanged will therefore receive 421 Misdirected Request; a public browser Origin will receive 403 Forbidden.

The proxy must authenticate requests, rewrite Host to the loopback upstream, and clear Origin. For example, with nginx and an existing htpasswd file:

location /mcp {
    auth_basic "reMarkable MCP";
    auth_basic_user_file /etc/nginx/remarkable-mcp.htpasswd;

    proxy_pass http://127.0.0.1:8000;
    proxy_http_version 1.1;
    proxy_buffering off;
    proxy_read_timeout 3600s;

    # Required by MCPServer's default DNS-rebinding protection.
    proxy_set_header Host 127.0.0.1:8000;
    proxy_set_header Origin "";
}

Do not expose the upstream port directly. Configure OpenWebUI with the authenticated proxy URL, such as https://mcp.example.com/mcp.

For NixOS, remarkable-mcp-bridge.nix provides a systemd module with the same loopback default:

{
  imports = [ ./remarkable-mcp-bridge.nix ];
  services.remarkable-mcp = {
    enable = true;
    command = "/opt/remarkable-mcp/.venv/bin/remarkable-mcp";
  };
}

The service user must have its reMarkable credentials under /var/lib/remarkable-mcp (or the configured home). The module adds Tesseract to the service's executable search path; install the configured command separately.

---

OpenClaw Integration

remarkable-mcp works as an OpenClaw skill. Add to your openclaw.json:

{
  "mcpServers": {
    "remarkable": {
      "command": "uvx",
      "args": ["remarkable-mcp", "--usb"]
    }
  }
}

Install from ClawHub:

clawhub install remarkable-mcp

Or copy the SKILL.md from this repository into your ~/.openclaw/skills/remarkable-mcp/ directory.

---

Tools

Tool	Description
remarkable_read	Read and extract text from documents (with pagination and search)
remarkable_browse	Navigate folders, search by document name, or filter by tags
remarkable_search	Search content across multiple documents (with tag filtering)
remarkable_recent	Get recently modified documents
remarkable_status	Check connection status and the per-transport capability matrix
remarkable_image	Get PNG/SVG images of pages with optional OCR
remarkable_export	Export one document as a temporary PDF or Markdown resource

The read/search/render tools are read-only. remarkable_export never changes the tablet, but it writes a bounded temporary file on the MCP server host and therefore declares readOnlyHint=false. Export links expire after 15 minutes and the server retains at most eight at a time. Supported transports also register write tools by default; pass --read-only to disable them. See Write Tools. Clients that support MCP Apps can also open remarkable_canvas.

Full tools reference

Tool behavior

• Browsing a document path returns its content.
• Empty notebook text can trigger OCR automatically.
• Search can scan several matching documents.
• Image tools return visual content that text extraction misses.
• remarkable_read.total_pages is the physical document count; content_pages counts extracted-text chunks, and more / next_page continue those chunks. Raw PDF reads count pages from the already-downloaded PDF. If a raw EPUB's separate archive cannot be read, its text still returns with total_pages: null and total_pages_known: false.
• PNG images of PDF-backed pages merge the source page and annotations automatically; pass render_merged=False for the annotation layer alone.
• PDF exports preserve physical page order and merge mapped source underlays with annotations by default. Markdown exports keep fixed source/typed/annotation/ highlight/OCR sections without guessing document structure.
• OCR uses Google Vision when configured and otherwise runs locally with Tesseract.
• Browse and search accept tag filters.

Example Usage

# Read a document
remarkable_read("Meeting Notes")

# Search for keywords
remarkable_read("Project Plan", grep="deadline")

# Enable OCR for handwritten notes
remarkable_read("Journal", include_ocr=True)

# Browse your library
remarkable_browse("/Work/Projects")

# Filter by tags
remarkable_browse("/", tags=["important"])
remarkable_browse("/Work", tags=["project", "active"])

# Search across documents
remarkable_search("meeting", grep="action items")

# Search with tag filter
remarkable_search("project", tags=["work"])

# Get recent documents
remarkable_recent(limit=10)

# Get a page image (for visual content like UI mockups or diagrams)
remarkable_image("UI Mockup", page=1)

# Get SVG for editing in design tools
remarkable_image("Wireframe", output_format="svg")

# Get image with OCR text extraction
remarkable_image("Handwritten Notes", include_ocr=True)

# Imported PDF pages include their reMarkable annotations automatically
remarkable_image("Research Paper", page=3)

# Request only the reMarkable annotation layer
remarkable_image("Research Paper", page=3, render_merged=False)

# Transparent background for compositing
remarkable_image("Logo Sketch", background="#00000000")

# Compatibility mode: return resource URI instead of embedded resource
remarkable_image("Diagram", compatibility=True)

# Export a complete PDF through a temporary MCP ResourceLink
remarkable_export("Meeting Notes")

# Export honest, sectioned Markdown with opt-in OCR
remarkable_export("Journal", output_format="markdown", include_ocr=True)

# Export only full-page annotation layers when archive data is available
remarkable_export("Research Paper", pdf_mode="annotations")

Note: PNG rendering uses PyMuPDF for both notebook SVGs and PDF pages, so remarkable_image does not require Cairo, Inkscape, Chromium, or another system graphics runtime. If local stroke parsing cannot handle a page, USB and SSH modes fall back to the tablet's native PDF export and cloud mode falls back to an original source PDF when one exists.

---

Resources

Documents are automatically registered as MCP resources:

URI Scheme	Description
remarkable:///{path}.txt	Extracted text content
remarkableraw:///{path}.pdf.txt	Extracted text from the original PDF
remarkableraw:///{path}.epub.txt	Extracted text from the original EPUB
remarkableimg:///{path}.page-{N}.png	PNG image of page N (notebooks only)
remarkablesvg:///{path}.page-{N}.svg	SVG vector image of page N (notebooks only)
remarkableexport:///{format}/{id}	Temporary generated PDF or Markdown export

Trashed documents are excluded from tool, canvas, and resource lookup, so a trashed item cannot shadow a live document with the same name.

remarkable_export returns a ResourceLink instead of embedding potentially large file content in the tool response. The server stores the file in a private temporary directory for 15 minutes, retains at most eight exports, and removes managed exports at shutdown. Fetch and save the linked resource for durable use.

Full resources reference

---

OCR for Handwriting

For handwritten content, remarkable-mcp offers two OCR backends:

Backend	Setup	Offline	Notes
Google Vision	API key	No	Good handwriting support
Tesseract	System install	Yes	Better suited to printed text

Quick Setup

Set REMARKABLE_OCR_BACKEND in your MCP config:

{
  "env": {
    "REMARKABLE_OCR_BACKEND": "auto"
  }
}

Options: auto, google, tesseract

1. Enable Cloud Vision API
2. Create an API key
3. Add to config: "GOOGLE_VISION_API_KEY": "your-key"

Cost: 1,000 free requests/month, then ~$1.50 per 1,000.

Google Vision setup guide

Open-source OCR designed for printed text. Poor results with handwriting, but useful as an offline fallback.

# Install Tesseract
# macOS
brew install tesseract

# Ubuntu/Debian
sudo apt install tesseract-ocr

# Windows
choco install tesseract

Default Behavior (auto)

When REMARKABLE_OCR_BACKEND=auto (default):

1. Google Vision (if GOOGLE_VISION_API_KEY is set)
2. Tesseract (fallback)

---

Write Tools by Transport

Write tools let you upload, organize, and manage documents on your reMarkable. Enabled by default on write-capable transports. Cloud and SSH modes support the full set; USB web supports upload only (its firmware exposes no folder operations); local-directory mode is always read-only. Pass --read-only to expose a read-only server elsewhere.

Feature	Local Directory	Cloud Mode	SSH Mode	USB Web Mode
Upload	❌	✅	✅	✅ (tablet-selected folder)
Mkdir	❌	✅	✅	❌
Move	❌	✅	✅	❌
Rename	❌	✅	✅	❌
Delete	❌	✅ (→ trash)	✅ (→ trash; optional permanent)	❌

Disabling Write Tools (read-only mode)

Write tools are on by default in each write-capable mode. Local-directory mode is always read-only. To make another transport read-only, add the --read-only flag:

{
  "servers": {
    "remarkable": {
      "command": "uvx",
      "args": ["remarkable-mcp", "--read-only"]
    }
  }
}

It combines with any transport flag (--ssh, --usb):

{
  "servers": {
    "remarkable": {
      "command": "uvx",
      "args": ["remarkable-mcp", "--ssh", "--read-only"]
    }
  }
}

Or set the environment variable:

{
  "env": {
    "REMARKABLE_READ_ONLY": "1"
  }
}

The legacy --write flag and REMARKABLE_ENABLE_WRITE variable are still accepted for backward compatibility but are now no-ops (write is the default). --write and --read-only are mutually exclusive.

Available Write Tools

Tool	Description
remarkable_upload(file_path, parent_folder, document_name, defer_restart)	Upload a PDF or EPUB file (cloud, SSH, and USB web; USB web preserves the name but ignores parent_folder)
remarkable_markdown_to_pdf(markdown, document_name, parent_folder, defer_restart)	Render Markdown as a paginated PDF and upload it (cloud, SSH, and USB web)
remarkable_mkdir(folder_name, parent, defer_restart)	Create a new folder (cloud and SSH)
remarkable_move(document, dest_folder, defer_restart)	Move a document or folder (cloud and SSH)
remarkable_rename(document, new_name, defer_restart)	Rename a document or folder (cloud and SSH)
remarkable_delete(document, defer_restart, permanent)	Move a document/folder to Trash; SSH can permanently remove it with permanent=True
remarkable_refresh()	Safely restart xochitl once to apply pending writes made with defer_restart=True; no-op after this process has confirmed a clean state — SSH only
remarkable_author(method, ..., defer_restart)	Author native ink and notebooks — draw (append strokes), add_page (append a blank notebook page), create_document (new notebook) — SSH only

Safety