reMarkable MCP Server
PYPI · REMARKABLE-MCP · SCANNED SEP 21
Read, render, search, and manage reMarkable documents through MCP
Available components
How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. How we score → Why this is hard to score →
Supply Chain Security50
- Malware scan not yet available for this package.Unverified
- No known CVEs affecting this package version or its production dependencies.Pass
- Runs hatchling.build at install time, a recognised native-build step with no shell scripting around it. View diagnostics → Pass
- 3 of 47 dependencies flagged as unhealthy. View diagnostics → Partial
Provenance & Transparency45
- Source repository is publicly reachable at the declared URL. View diagnostics → Pass
- Provenance check failed: no build-provenance attestation is published. See how to fix → View diagnostics → Fail
- Clear OSI-approved license (MIT).Pass
- Actively maintained (last published 34 days ago).Pass
- Security-disclosure policy not yet verified: we couldn't inspect the source repository.Unverified
Schema Quality & AI Usability74
- 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).Pass
- AI-judged instruction clarity (excellent).Pass
- Context-footprint check failed: tool/resource definitions use about 5817 tokens (~387/item across 15 items; 14 tools + 1 resources), over budget; trim descriptions and params. See how to fix → Fail
- Usage-examples check failed: none of the tools include examples. See how to fix → Fail
Stability & Change Management93
- Stability observed for 28 of 30 days with no destabilising changes; credit accrues until the full window elapses.Partial
Tool Coverage71
- 100% of tools have a non-trivial description (not blank, and not just the tool's name).Pass
- 0% of tool parameters carry a description.Fail
- Structured output schemas are declared (79% of tools); any adoption earns full credit.Pass
Tool Safety100
- No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.Pass
- All 1 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.Pass
- An AI judge read all 16 captured unit(s) of tool text and found none that tries to manipulate the model reading it.Pass
Capabilities100
- Implements a current MCP spec version (2026-07-28).Pass
- Supports UI / widget rendering.Pass
How do I install the reMarkable MCP Server server?
reMarkable MCP Server runs locally as a PyPI package, launched with uvx remarkable-mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.
pypi · remarkable-mcp
claude mcp add sammorrowdrums-remarkable -- uvx remarkable-mcp
{
"mcpServers": {
"sammorrowdrums-remarkable": {
"command": "uvx",
"args": [
"remarkable-mcp"
]
}
}
} {
"servers": {
"sammorrowdrums-remarkable": {
"command": "uvx",
"args": [
"remarkable-mcp"
]
}
}
} codex mcp add sammorrowdrums-remarkable -- uvx remarkable-mcp
{
"$schema": "https://opencode.ai/config.json",
"mcp": {
"sammorrowdrums-remarkable": {
"type": "local",
"command": [
"uvx",
"remarkable-mcp"
],
"enabled": true
}
}
} openclaw mcp add sammorrowdrums-remarkable --command uvx --arg remarkable-mcp
mcp_servers:
sammorrowdrums-remarkable:
command: "uvx"
args: ["remarkable-mcp"] {
"McpServers": {
"sammorrowdrums-remarkable": {
"Transport": "stdio",
"Command": "uvx",
"Arguments": [
"remarkable-mcp"
]
}
}
} assistant mcp add sammorrowdrums-remarkable -t stdio -c uvx -a remarkable-mcp
{
"mcpServers": {
"sammorrowdrums-remarkable": {
"command": "uvx",
"args": [
"remarkable-mcp"
]
}
}
} Every change we have recorded for this component, newest first. Security-relevant changes are always shown. ▲ marks a change for the better, ▼ a change for the worse; unmarked changes are neutral.
- 21 Sept 26 0
- Security disclosure: fail → unverified ▼ functional
- 20 Sept 26 +1
No change was recorded against any check on this day. Stability & Change Management went from 87 to 90. That category is still filling its 30-day observation window: 26 days of observed history at the previous scan, 27 at this one. The score rises as the window fills, whether or not the server changes.
- 18 Sept 26 +1
No change was recorded against any check on this day. Stability & Change Management went from 80 to 83. That category is still filling its 30-day observation window: 24 days of observed history at the previous scan, 25 at this one. The score rises as the window fills, whether or not the server changes.
- 17 Sept 26 −3
- Stability: pass → 0.80 functional
- 16 Sept 26 0
- Stability: 0.97 → pass security
- 15 Sept 26 +1
No change was recorded against any check on this day. Stability & Change Management went from 93 to 97. That category is still filling its 30-day observation window: 28 days of observed history at the previous scan, 29 at this one. The score rises as the window fills, whether or not the server changes.
- 14 Sept 26 −1
- Stability: pass → 0.93 functional
- 13 Sept 26 0
- Stability: 0.97 → pass security
Diagnostic detail from the automated scan of this channel: what the scanner observed at each step, so you can see exactly where a check passed or failed. It is informational only and never changes the trust score.
Captured 21 Sept 2026 · Analysed pypi/remarkable-mcp@2.1.0
Provenance No attestation
The registry publishes no build provenance for this version, so there is nothing to verify.
| Result | No attestation |
|---|---|
| Ecosystem | pypi |
Background: How many MCP packages publish verified provenance →
Install scripts 1 script
| Hook | Tier | Command |
|---|---|---|
| build_backend | allowlisted | hatchling.build |
Background: Why install scripts are a supply-chain risk →
Dependencies 47 packages
| Packages resolved | 47 |
|---|---|
| Stale | 2 |
| No linked repository | 1 |
| Tree resolution | Complete |
Background: SBOMs and build attestations, explained →
The tools this component advertises to a client, with an estimated token cost for each. Expand a tool to see its parameters and schema. The per-tool counts are indicative and are not scored directly; the schema's total context footprint is one signal in Schema Quality & AI Usability. A tool's description is untrusted text the model reads on every call, which is what makes this list a security surface and not just an inventory: how tool poisoning works →
remarkable_browse ~328
<usecase>Browse your reMarkable library or search for documents.</usecase> <instructions> Three modes: 1. Browse mode (default): List contents of a folder - Use path="/" for root folder - Use path="/FolderName" to navigate into folders 2. Search mode: Find documents by name - Set query="search term" to search across all documents 3. Filter by tags: Find documents with specific tags - Set tags=["tag1", "tag2"] to filter by tags - Works in both browse and search modes Results include document names, types, modification dates, and tags. Note: If REMARKABLE_ROOT_PATH is configured, only documents within that folder are accessible. Paths are relative to the root path. </instructions> <parameters> - path: Folder path to browse (default: "/" for root) - query: Search term to find documents by name (optional, triggers search mode) - tags: List of tags to filter documents (optional, case-insensitive) </parameters> <examples> - remarkable_browse() # List root folder - remarkable_browse("/Work") # List Work folder - remarkable_browse(query="meeting") # Search for "meeting" - remarkable_browse(tags=["important"]) # Show documents with "important" tag - remarkable_browse(query="project", tags=["work"]) # Search with tag filter </examples>
| Name | Type | Req | Description |
|---|---|---|---|
| path | string | – | – |
| query | – | – | – |
| tags | – | – | – |
| Name | Type | Req | Description |
|---|---|---|---|
| result | string | yes | – |
No examples provided.
remarkable_canvas ~226
<usecase>Open a reMarkable page in an interactive canvas viewer.</usecase> <instructions> Renders a notebook or document page and, in clients that support MCP Apps interactive UI, opens a canvas viewer that lets the user page through the document. This is the entry point for the interactive viewer. The canvas is currently a read-only viewer (render + page navigation). For plain image extraction without the interactive surface, use remarkable_image instead. Clients that do not support MCP Apps still get the rendered page back as an embedded PNG image, so this tool is useful everywhere; it just won't open the interactive panel. </instructions> <parameters> - document: Document name or path (use remarkable_browse to find documents) - page: Page number to open (default: 1, 1-indexed) </parameters> <examples> - remarkable_canvas("Meeting Notes") - remarkable_canvas("/Work/Sketches/Wireframe", page=3) </examples>
| Name | Type | Req | Description |
|---|---|---|---|
| document | string | yes | – |
| page | integer | – | – |
No output schema declared.
No examples provided.
remarkable_delete ~303
<usecase>Delete a document or folder on the reMarkable tablet.</usecase> <instructions> DESTRUCTIVE operation. By default the item is moved to the tablet's Trash and remains recoverable. In SSH mode only, permanent=True removes the resolved UUID and all sidecar files instead; use that only when the user explicitly asked for permanent deletion. Works in cloud and SSH modes (default; --read-only disables). Not available over the USB web interface. If the client supports elicitation, this tool asks the user to confirm before deleting. If the client cannot show a confirmation prompt, the delete is refused unless REMARKABLE_SKIP_CONFIRM=1 is set (for headless automation). </instructions> <parameters> - document: Name or path of the document/folder to delete - defer_restart: SSH only. Skip the xochitl restart so a batch of deletes can refresh once via remarkable_refresh() instead of once per delete. Sets "refresh_pending": true. Ignored in cloud mode. - permanent: SSH only. Permanently remove the resolved document/folder files instead of moving the item to Trash (default: False). </parameters> <examples> - remarkable_delete("Old Notes") - remarkable_delete("/Books/Archive/Old Draft") </examples>
| Name | Type | Req | Description |
|---|---|---|---|
| defer_restart | boolean | – | – |
| document | string | yes | – |
| permanent | boolean | – | – |
| Name | Type | Req | Description |
|---|---|---|---|
| result | string | yes | – |
No examples provided.
remarkable_export ~432
<usecase>Export one reMarkable document as a reusable PDF or Markdown file.</usecase> <instructions> Exports a single document without modifying the tablet or its library. The generated file is written to a server-managed temporary directory and returned as an MCP ResourceLink. The tool response stays small: it never embeds the PDF/Markdown as base64 and never writes to an arbitrary host path. The resource expires after 15 minutes and may be evicted earlier when more than eight exports are retained. Fetch and save the linked resource for durable use. PDF behavior: - `pdf_mode="merged"` (default) preserves complete physical pages, combining mapped PDF underlays and reMarkable annotations. - `pdf_mode="annotations"` exports full-page annotation layers only when the transport provides a document archive. - Pages remain in physical device order. A render failure produces a labeled placeholder at that ordinal and a partial-export warning; pages are not skipped. Markdown behavior: - Preserves basic source metadata and fixed source text, typed text, annotation, highlight, and OCR sections. - OCR is opt-in and uses the same configured/cached OCR path as remarkable_read. - Extracted text is kept verbatim; the exporter does not invent headings, lists, links, or page attribution it cannot prove. </instructions> <parameters> - document: Document name or path (use remarkable_browse to find documents). - output_format: "pdf" (default) or "markdown". - pdf_mode: PDF-only mode, "merged" (default) or "annotations". - include_ocr: Enable existing handwriting OCR for Markdown (default: False). </parameters> <examples> - remarkable_export("Meeting Notes") - remarkable_export("Research Paper", output_format="pdf", pdf_mode="annotations") - remarkable_export("Journal", output_format="markdown", include_ocr=True) </examples>
| Name | Type | Req | Description |
|---|---|---|---|
| document | string | yes | – |
| include_ocr | boolean | – | – |
| output_format | string | – | – |
| pdf_mode | string | – | – |
No output schema declared.
No examples provided.
remarkable_image ~764
<usecase>Get an image of a specific page from a reMarkable document.</usecase> <instructions> Renders a notebook or document page as an image (PNG or SVG). This is useful for: - Viewing hand-drawn diagrams, sketches, or UI mockups - Getting visual context that text extraction might miss - Implementing designs based on hand-drawn wireframes - SVG format for scalable vector graphics that can be edited ## Merged PDF + Annotation Rendering PNG pages backed by an imported PDF automatically composite the PDF page with its reMarkable annotations. Set render_merged=False for an annotation-only render, or True to explicitly request compositing. SVG remains annotation-only. ## Response Formats By default, images are returned as embedded resources (EmbeddedResource) which include the full image data inline: - PNG: Returned as BlobResourceContents with base64-encoded data - SVG: Returned as TextResourceContents with SVG markup If your client doesn't support embedded resources in tool responses, set compatibility=True to receive a JSON response with just the resource URI. The client can then fetch the resource separately. Optionally, enable include_ocr=True to extract text from the image using OCR. Google Vision is used when configured; otherwise OCR runs locally with Tesseract. Note: Native notebooks retain their existing stroke rendering behavior. If older USB firmware returns only a native PDF export, PNG remains available; SVG and explicit annotation-only rendering require an rmdoc archive and return a clear error when it is unavailable. </instructions> <parameters> - document: Document name or path (use remarkable_browse to find documents) - page: Page number (default: 1, 1-indexed) - background: Background color as hex code. Supports RGB (#RRGGBB) or RGBA (#RRGGBBAA). Default is "#FBFBFB" (reMarkable paper color), or set REMARKABLE_BACKGROUND_COLOR env var to override. Use "#00000000" for transparent. - output_format: Output format - "png" (default) or "svg" f…
| Name | Type | Req | Description |
|---|---|---|---|
| background | – | – | – |
| compatibility | boolean | – | – |
| document | string | yes | – |
| include_ocr | boolean | – | – |
| output_format | string | – | – |
| page | integer | – | – |
| render_merged | – | – | – |
No output schema declared.
No examples provided.
remarkable_markdown_to_pdf ~416
<usecase>Render Markdown text as a PDF and upload it to the reMarkable tablet.</usecase> <instructions> Use this when the user wants notes, reports, summaries, or other Markdown content written back to the tablet without first creating a local file. Headings, lists, tables, links, blockquotes, and code blocks are rendered into a paginated A4 PDF. Raw HTML is escaped and image assets are omitted so rendering never reads local files or fetches remote content. Works in all three transports: - Cloud: sync upload with parent_folder and document_name - SSH: filesystem upload with parent_folder and document_name - USB web: upload whose multipart filename is document_name + ".pdf"; parent_folder is ignored and the tablet web service chooses the folder. Requires write mode (the default; disabled with --read-only). </instructions> <parameters> - markdown: Markdown source text. Must not be empty. - document_name: Display name on the tablet (default: "Markdown"). - parent_folder: Destination folder (default: root "/"). USB web ignores this parameter because its upload endpoint has no folder argument. - defer_restart: SSH only. When True, skip the xochitl restart and call remarkable_refresh() once after the batch. Forwarded exactly like remarkable_upload; ignored in cloud and USB web modes. </parameters> <examples> - remarkable_markdown_to_pdf("# Meeting Notes\n\n- Follow up with Sam") - remarkable_markdown_to_pdf( "# Q4 Report\n\nRevenue increased **20%**.", document_name="Q4 Report", parent_folder="/Reports", ) - remarkable_markdown_to_pdf( "# Batch item", document_name="Item 1", defer_restart=True ) remarkable_refresh() </examples>
| Name | Type | Req | Description |
|---|---|---|---|
| defer_restart | boolean | – | – |
| document_name | string | – | – |
| markdown | string | yes | – |
| parent_folder | string | – | – |
| Name | Type | Req | Description |
|---|---|---|---|
| result | string | yes | – |
No examples provided.
remarkable_mkdir ~224
<usecase>Create a new folder on the reMarkable tablet.</usecase> <instructions> Creates a folder in the tablet's document hierarchy. In SSH mode the folder appears after xochitl restarts; in cloud mode it syncs to all your devices. Works in cloud and SSH modes (default; --read-only disables). Not available over the USB web interface (the firmware exposes no folder-create endpoint). </instructions> <parameters> - folder_name: Name of the new folder - parent: Parent folder path (default: root "/") - defer_restart: SSH only. Skip the xochitl restart so a batch of writes can refresh once via remarkable_refresh() instead of once per write. Sets "refresh_pending": true. Ignored in cloud mode. </parameters> <examples> - remarkable_mkdir("Projects") - remarkable_mkdir("2024", parent="/Archive") </examples>
| Name | Type | Req | Description |
|---|---|---|---|
| defer_restart | boolean | – | – |
| folder_name | string | yes | – |
| parent | string | – | – |
| Name | Type | Req | Description |
|---|---|---|---|
| result | string | yes | – |
No examples provided.
remarkable_move ~213
<usecase>Move a document or folder to a different location.</usecase> <instructions> Moves a document or folder by updating its parent reference in the metadata. Find the document name with remarkable_browse() first. Works in cloud and SSH modes (default; --read-only disables). Not available over the USB web interface. </instructions> <parameters> - document: Name or path of the document/folder to move - dest_folder: Destination folder path (use "/" for root) - defer_restart: SSH only. Skip the xochitl restart so a batch of writes can refresh once via remarkable_refresh() instead of once per write. Sets "refresh_pending": true. Ignored in cloud mode. </parameters> <examples> - remarkable_move("Meeting Notes", "/Archive") - remarkable_move("Old Project", "/Archive/2023") </examples>
| Name | Type | Req | Description |
|---|---|---|---|
| defer_restart | boolean | – | – |
| dest_folder | string | yes | – |
| document | string | yes | – |
| Name | Type | Req | Description |
|---|---|---|---|
| result | string | yes | – |
No examples provided.
remarkable_read ~547
<usecase>Read and extract text content from a reMarkable document.</usecase> <instructions> Extracts content from a document with pagination to preserve context window. Content types: - "text" (default): Full extracted text (PDF/EPUB content + annotations) - "raw": Original PDF/EPUB text only (no annotations). Works in every transport, as long as the source file is present (very large PDFs/EPUBs may not be synced to the cloud). - "annotations": Only annotations, highlights, and handwritten notes Use pagination to read large documents without overwhelming context: - Start with page=1 (default) - Check "more" field - if true, there's more content - Use "next_page" value to get the next page - "total_pages" is the physical document count; "content_pages" is the extracted-text count used by page/more/next_page - "total_pages_known" reports whether the physical count was available. Raw PDF reads count the downloaded PDF directly. If a raw EPUB archive cannot be read, content still returns with total_pages=null. - If older USB firmware returns only a native PDF, "text" returns source text without annotations and "annotations" reports that the archive is unavailable instead of trying to parse the PDF as a zip. Use grep to search for specific content on the current page. OCR uses Google Vision when configured, otherwise Tesseract. </instructions> <parameters> - document: Document name or path (use remarkable_browse to find documents) - content_type: "text" (full), "raw" (PDF/EPUB only), "annotations" (notes only) - page: Extracted-content page number (default: 1). Physical document pages are reported separately as total_pages. - grep: Optional regex pattern to filter content (searches current page) - include_ocr: Enable handwriting OCR for annotations (default: False) </parameters> <examples> - remarkable_read("Meeting Notes") # Get first page of text - remarkable_read("Book.pdf", content_type="raw") # Get raw PDF text - remarkable_read("Notes", cont…
| Name | Type | Req | Description |
|---|---|---|---|
| content_type | string | – | – |
| document | string | yes | – |
| grep | – | – | – |
| include_ocr | boolean | – | – |
| page | integer | – | – |
| Name | Type | Req | Description |
|---|---|---|---|
| result | string | yes | – |
No examples provided.
remarkable_recent ~181
<usecase>Get your most recently modified documents.</usecase> <instructions> Returns documents sorted by modification date (newest first). Optionally includes a text preview of each document's content. Use this to quickly find what you were working on recently. Note: If REMARKABLE_ROOT_PATH is configured, only documents within that folder are included. </instructions> <parameters> - limit: Maximum documents to return (default: 10, max: 50 without preview, 10 with preview) - include_preview: Include first ~200 chars of text content (default: False) </parameters> <examples> - remarkable_recent() # Last 10 documents - remarkable_recent(limit=5, include_preview=True) # With content preview </examples>
| Name | Type | Req | Description |
|---|---|---|---|
| include_preview | boolean | – | – |
| limit | integer | – | – |
| Name | Type | Req | Description |
|---|---|---|---|
| result | string | yes | – |
No examples provided.
remarkable_rename ~219
<usecase>Rename a document or folder on the reMarkable tablet.</usecase> <instructions> Changes the display name of a document or folder by updating its metadata. Find the document name with remarkable_browse() first. Works in cloud and SSH modes (default; --read-only disables). Not available over the USB web interface. </instructions> <parameters> - document: Current name or path of the document/folder - new_name: New display name - defer_restart: SSH only. Skip the xochitl restart so a batch of writes can refresh once via remarkable_refresh() instead of once per write. Sets "refresh_pending": true. Ignored in cloud mode. </parameters> <examples> - remarkable_rename("Untitled", "Meeting Notes 2024-01-15") - remarkable_rename("/Work/Draft", "Final Report") </examples>
| Name | Type | Req | Description |
|---|---|---|---|
| defer_restart | boolean | – | – |
| document | string | yes | – |
| new_name | string | yes | – |
| Name | Type | Req | Description |
|---|---|---|---|
| result | string | yes | – |
No examples provided.
remarkable_search ~306
<usecase>Search across multiple documents and return matching content.</usecase> <instructions> Searches document names for the query, then optionally searches content with grep. Can filter by tags to narrow results. Returns summaries from multiple documents in a single call. This is efficient for finding information across your library without making many individual tool calls. Limits: - Max 5 documents per search (to keep response size manageable) - Returns first page (~8000 chars) of each matching document - Use grep to filter to relevant sections </instructions> <parameters> - query: Search term for document names - grep: Optional pattern to search within document content - limit: Max documents to return (default: 5, max: 5) - include_ocr: Enable OCR for handwritten content (default: False) - tags: List of tags to filter documents (optional, case-insensitive) </parameters> <examples> - remarkable_search("meeting") # Find docs with "meeting" in name - remarkable_search("journal", grep="project") # Find "project" in journals - remarkable_search("notes", include_ocr=True) # Search with OCR enabled - remarkable_search("project", tags=["work"]) # Find work-tagged projects </examples>
| Name | Type | Req | Description |
|---|---|---|---|
| grep | – | – | – |
| include_ocr | boolean | – | – |
| limit | integer | – | – |
| query | string | yes | – |
| tags | – | – | – |
| Name | Type | Req | Description |
|---|---|---|---|
| result | string | yes | – |
No examples provided.
remarkable_status ~299
<usecase>Check connection status, active transport, and write capabilities.</usecase> <instructions> Returns authentication status, the active transport (cloud, local-dir, ssh, or usb-web), the document count, and a capability matrix describing what each transport can do. Use this to verify your connection, choose a transport, or troubleshoot. Capability notes: - Export is available in every transport and creates only a bounded temporary local resource; it never modifies the tablet. - Cloud (default): full read/render/export/upload/mkdir/move/rename/delete — no device needed, works from anywhere your token is valid. - SSH: full capabilities over a local/USB connection to the tablet. - USB web: read, render, export, and upload (to root) only — the tablet's USB web interface firmware exposes no folder/move/rename/delete endpoints. For full write parity over a USB cable, use SSH mode pointed at the USB IP. - Local directory: fully offline read/render/export access to the desktop app's sync cache. Strictly read-only to avoid corrupting app-managed state. Write tools (upload/mkdir/move/rename/delete) are enabled by default; run with --read-only (or REMARKABLE_READ_ONLY=1) to expose a read-only server. </instructions> <examples> - remarkable_status() </examples>
Input schema present but exposes no named parameters.
| Name | Type | Req | Description |
|---|---|---|---|
| result | string | yes | – |
No examples provided.
remarkable_upload ~454
<usecase>Upload a PDF or EPUB file to the reMarkable tablet.</usecase> <instructions> Uploads a local file to the tablet. Only PDF and EPUB formats are supported. Works in all three transports: - Cloud: uploaded via the sync protocol; supports parent_folder + document_name - SSH: transferred over SSH, metadata created; supports parent_folder + document_name - USB web: uploaded via POST /upload. The multipart filename carries document_name, parent_folder is ignored, and the tablet web service chooses the destination folder. Requires write mode (the default; disabled with --read-only). </instructions> <parameters> - file_path: Absolute path to the local PDF or EPUB file - parent_folder: Destination folder path on tablet (default: root "/"). Honored in cloud and SSH modes; ignored by the USB web interface. - document_name: Display name on tablet (default: filename without extension). Honored in every mode; USB web uses it as the uploaded filename. - defer_restart: SSH only. When True, skip the xochitl restart that normally makes the upload visible. Use this for every upload in a batch, then call remarkable_refresh() ONCE at the end. Each restart forces a full document-store rescan that briefly destabilises the SSH link, so deferring turns N restarts (and N races) into one. The response sets "refresh_pending": true while a refresh is owed. Ignored in cloud/USB modes (no xochitl). </parameters> <examples> - remarkable_upload("/tmp/paper.pdf") - remarkable_upload("/tmp/book.epub", parent_folder="/Books") - remarkable_upload("/tmp/report.pdf", document_name="Q4 Report") - # batch import: defer every upload, refresh once at the end remarkable_upload("/tmp/a.pdf", defer_restart=True) remarkable_upload("/tmp/b.pdf", defer_restart=True) remarkable_refresh() </examples>
| Name | Type | Req | Description |
|---|---|---|---|
| defer_restart | boolean | – | – |
| document_name | – | – | – |
| file_path | string | yes | – |
| parent_folder | string | – | – |
| Name | Type | Req | Description |
|---|---|---|---|
| result | string | yes | – |
No examples provided.
What is the reMarkable MCP Server server?
reMarkable MCP Server is listed in the public MCP registry as io.github.SamMorrowDrums/remarkable. Read, render, search, and manage reMarkable documents through MCP. This page covers its PyPI package (remarkable-mcp).
Is the reMarkable MCP Server server safe to use?
reMarkable MCP Server scores 66 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 21 September 2026. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.
What tools does the reMarkable MCP Server server expose?
reMarkable MCP Server exposes 14 tools: remarkable_read, remarkable_browse, remarkable_recent, remarkable_search, remarkable_status, and 9 more. Their descriptions and schemas cost roughly 4,912 tokens of context every time the server is loaded.
Is the reMarkable MCP Server server still maintained?
reMarkable MCP Server is still listed as active in the MCP registry. We last reached this channel on 21 September 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.
What licence is the reMarkable MCP Server server under?
reMarkable MCP Server declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.