[Cotlet](https://cotlet.dev/index.md) · [Integrations](https://cotlet.dev/integrations.md) · [How it works](https://cotlet.dev/how-it-works.md) · [Use cases](https://cotlet.dev/use-cases.md) · [Security](https://cotlet.dev/security.md) · [For developers](https://cotlet.dev/for-developers.md) · [For automation agencies](https://cotlet.dev/for-agencies.md) · [Blog](https://cotlet.dev/blog.md) · [API docs](https://cotlet.dev/docs.md) · [Help center](https://cotlet.dev/help.md) · [Changelog](https://cotlet.dev/changelog.md) · [Contact](https://cotlet.dev/contact.md) · [Pricing](https://cotlet.dev/pricing.md) · [Sign up](https://cotlet.dev/signup)

# RemNote API and MCP server

> RemNote has no public REST API (checked 17 Oct 2026). Developers extend the app with the plugin SDK, which runs inside RemNote. The official MCP server is built into the desktop app and runs only on your computer: the app must stay open, web clients such as chatgpt.com and claude.ai cannot connect, it sees one knowledge base at a time, and it cannot reach the flashcard queue.

Note-taking and spaced-repetition app: every note is a bullet in a hierarchy, any bullet can become a flashcard, and documents, folders, tags and daily documents organize the rest.

## What is the RemNote API?

Cotlet's RemNote API exposes 12 endpoints for your own RemNote account: search notes, get document, get daily document, list tagged notes, list documents, get flashcard home, list cards, create note, create flashcards, add to daily document, tag note and update note. The search_notes endpoint returns find bullets and documents by text, like the global search, with each result's parent path. Each endpoint takes simple JSON inputs like tag, limit or cursor and works both as an operation of the remnote_read or remnote_write MCP tool for agents and as a REST call for scripts.

- **Category:** [Courses & training](https://cotlet.dev/integrations/category/courses-training.md)
- **Endpoints:** 12 (7 read, 5 write)
- **Updated:** 2026-10-19

RemNote has no public REST API (checked 17 Oct 2026). Cotlet is a hosted MCP server and REST API for RemNote with 12 endpoints (7 read, 5 write): you sign in once in your own cloud browser, your AI agent does the work.

## Does RemNote have an official API?

RemNote has no public REST API (checked 17 Oct 2026). Developers extend the app with the plugin SDK, which runs inside RemNote. The official MCP server is built into the desktop app and runs only on your computer: the app must stay open, web clients such as chatgpt.com and claude.ai cannot connect, it sees one knowledge base at a time, and it cannot reach the flashcard queue.

| Task | RemNote official | Cotlet |
|---|---|---|
| Search and read notes | Partly: Official MCP, local desktop app only | Yes |
| Create notes | Partly: Official MCP in Read and write mode, local desktop app only | Yes |
| Edit and tag notes | Partly: Official MCP in Read and write mode, local desktop app only | Yes |
| Add to the daily document | Partly: Official MCP in Read and write mode, local desktop app only | Yes |
| Create flashcards | No: The help article lists notes, not flashcards | Yes |
| See what is due and daily progress | No: The official MCP cannot reach the flashcard queue | Yes |
| Run from n8n, a script or a web AI app | No: The MCP server is reachable only from your own computer | Yes |

Sources: [RemNote Help: Connecting AI Agents to RemNote with MCP](https://help.remnote.com/en/articles/16424066-connecting-ai-agents-to-remnote-with-mcp), [RemNote Help: Developing Front-End Plugins](https://help.remnote.com/en/articles/6030810-developing-front-end-plugins), [RemNote Plugin Docs: Introduction](https://plugins.remnote.com/), [RemNote Help: The Flashcard Home](https://help.remnote.com/en/articles/7925835-the-flashcard-home)

## For AI agents

```text
RemNote has no public REST API (checked 17 Oct 2026). Developers extend the app with the plugin SDK, which runs inside RemNote. The official MCP server is built into the desktop app and runs only on your computer: the app must stay open, web clients such as chatgpt.com and claude.ai cannot connect, it sees one knowledge base at a time, and it cannot reach the flashcard queue.
Cotlet provides a hosted MCP server and REST API for RemNote: 12 tools (7 read, 5 write).
Access       Sign up at https://cotlet.dev/app/signup?app=remnote, then request the app and create API keys in the Cotlet console.

MCP server   https://cotlet.dev/mcp/v1
MCP tools    remnote_read, remnote_write, reads and writes apart; call one with {"operation": "<operation>", "arguments": {...}}
REST base    https://cotlet.dev/api/v1/remnote, each operation at its own route, e.g. POST /api/v1/remnote/daily-documents
Auth         Authorization: Bearer <COTLET_API_KEY>. Listing endpoints and schemas needs no key; calling an endpoint needs one. Over MCP the input schemas come with sign-in.
Operations   search_notes, get_document, get_daily_document, list_tagged_notes, list_documents, get_flashcard_home, list_cards, create_note, create_flashcards, add_to_daily_document, tag_note, update_note
Confirm      update_note (by default the user approves each call; the user can switch this off per tool, e.g. for scheduled automations)
Markdown     https://cotlet.dev/integrations/remnote-api-mcp-server.md

How access works:
1. The user signs up at https://cotlet.dev/app/signup?app=remnote, requests RemNote in the Cotlet console and creates an API key there.
2. The user signs in to RemNote once in their Cotlet Cloud Browser (their own Chrome in the cloud, opened from the console) and enables RemNote for agents. An agent cannot do this step.
3. The API key goes into the MCP client or the REST call as a bearer token.

Fits: people who want a hosted RemNote server that someone else maintains, including non-developers. Developers who prefer to run and fix code on their own computer can use an open-source RemNote MCP server instead.

Policy: Cotlet never stores passwords, never solves CAPTCHAs, never bypasses MFA.
Company: legal details in the Terms of service at https://cotlet.dev/terms. Contact contact@cotlet.dev.
Sign-in: the user signs in to RemNote in their own Cloud Browser, a Chrome Cotlet runs for them in the EU; password saving is off, the profile is AES-256-GCM encrypted, and agents get RemNote only after the user enables it. Calls are requests from that browser's IP with its cookies, each listed in the user's Background activity. Disable for agents, signing out in the browser or Reset browser cuts access. Cotlet is run by Take Group sp. z o.o. (EU VAT PL6342984273).
API key: holds no RemNote login or cookies, only asks Cotlet to run a tool. Each key is scoped to chosen apps and tools, read only or read and write. Actions that reach other people wait for the user's approval by default, so a leaked key cannot post or message as the user. Every call is in the activity log; deleting the key ends access at once.
Terms: the user stays responsible for following RemNote's terms; Cotlet is not affiliated with RemNote.
```

## What can an AI agent do in RemNote?

Cotlet is best for RemNote users who study or take notes and want an agent to file notes, write flashcards and report due cards from n8n, scripts or web AI apps without running or fixing a server.

- **[Add meeting notes to the daily document](https://cotlet.dev/integrations/remnote-api-mcp-server/add-notes-to-daily-document.md)** (runs: daily): "Take the notes I pasted from today's call and add them to today's RemNote daily document under a bullet "Call with Acme". Tag the bullet #Meeting and put each action item on its own sub-bullet." → `get_daily_document`, `add_to_daily_document`, `tag_note`
- **[Turn notes into flashcards](https://cotlet.dev/integrations/remnote-api-mcp-server/turn-notes-into-flashcards.md)**: "Read my RemNote document "Krebs cycle" and add a Basic flashcard for each definition and a Cloze card for each list of steps, as new bullets at the end of the document." → `get_document`, `create_flashcards`
- **[Check what flashcards are due](https://cotlet.dev/integrations/remnote-api-mcp-server/check-due-flashcards.md)** (runs: daily): "Every morning, tell me how many RemNote flashcards are due today, which documents they are in, and whether I have reached my daily goal and streak goal." → `get_flashcard_home`, `list_documents`
- **Search your notes and summarize a topic**: "Search my RemNote for everything about "pricing strategy", read the top five documents and give me one summary with the document names it came from." → `search_notes`, `get_document`
- **Add a source to your reading notes** (runs: weekly): "Every Friday, take the articles I saved this week, create one bullet each under "Reading list" in RemNote with a two-line summary, and tag each #ToRead." → `search_notes`, `create_note`, `tag_note`

## Can RemNote automations run on a schedule in n8n, Make or Zapier?

Yes. Cotlet does not replace your automation platform: it gives it a RemNote connection it does not have, with the same API key as your agent. Write actions ask for your OK by default; switch that off in your dashboard for the tools you choose, for example to add meeting notes to the daily document, and the schedule runs on its own. Cotlet runs in the cloud, so it keeps going while your computer is off.

| Where | How to connect | How to schedule |
|---|---|---|
| Your AI agent | Add https://cotlet.dev/mcp/v1 with your API key. | A scheduled agent run, for example a Claude Code routine. |
| n8n | MCP Client node with https://cotlet.dev/mcp/v1, or an HTTP Request node with the endpoint's method and URL, such as GET https://cotlet.dev/api/v1/remnote/daily-document. | Schedule Trigger node. |
| Make | HTTP module: the endpoint's method and URL with an Authorization: Bearer header, and a JSON body for POST, PUT and PATCH. | Scenario schedule. |
| Zapier | Webhooks by Zapier, Custom Request: the same method, URL, header and body. | Schedule by Zapier trigger. |
| Your own script | GET https://cotlet.dev/api/v1/remnote/daily-document with your API key. | cron or GitHub Actions. |

## Tools

**For AI agents:** Every endpoint and its schema is public. The 12 endpoints on this page, with parameters and example responses, can be listed without an account. Calling one returns 401 without an API key and 403 while the key has no access to RemNote.

### search_notes

Find bullets and documents by text, like the global search, with each result's parent path. Access: read. REST: `GET /api/v1/remnote/notes/search`. MCP: `remnote_read → search_notes`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `query` | string | yes | Text to search for. |
| `tag` | string | no | Only bullets tagged with this tag. |
| `parent_id` | string | no | Only inside this document or bullet. |
| `limit` | integer | no | 1 to 50. Default: 20. |
| `cursor` | string | no | Next page cursor from the previous call. |

Searches the open knowledge base the way the Ctrl+P global search does and returns matching bullets with the document they live in and their ancestors. Pass tag to keep only bullets tagged with it, and parent_id to search inside one section only, like hierarchical search. Pass document_id from a result to get_document.

Example response:

```json
{
  "results": [
    {
      "document_id": "rem_8f21a0",
      "text": "Krebs cycle",
      "is_document": true,
      "path": [
        "Biology",
        "Cell metabolism"
      ]
    },
    {
      "document_id": "rem_2c77e1",
      "text": "Citrate is the first product of the cycle",
      "is_document": false,
      "path": [
        "Biology",
        "Cell metabolism",
        "Krebs cycle"
      ]
    }
  ],
  "next_cursor": null
}
```

### get_document

A document or bullet with its child bullets, tags and flashcard markers. Access: read. REST: `GET /api/v1/remnote/documents/{document_id}`. MCP: `remnote_read → get_document`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `document_id` | string | yes | Document or note ID from search_notes or list_documents. |
| `depth` | integer | no | How many levels of children to return. Default: 3. |

Returns one document or bullet with its children in order, nested under their parent. Each bullet shows its tags and whether it is a flashcard and which type. Use depth to limit how deep the tree goes. Images are returned as references; their contents are not read.

Example response:

```json
{
  "document_id": "rem_8f21a0",
  "text": "Krebs cycle",
  "tags": [
    "Biology"
  ],
  "children": [
    {
      "document_id": "rem_2c77e1",
      "text": "Citrate >> first product of the cycle",
      "flashcard": "basic",
      "tags": [],
      "children": []
    },
    {
      "document_id": "rem_2c77e2",
      "text": "The cycle runs in the mitochondrial matrix",
      "flashcard": null,
      "tags": [],
      "children": []
    }
  ]
}
```

### get_daily_document

The daily document for a date, with its bullets. Today by default. Access: read. REST: `GET /api/v1/remnote/daily-document`. MCP: `remnote_read → get_daily_document`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `date` | date | no | ISO date, e.g. 2026-10-17. Default: today. |

Returns the daily document for one calendar date with its bullets in order. RemNote creates today's daily document when it is opened, so today always returns a document; a past date with no document returns an empty list.

Example response:

```json
{
  "document_id": "rem_d20261017",
  "date": "2026-10-17",
  "children": [
    {
      "document_id": "rem_d1",
      "text": "Plan the week",
      "tags": [],
      "children": []
    }
  ]
}
```

### list_tagged_notes

Bullets that carry a given tag, with their document. Access: read. REST: `GET /api/v1/remnote/tagged-notes`. MCP: `remnote_read → list_tagged_notes`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `tag` | string | yes | Tag name, without ##. |
| `limit` | integer | no | 1 to 50. Default: 20. |
| `cursor` | string | no | Next page cursor from the previous call. |

Lists the bullets tagged with one tag, with the document each one is in, most recently edited first. Use it to collect everything tagged #ToRead or #Meeting. The tag has to exist in your knowledge base.

Example response:

```json
{
  "tag": "ToRead",
  "notes": [
    {
      "document_id": "rem_91ab02",
      "text": "Article: spaced repetition and sleep",
      "document": "Reading list"
    }
  ],
  "next_cursor": null
}
```

### list_documents

Documents and folders in the Flashcard Home order, by priority, with due cards. Access: read. REST: `GET /api/v1/remnote/documents`. MCP: `remnote_read → list_documents`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `include_children` | boolean | no | Also list documents inside folders. Default: false. |

Lists the documents and folders shown in the Flashcard Home, sorted by priority, with the number of cards due in each. Upcoming exams from the Exam Scheduler come first. Folders list their sub-documents when include_children is true.

Example response:

```json
{
  "documents": [
    {
      "document_id": "rem_aa01",
      "name": "Anatomy",
      "priority": "high",
      "cards_due": 41,
      "exam": "Anatomy midterm"
    },
    {
      "document_id": "rem_aa02",
      "name": "Spanish",
      "priority": "medium",
      "cards_due": 18,
      "exam": null
    }
  ]
}
```

### get_flashcard_home

Cards due today, your daily goal and streak goal progress. Access: read. REST: `GET /api/v1/remnote/flashcard-home`. MCP: `remnote_read → get_flashcard_home`.

No parameters.

Returns what the top of the Flashcard Home shows: the number of due reviews, whether today's daily goal and streak goal are reached, and the current streak. It reads numbers only and never answers or schedules a card.

Example response:

```json
{
  "due_reviews": 86,
  "daily_goal": {
    "target": 100,
    "done": 0,
    "reached": false
  },
  "streak_goal": {
    "target": 20,
    "done": 0,
    "reached": false
  },
  "streak_days": 12
}
```

### list_cards

Flashcards from the Cards Table, filtered by document, text or enabled state. Access: read. REST: `GET /api/v1/remnote/cards`. MCP: `remnote_read → list_cards`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `document_id` | string | no | Only cards in this document or folder. |
| `contains` | string | no | Only cards that contain this text. |
| `enabled` | boolean | no | true or false filters on enabled state. |
| `limit` | integer | no | 1 to 100. Default: 50. |
| `cursor` | string | no | Next page cursor from the previous call. |

Lists flashcards the way the Cards Table does, with their front, back and whether they are enabled or due. Filter by document, by words in the card or by enabled state. Use it to find duplicates or cards with no answer before adding more.

Example response:

```json
{
  "cards": [
    {
      "card_id": "cd_5521",
      "document": "Krebs cycle",
      "type": "basic",
      "front": "Citrate",
      "back": "First product of the cycle",
      "enabled": true,
      "due": true
    }
  ],
  "next_cursor": null
}
```

### create_note

Add a bullet or a tree of bullets under a document or bullet. Access: write. REST: `POST /api/v1/remnote/parents/{parent_id}/notes`. MCP: `remnote_write → create_note`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `parent_id` | string | yes | Document or bullet to add under. |
| `markdown` | string | yes | Bullets with leading dashes; indent to nest. |
| `as_document` | boolean | no | Make the top bullet a document. Default: false. |

Adds bullets under a parent document or bullet. Pass markdown with leading dashes for bullets and equal indentation for nesting; RemNote reads both. Set as_document to true to make the top bullet its own document. It writes into your own knowledge base and reaches no one, so it does not ask first; shared knowledge bases are the exception, where others see the new bullets.

Example response:

```json
{
  "document_id": "rem_91ab02",
  "parent_id": "rem_aa10",
  "bullets_added": 3,
  "is_document": false
}
```

### create_flashcards

Add flashcards to a document as bullets with RemNote's card triggers. Access: write. REST: `POST /api/v1/remnote/documents/{document_id}/flashcards`. MCP: `remnote_write → create_flashcards`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `document_id` | string | yes | Document or note ID from search_notes or list_documents. |
| `cards` | array | yes | Cards to add: each has type (basic, reverse, two_way, cloze, multi_line) plus front and back, or text for cloze, or items for multi_line. |

Adds flashcards as new bullets at the end of a document, using the same trigger characters RemNote documents for text import. Types: basic (front >> back), reverse, two_way, cloze ({{hidden}}) and multi_line (front with items nested under it). New cards wait in their own queue before you start learning them. It writes into your own knowledge base and reaches no one, so it does not ask first.

Example response:

```json
{
  "document_id": "rem_8f21a0",
  "cards_added": 2,
  "by_type": {
    "basic": 1,
    "cloze": 1
  }
}
```

### add_to_daily_document

Append bullets to the daily document of a date, today by default. Access: write. REST: `POST /api/v1/remnote/daily-documents`. MCP: `remnote_write → add_to_daily_document`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `markdown` | string | yes | Bullets with leading dashes; indent to nest. |
| `date` | date | no | ISO date. Default: today. |

Appends bullets to the end of a daily document. Pass markdown with leading dashes for bullets and equal indentation for nesting. Today's document is created when it does not exist yet. It writes into your own knowledge base and reaches no one, so it does not ask first.

Example response:

```json
{
  "document_id": "rem_d20261017",
  "date": "2026-10-17",
  "bullets_added": 4
}
```

### tag_note

Add or remove a tag on a bullet. Access: write. REST: `POST /api/v1/remnote/notes/{note_id}/tag`. MCP: `remnote_write → tag_note`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `note_id` | string | yes | Bullet ID from search_notes or get_document. |
| `tag` | string | yes | Existing tag name, without ##. |
| `remove` | boolean | no | true removes the tag. Default: false. |

Adds a tag to a bullet, or removes it when remove is true. The tag has to exist in your knowledge base already; the call fails with the tag name instead of creating a new one. It changes only your own notes and is undone by calling it again with remove set the other way, so it does not ask first.

Example response:

```json
{
  "document_id": "rem_91ab02",
  "tag": "ToRead",
  "status": "tagged"
}
```

### update_note

Replace the text of a bullet or insert new children under it. Access: write, asks the user first. REST: `PATCH /api/v1/remnote/notes/{note_id}`. MCP: `remnote_write → update_note`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `note_id` | string | yes | Bullet ID from search_notes or get_document. |
| `text` | string | no | New text for the bullet. |
| `children` | string | no | Bullets to add under it, with leading dashes. |

Replaces the text of one bullet, or adds children under it when children is set. The old text is not kept by this call, and in a shared knowledge base others see the change. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "document_id": "rem_2c77e2",
  "status": "updated",
  "children_added": 0
}
```

## How do I connect RemNote to Claude Code, Codex or Cursor?

Connecting RemNote takes three steps: sign up, sign in to RemNote once in your Cloud Browser and enable it for agents, then add one MCP server or call the REST API with the same key.

### Connect RemNote to your agent.

1. **Create an account** Sign up and add RemNote in the console. Your API key is there too.

2. **Sign in to RemNote in your Cloud Browser** Open your Cloud Browser in the console: your own Chrome in the cloud. Sign in to RemNote there yourself, the way you always do, then press Enable for agents, read only or read and write. We never save your password, and your agent keeps working even when your computer is off.

3. **Add Cotlet to your agent** Paste the snippet for your client. The same server and key serve every app you connect, so you do this once.

   Claude Code:

```
claude mcp add --transport http cotlet \
  https://cotlet.dev/mcp/v1 \
  --header "Authorization: Bearer $COTLET_API_KEY"
```

   Cursor:

```
{
  "mcpServers": {
    "cotlet": {
      "url": "https://cotlet.dev/mcp/v1",
      "headers": {
        "Authorization": "Bearer ${COTLET_API_KEY}"
      }
    }
  }
}
```

   Codex:

```
# ~/.codex/config.toml
[mcp_servers.cotlet]
url = "https://cotlet.dev/mcp/v1"
bearer_token_env_var = "COTLET_API_KEY"
```

4. **Ask your agent** Ask in plain words. Your agent finds the RemNote tools on the server and calls them for you; anything that reaches other people waits for your OK unless you switch that off for a tool.

```
Take the notes I pasted from today's call and add them to today's RemNote daily document under a bullet "Call with Acme". Tag the bullet #Meeting and put each action item on its own sub-bullet.
```

### Call RemNote from your scripts.

1. **Export your API key** Your scripts use the same API key as your agent. Keep it in an environment variable, never in your code.

```
export COTLET_API_KEY="cotlet_..."
```

2. **Call a tool** Every tool is an endpoint under /api/v1/remnote with its own method and path, listed with the endpoints above. Path parameters go in the URL; the other parameters go in the query for GET and DELETE and in a JSON body otherwise.

```
curl -X POST https://cotlet.dev/api/v1/remnote/daily-documents \
  -H "Authorization: Bearer $COTLET_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"date":"2026-10-17","markdown":"- Call with Acme\n  - Agreed to pilot in November\n  - Action: send pricing sheet by Friday\n  - Action: book follow-up for 24 Oct"}'
```

3. **Read the result** You get plain JSON back, ready for your script. A failed call costs nothing.

```
{
  "document_id": "rem_d20261017",
  "date": "2026-10-17",
  "bullets_added": 4
}
```

## Why use Cotlet for RemNote?

**Built for agents**

- One MCP server for every app you connect.
- The same tools as a REST API for scripts and cron jobs.
- Works with Claude Code, Codex and Cursor.

**Your login stays yours**

- You sign in to RemNote yourself, in your own Cloud Browser. We never save your password; the profile is encrypted with AES-256-GCM, the cipher 1Password uses.
- A+ on Qualys SSL Labs, securityheaders.com and Mozilla Observatory.
- The model never sees a login.
- No stored passwords, no CAPTCHA solving, no MFA bypass.

**You stay in control**

- Scope each API key: its apps, its tools, read only or read and write.
- Anything that reaches other people waits for your OK, so a leaked key cannot post or message as you.
- Every background request listed in your Background activity. Disable for agents in one click.

**Kept working for you**

- We test every integration every 6 hours.
- When RemNote changes, the tool pauses until we fix it.
- Failed calls cost nothing.

## Is it safe to connect RemNote to Cotlet?

Yes. You sign in to RemNote yourself, in your own Cloud Browser, and we never save your password. Your agents only get RemNote once you enable it, and every background request is listed. The browser profile is stored encrypted with AES-256-GCM, the same cipher 1Password uses for its vaults and Apple for iCloud Keychain. Independent public scanners grade cotlet.dev A+ and find it clean; click a result to rerun it yourself.

- **A+ on Qualys SSL Labs**: Encryption in transit: TLS setup and certificates, on all four server addresses. [Live result](https://www.ssllabs.com/ssltest/analyze.html?d=cotlet.dev)
- **A+ on securityheaders.com**: Browser protections sent with every page, all six headers present. [Live result](https://securityheaders.com/?q=cotlet.dev&followRedirects=on)
- **A+ on Mozilla Observatory**: Mozilla's web security baseline: score 120 of 100, 12 of 12 tests passed. [Live result](https://developer.mozilla.org/en-US/observatory/analyze?host=cotlet.dev)
- **Clean on Sucuri SiteCheck**: No malware, spam or defacement, and not on any of 9 blocklists, Google Safe Browsing included. [Live result](https://sitecheck.sucuri.net/results/cotlet.dev)

[How Cotlet protects your access](https://cotlet.dev/security.md)

### Common concerns

**Who runs Cotlet?**

Cotlet is run by Take Group, a Polish software company working since 2019. Take Group runs about 3,200 websites on its own systems and has its own DevOps team for infrastructure security. We built and used integrations like this inside the company for years before opening them as Cotlet.

**Is this an official RemNote integration?**

No, Cotlet is independent of RemNote. RemNote has no public API. Cotlet works through your own RemNote account, the way you use RemNote in the browser, so you need no partner approval and no developer setup.

**What about client data and GDPR?**

Cotlet is run from the EU and follows the GDPR. Cloud Browsers run in Finland, a Tier 1 country in the ITU Global Cybersecurity Index 2024. Data passes through a call and is not kept after it.

**Can I start with read only?**

Yes. Enable the app for agents as read only, or make the API key read only, and anything that reaches other people waits for your OK unless you switch that off per tool.

**Is it reliable?**

Every Cotlet service is checked every 3 minutes from Europe, North America, Asia and Australia. The live results and any outage are public at status.cotlet.dev.

**How do I stop?**

Press Disable for agents next to RemNote in your console: your agents lose access at once and you stay signed in. Signing out of RemNote in the browser works too, and Reset browser deletes the whole profile.

## Is there a RemNote MCP server on GitHub?

Yes. Community RemNote MCP servers exist on GitHub, usually maintained by one person. Most pair a server with a plugin you install inside RemNote, and cloud clients need a tunnel to reach it. You install, update and fix them yourself. Cotlet hosts the same kind of server for you, and our team keeps it working.

|  | GitHub MCP server | Cotlet |
|---|---|---|
| Setup | Install the server, install a bridge plugin in RemNote, keep both versions matching, add it to each MCP client | Sign up, sign in to RemNote once, add one MCP server or API key |
| When RemNote changes | It breaks until you or the maintainer fix it | Our team tests it daily and fixes it for you; failed calls are free |
| Your RemNote session | RemNote has to be open on your computer with the plugin running | In your own Cloud Browser in the EU, profile encrypted, only for the apps you enable, disabled for agents in one click |
| When the session expires | Tools fail until you open RemNote and reconnect by hand | Your Cloud Browser keeps you signed in; if RemNote logs you out, your agent gets a link to sign in again |
| Upkeep | You update, monitor and debug it yourself | Nothing to host or update |
| Where it runs | Your computer, while it is on and RemNote is open; cloud clients need a tunnel | Hosted: Claude Code, Codex, Cursor, n8n and scripts, also on a schedule |
| Price | Free, paid for with your time | Free 7-day trial, then pay-as-you-go credit packs, no subscription |

### Which one fits you

**Pick Cotlet if**

- you are not a developer, or you do not want to maintain a server
- you need it to keep working when RemNote changes, without checking it yourself
- your agent or a script should run it on a schedule, also while your computer is off

**Pick an open-source server if**

- you are comfortable installing, updating and fixing it yourself
- you want your sign-in to stay on your own computer
- you only need it now and then, from one MCP client

## How much does the RemNote API cost?

Free 7-day trial with 2,000 credits, no card needed. After that, the RemNote API is pay as you go with no limit on apps: Credit packs from $29 for 5,000 credits, one-time, no subscription. A successful call uses 20 to 30 credits (25 for most tools, about $0.10 to $0.15), your Cloud Browser uses 50 credits a day while it has an app enabled for agents, however many apps that is, and an agent driving the browser itself uses 5 credits a minute. Credit packs stay valid for 12 months and stack, so unused credits carry over.

| Credits | Price, one time | Calls at 25 credits | Per 1,000 credits |
|---|---|---|---|
| 5,000 | $29 | 200 | $5.80 |
| 15,000 | $79 | 600 | $5.27 |
| 32,000 | $149 | 1,280 | $4.66 |
| 60,000 | $249 | 2,400 | $4.15 |

Only successful calls use credits; failed calls and timeouts cost nothing. At a balance of 0 calls pause, never a surprise charge. Authenticate with the `Authorization: Bearer` header. [See full pricing](https://cotlet.dev/pricing.md)

## How Cotlet holds your access

Cotlet hosts MCP servers and REST APIs for apps with no usable API. Your agent works in your own RemNote account.

- **Company details:** Cotlet is run by Take Group sp. z o.o., a company registered in Poland. Its full address and registration numbers are in the Terms of service. [Terms of service](https://cotlet.dev/terms)
- **Your sign-in:** You sign in to RemNote yourself, in your own Cloud Browser: a Chrome we run for you in the EU, one per app. We never save your password (password saving is off), the profile is stored encrypted with AES-256-GCM, and your agents get RemNote only after you enable it. When RemNote signs you out, your agent gives you a link to sign in again. [Security](https://cotlet.dev/security.md)
- **Revoking access:** Press Disable for agents next to RemNote, sign out of RemNote in your Cloud Browser, or reset the browser. Every background request is listed in your Background activity. Actions that reach other people wait for your OK unless you switch that off per tool.
- **What we never do:** Store passwords, solve CAPTCHAs or bypass MFA.
- **RemNote's terms:** You use your own RemNote account and stay responsible for following RemNote's terms. Cotlet is independent and not affiliated with RemNote. [Terms](https://cotlet.dev/terms)
- **Contact:** Questions about the company, security or an app: [contact@cotlet.dev](mailto:contact@cotlet.dev)

## Frequently asked questions

**How do I get access?**

Sign up free, open RemNote in the console and press Request access. Then you create your API key and connect RemNote there.

**Do I need to be technical?**

No. You sign in to RemNote once in your Cloud Browser, a normal Chrome you open from the console, and paste one command into your agent, or one URL into n8n. Your agent can walk you through it. There is no server to install, update or fix.

**Is it safe to connect RemNote to Cotlet?**

Yes. You sign in to RemNote yourself, in your own Cloud Browser in the EU, and we never save your password. Your agents only get RemNote once you enable it, every background request is listed, and the browser profile is stored encrypted with AES-256-GCM, the cipher 1Password uses for its vaults. The AI model never sees a login, posts and messages wait for your OK, and Disable for agents cuts access in one click. Independent scanners grade cotlet.dev A+ on Qualys SSL Labs, securityheaders.com and Mozilla Observatory; live results are on https://cotlet.dev/security.

**Is a hosted server safer than a local one? My RemNote sign-in would leave my computer.**

On Cotlet you sign in inside your own Cloud Browser, which only you open, and its profile is stored encrypted with AES-256-GCM in the EU. Agents get only the apps you enable, and every background request is listed. A local server keeps your RemNote cookie in a plain file on your computer, readable by any program you run, and stops when your computer is off.

**Why does Cotlet send requests instead of clicking in my browser?**

To be fast, Cotlet doesn't click through RemNote's pages. It sends the same requests your browser would, from your browser's IP with its cookies, without opening a window. RemNote sees the same browser and IP you signed in with, and every request is listed in your Background activity.

**What if someone gets my Cotlet API key?**

The key holds no RemNote login or cookies, it only asks Cotlet to run a tool. It can call only the apps and tools you gave it, and a read-only key changes nothing. Anything that reaches other people, like posts, comments or messages, waits for your OK in the dashboard by default, so a leaked key cannot post or message as you. When you switch approval off for a scheduled job, give that job its own key limited to that one tool. Every call is in your activity log, and deleting the key ends access at once.

**Why a signed-in browser and not OAuth, like other integration platforms?**

RemNote offers no OAuth or API for this, so there is no scoped token to hold. That is why Cotlet sets the limits itself: per key, per tool, with your approval before anything reaches other people. Cotlet is run by Take Group sp. z o.o., an EU company (VAT PL6342984273).

**Do I need a paid RemNote plan?**

No plan is needed for these tools. RemNote's Free plan has unlimited notes and flashcards, and create_flashcards writes plain card triggers, not AI Cards, which use AI credits (RemNote Pricing, checked 17 Oct 2026). Some card features have Free plan limits, such as 10 Math (LaTeX) Cloze flashcards.

**Does RemNote's own MCP server do the same?**

Partly. It searches, reads and, in Read and write mode, creates, edits and tags notes, but it runs only on your computer while the desktop app is open, and it cannot reach the flashcard queue (RemNote Help, checked 17 Oct 2026). Cotlet works from n8n, scripts and web AI apps and adds the flashcard queue tools.

**Can my agent post or send messages in RemNote without asking me?**

No. Every call to update_note waits for your OK by default. For scheduled automations you can switch confirmation off per tool in your dashboard, for example only for approvals. create_note, create_flashcards, add_to_daily_document, tag_note runs without asking, because it sends nothing to anyone and one call undoes it.

**Can I use the RemNote API in n8n?**

Yes. Add https://cotlet.dev/mcp/v1 with your API key in n8n's MCP Client node, or call its endpoints under https://cotlet.dev/api/v1/remnote from the HTTP Request node.

---

Give your AI agents your signed-in browser.

**Product:** [Integrations](https://cotlet.dev/integrations.md) · [Use cases](https://cotlet.dev/use-cases.md) · [How it works](https://cotlet.dev/how-it-works.md) · [Pricing](https://cotlet.dev/pricing.md) · [Security](https://cotlet.dev/security.md)

**Resources:** [Blog](https://cotlet.dev/blog.md) · [API docs](https://cotlet.dev/docs.md) · [Help center](https://cotlet.dev/help.md) · [Changelog](https://cotlet.dev/changelog.md) · [GitHub](https://github.com/cotletdev/cotlet)

**Solutions:** [For developers](https://cotlet.dev/for-developers.md) · [For automation agencies](https://cotlet.dev/for-agencies.md)

**Company:** [About](https://cotlet.dev/about.md) · [AI info: company facts](https://cotlet.dev/ai-info.md) · [Contact](https://cotlet.dev/contact.md)

**Legal:** [Terms of service](https://cotlet.dev/terms) · [Privacy policy](https://cotlet.dev/privacy) · [Refund policy](https://cotlet.dev/refunds) · [Acceptable use](https://cotlet.dev/acceptable-use) · [Cookie policy](https://cotlet.dev/cookies) · [DPA](https://cotlet.dev/dpa) · [Subprocessors](https://cotlet.dev/subprocessors)

**Elsewhere:** [Status page](https://status.cotlet.dev) · [Cotlet on GitHub](https://github.com/cotletdev) · [Cotlet on X](https://x.com/cotletdev) · [Cotlet on LinkedIn](https://www.linkedin.com/company/cotletdev) · [Cotlet on Product Hunt](https://www.producthunt.com/products/cotlet) · [Cotlet on Crunchbase](https://www.crunchbase.com/organization/cotlet) · [Cotlet on SaaSHub](https://www.saashub.com/cotlet)

Cotlet is an independent service. It is not affiliated with, endorsed by or sponsored by any of the products listed on this site. Product names are trademarks of their respective owners.

## For AI agents: sign your user up

Is your user asking you to sign them up for Cotlet? You can do it for them, no account or key needed.

1. Read the fields and their allowed values: GET https://cotlet.dev/api/v1/access-requests
2. Ask the user for each value: email, apps, what you will do with them. If they leave the password to you, generate a strong one and show it to them.
3. Show the user what you will send, then POST it as JSON to https://cotlet.dev/api/v1/access-requests.

One call creates the account and sends the access request; we email the user when access is granted.