reclickup-mcp
An MCP server for ClickUp that proxies the official ClickUp MCP tools and adds direct formatted-table writing into ClickUp Docs.
Use all official
clickup_*tools for ClickUp, such as reading/writing tasks, Docs, comments, and lists, plus search/filter and other proxied official capabilities.Write content into a ClickUp Doc page with
clickup_doc_writeusing Markdown or a Quill delta, with no manual copy/paste.Apply team table formatting automatically: set column widths, green header cells, bold headers/styles, and fit tables to the Doc’s 720 px column.
Replace the page body or append content with
mode: "replace"ormode: "append".Optionally set a title for an untitled page, or let it default to the first
#heading in the Markdown.Get read-back verification of table widths, colors, and alignment after the write.
Refresh the headless browser’s ClickUp session with
clickup_reloginwhen needed.
Provides all tools of the official ClickUp MCP server, plus tools for writing formatted Markdown tables into ClickUp Doc pages with controlled column widths, green header cells, bold text, and alignment, and for refreshing the ClickUp browser session.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@reclickup-mcpappend this markdown table to my ClickUp doc page"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
reclickup-mcp
Every tool of the official ClickUp MCP, plus formatted tables written straight into a ClickUp Doc.
Setup on Windows in Claude Desktop: install, sign in, add the clickup-user-story skill, write a ticket into a Doc (1:55).
An MCP server that gives you every tool of the official ClickUp MCP plus one thing it cannot do: write formatted tables into a ClickUp Doc — set column widths, green header cells, bold text — straight from Markdown, with nothing to copy or paste.
Proxies the official server (
mcp.clickup.com), so its tools stay current: read and write tasks, Docs, comments, lists.clickup_doc_writefills a Doc page from Markdown in a headless Microsoft Edge: tables fitted to the Doc's 720 px column, green header cells, bold scenario titles.Installs from this repo with one
uvxline. Nothing to clone.
Why
ClickUp's public Docs API (and the official MCP's create/update_document_page) only accepts Markdown
or plain text. Tables written that way always get equal-width columns and no cell colours.
The Doc editor does accept a paste whose text/html carries each table as
<span class="ql-table-embed" data-table-embed-value="BASE64(JSON table-embed)"></span>That is what ClickUp itself puts on the clipboard when you copy a task description. Column widths,
cell-bg-color, bold, links and headings all survive, and the result is saved server-side.
reclickup builds that HTML and pastes it inside its own headless Microsoft Edge: no window and
no clipboard.
Related MCP server: ClickUp MCP
Tools
Tool | What it does |
all | Proxied unchanged from |
| Writes into a Doc page ( |
| Refreshes the ClickUp session of reclickup's headless browser. |
Markdown it understands
Headings
#,##,###(the first#line names an untitled page and is not written into the body).Paragraphs,
**bold**,*italic*,`code`,~~strike~~,[links](url),> quotes.Lists:
- bullet,1. ordered,- [ ]/- [x]checklists, nested with two spaces.Pipe tables, with
<br>for line breaks and\|for a literal pipe in a cell.Backslash escapes (
\_,\#, …) as written by ClickUp's own markdown export, so a page read withclickup_get_document_pagescan be edited and written back.
Every table gets a bold header row with green background cells. A table whose first header cell is
User Story Name is a key/value table: its first column is styled instead. Lines starting with
Scenario <n> in a cell are bold. Columns are sized to the Doc's 720 px text column. Presets cover the
common user-story tables (md2delta.py / delta2doc.py); any other table is scaled proportionally.
Errors that mean "retry"
Every call answers within ~50 s (Claude Desktop and Cowork give up on a call to your computer after 60 s).
Error | Meaning |
| The official server is still connecting, or waits for the ClickUp sign-in in the browser. Nothing was sent. |
| The connection to ClickUp had stopped answering (network or VPN change); reclickup restarted it. |
| Another Doc write or sign-in is using reclickup's browser. |
| reclickup's browser needs a ClickUp session: call |
| The Doc page did not load in time; nothing was pasted. |
Read-only official tools are retried once on a network blip; writes never are.
How it works
Proxy:
reclickup_mcp/server.pyspeaks MCP over stdio. It startsnpx -y mcp-remote@0.15.1 https://mcp.clickup.com/mcp, forwardstools/list,tools/call,resources/*(the official tools' MCP Apps views, e.g. the task card ofclickup_get_task) andprompts/*, and adds its own tools. Each request runs in its own thread, so a slow Doc write does not block other calls. Until the official server connects, the tool list comes from the last one seen (or a snapshot shipped in the package). A call slower than 20 s triggers a ping; a dead connection is restarted.Browser:
reclickup_mcp/browser.pyruns a private headless Edge on port 9335 with its own profile (~/.reclickup/headless-profile). It starts on demand and stops after 10 minutes idle (RECLICKUP_IDLE_STOP). Claude Desktop may start several copies of reclickup; they share that Edge through a lock file (~/.reclickup/browser.lock), so one copy never closes it under another's write.Session: the ClickUp session (
cu_jwtcookie) is copied once into that profile:macOS: from a running debug Edge on
:9222if one is signed in, else decrypted from your real Edge profile. Keychain asks once for "Microsoft Edge Safe Storage": click Allow.Windows:
clickup_reloginopens an Edge window at the ClickUp login. Sign in once; the profile keeps the session.
Install
Let an AI agent do it
Paste one of these into Claude Code (or a Claude Desktop task with shell access) on the machine to set up.
Install the reclickup-mcp MCP server for Claude Desktop on this computer, following
https://github.com/haonguyenstech/reclickup-mcp (read its README first). Talk to me in my language.
1. Check the requirements: uv (uvx), Node.js (npx) and Microsoft Edge. Install what is missing
(uv: the official one-line installer; Node: winget on Windows, brew on macOS) and tell me what you installed.
2. Find Claude Desktop's config. macOS: ~/Library/Application Support/Claude/claude_desktop_config.json, or
Claude-3p/ next to it when Desktop runs through an organization gateway. Windows: %APPDATA%\Claude\,
%LOCALAPPDATA%\Claude-3p\, or %LOCALAPPDATA%\Packages\Claude_*\LocalCache\Roaming\Claude\ for the Store app.
If the file has "deploymentMode": "3p", the Claude-3p one is in use. Back the file up, then add ONLY this entry
under "mcpServers", keeping every other key; write UTF-8 without a BOM:
"reclickup-mcp": { "command": "uvx",
"args": ["--from", "git+https://github.com/haonguyenstech/reclickup-mcp", "reclickup-mcp"] }
(macOS: if Desktop cannot find uvx, use the full path from `which uvx`.)
3. Pre-fetch it: uvx --from git+https://github.com/haonguyenstech/reclickup-mcp python -c "import reclickup_mcp"
4. Ask me to quit Claude Desktop completely (tray / menu bar icon -> Quit) and reopen it. Do not kill it yourself.
Then Settings -> Developer must show reclickup-mcp "Running".
5. Tell me to start a Claude Desktop task, type "log in to ClickUp", and in the browser page that opens pick the
workspace and click "Connect Workspace".
6. Download https://github.com/haonguyenstech/reclickup-mcp/releases/latest/download/clickup-user-story.zip and
tell me where it is: Claude Desktop -> Customize -> Skills -> + -> Upload skill.
7. Report what you changed (config file path, backup path) and what I still have to do.Check whether reclickup-mcp (https://github.com/haonguyenstech/reclickup-mcp) on this computer is up to date,
and update it if not. Talk to me in my language.
1. Latest version: the newest commit on master
(https://api.github.com/repos/haonguyenstech/reclickup-mcp/commits/master) and the latest release.
2. Installed version: the "reclickup-mcp" entry in Claude Desktop's claude_desktop_config.json (see the README for
where it lives; check Claude-3p too). If it is missing, stop and offer to install it instead. If its git URL is
pinned to an old tag or commit, tell me before changing it.
3. Update the cached build:
uvx --refresh --from git+https://github.com/haonguyenstech/reclickup-mcp python -c "import reclickup_mcp"
4. Ask me to quit Claude Desktop completely (do not kill it yourself), then run
tools/enable_desktop_tools.py from the repo
(https://raw.githubusercontent.com/haonguyenstech/reclickup-mcp/master/tools/enable_desktop_tools.py):
first without arguments; if it lists disabled reclickup tools, run it again with --apply. Delete the script after.
5. Ask me to reopen Claude Desktop and check Settings -> Developer: reclickup-mcp "Running".
6. Skill: download the latest
https://github.com/haonguyenstech/reclickup-mcp/releases/latest/download/clickup-user-story.zip and tell me to
replace the clickup-user-story skill (Customize -> Skills: delete the old one, Upload skill). For Claude Code,
unzip it over ~/.claude/skills/clickup-user-story yourself.
7. Report: old -> new version, what changed (the commit messages since the old version), what I still have to do.By hand
Nothing to clone. uv fetches the server straight from this repo,
installs its dependencies in a cached environment, and downloads Python itself if needed.
Requirements: uv, Node.js (for npx), Microsoft Edge.
# macOS / Linux
curl -LsSf https://astral.sh/uv/install.sh | sh
# Windows (PowerShell)
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"Claude Desktop
Add this to claude_desktop_config.json (Settings → Developer → Edit Config), then restart Claude Desktop:
{
"mcpServers": {
"reclickup-mcp": {
"command": "uvx",
"args": ["--from", "git+https://github.com/haonguyenstech/reclickup-mcp", "reclickup-mcp"]
}
}
}If Claude Desktop cannot find uvx or npx, use the full path to uvx (which uvx, e.g.
/Users/you/.local/bin/uvx) and add "env": { "PATH": "/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin" }
so the path reaches node/npx.
Claude Code
claude mcp add reclickup-mcp -- uvx --from git+https://github.com/haonguyenstech/reclickup-mcp reclickup-mcpFirst run
Official ClickUp tools: after the restart, start a task and ask Claude something like "log in to ClickUp". That opens a browser tab for the official ClickUp MCP: pick your workspace and click Connect Workspace. The token is cached in
~/.mcp-auth. Until you approve, only reclickup's own tools are listed; the full list appears right after.clickup_doc_write: needs a ClickUp session in reclickup's browser. On macOS it is copied automatically. On Windows, callclickup_reloginonce and sign in in the window it opens.
Updating
uvx caches the build. To pick up a newer commit, run uvx --refresh --from git+https://github.com/haonguyenstech/reclickup-mcp reclickup-mcp
once, or pin a version in the config: git+https://github.com/haonguyenstech/reclickup-mcp@v0.1.0.
Skill: clickup-user-story
skills/clickup-user-story/SKILL.md is a Claude skill built on
this server. It turns a BA user-story spec into a clean draft ticket and publishes it in a fixed team
style: 840 px tables with set column widths, green header cells and bold scenario titles.
As a task: created through the official tools.
On a Doc page: written with
clickup_doc_write. Give it the Doc page link and the page is filled in directly.Edit a Doc page: reads the page, changes what you ask (e.g. a new scenario under Acceptance Criteria) and writes it back with the same formatting.
Fix: it also repairs existing tickets whose tables came out half width.
Download: clickup-user-story.zip
Claude Desktop / claude.ai: Settings → Capabilities → Skills → Upload skill, then pick the zip.
Claude Code:
curl -fsSL -o /tmp/clickup-user-story.zip \ https://github.com/haonguyenstech/reclickup-mcp/releases/latest/download/clickup-user-story.zip rm -rf ~/.claude/skills/clickup-user-story && unzip -q /tmp/clickup-user-story.zip -d ~/.claude/skillsThe skill is a folder:
SKILL.mdplusscripts/(the converters it runs) andreference/.
Then ask, for example: "make a ticket from this spec into https://app.clickup.com/…/v/dc/…/…". The skill reads the workspace from the link, or asks which list or Doc to use.
Environment variables
Variable | Default | |
|
| CDP port of the headless Edge |
|
| Seconds of inactivity before the headless Edge is closed |
| auto | Path to the Edge executable |
|
| Real Edge profile to copy the session from (macOS) |
|
| Seconds a call to an official tool may take before it answers |
|
| Windows: seconds |
|
| Seconds before a slow official call triggers a connection check |
|
| Seconds |
|
|
|
|
| Upstream MCP URL |
Upstream (mcp-remote) stderr is logged to ~/.reclickup/upstream.log (rotated at 2 MB).
Development
python -m pip install websocket-client
python -m unittest discover -s tests -vThe tests need no ClickUp account: tests/fake_upstream.py stands in for the official server (hung, dead, wedged,
slow, flaky, Vietnamese text). CI runs them on Linux, macOS and Windows. skills/clickup-user-story/scripts/ holds
copies of md2delta.py and delta2doc.py; a test fails if they drift from the package.
Troubleshooting
Claude says it has no tool to create, update or get a task. Claude Desktop may have switched off the official
tools that come with an MCP Apps view (clickup_create_task, clickup_get_task, clickup_update_task,
clickup_filter_tasks, clickup_search, the timers): main.log shows Filtering out disabled tool "clickup_create_task".
reclickup lists those tools without the view since 0a1f140, but a switch already stored stays off. Quit Claude Desktop, then:
curl -fsSL -o enable_desktop_tools.py https://raw.githubusercontent.com/haonguyenstech/reclickup-mcp/master/tools/enable_desktop_tools.py
python enable_desktop_tools.py # shows what is switched off
python enable_desktop_tools.py --apply # switches it back onCaveats
clickup_doc_writerelies on how ClickUp's web editor handles a paste, not on a public API. It can break if ClickUp changes the editor. The read-back check after each write reports that right away.Doc pages and tasks are different editors.
clickup_doc_writeonly targets Doc pages (/v/dc/…or/docs/…links).
License
MIT
Available Tools
2 toolsclickup_doc_writeA
Write a user story into a ClickUp DOC page with the team table style (column widths, green header cells, bold), directly - no copy/paste for the user. Uses reclickup's own headless Edge (no window); if it reports NOT_LOGGED_IN, call clickup_relogin. Give the Doc page link and EITHER the draft markdown (team ticket format) OR a Quill delta. mode 'replace' (default) overwrites the page body; 'append' adds at the end. Returns per-table widths/colour read back after a reload.
| Name | Required | Description | Default |
|---|---|---|---|
| mode | No | replace | |
| delta | No | Quill delta {ops:[...]} as built for a task (840px tables are refitted to the Doc's 720px). | |
| title | No | Page title, used only if the page is untitled. Defaults to the markdown's first '# ' line. | |
| markdown | No | Draft ticket markdown (the *_DRAFT.md content). A leading '# Title' line is skipped. | |
| page_url | Yes | https://app.clickup.com/<ws>/v/dc/<docId>/<pageId> |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden, and it does real work: it discloses the headless Edge runtime (no window), the NOT_LOGGED_IN failure mode with its remedy, and — critically — that 'replace' overwrites the page body while 'append' adds at the end, which is the destructive behavior an agent must know. It stops short of permissions requirements, reversibility of an overwrite, or other failure modes.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Purpose is front-loaded in the first clause, followed by input requirements, failure handling, and mode semantics in a compact block. Every sentence carries information, though the 'no copy/paste for the user' framing is a benefit statement rather than operational guidance and could be trimmed.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 5-parameter mutation tool with no annotations and no output schema, the description covers the essentials: inputs, the either/or between markdown and delta, overwrite semantics, auth failure handling, and even what the return value contains (per-table widths/colour read back after reload). Remaining gaps are secondary — error modes beyond NOT_LOGGED_IN and whether an overwrite can be undone.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 80% schema coverage the baseline is 3, and the description adds meaning on top: it clarifies that markdown is the team ticket draft format, that delta is a Quill delta with 840px tables refitted to the Doc's 720px, and that mode 'replace' overwrites the body by default. Only the title fallback behavior is left to the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource — writing a user story into a ClickUp DOC page — plus the styling it applies (team table style, column widths, green headers) and the constraint that it writes directly rather than requiring copy/paste. A sibling exists (clickup_relogin) and the description makes clear that one is only an auth recovery path, not an alternative writer.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives concrete input requirements (Doc page link plus EITHER markdown OR Quill delta) and names the recovery route: if NOT_LOGGED_IN is reported, call clickup_relogin. Mode semantics (replace default vs append) are also spelled out. No explicit "when not to use" guidance, but with only one sibling the routing risk is low.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
clickup_reloginA
Refresh the ClickUp session of reclickup's private headless browser (used by clickup_doc_write). macOS: copies the clickup.com cookies from the user's real Microsoft Edge (a Keychain prompt 'Microsoft Edge Safe Storage' may appear - the user must click Allow). Windows: opens an Edge window at the ClickUp login; the user signs in once (waits up to 5 minutes). Use on first use or when clickup_doc_write reports NOT_LOGGED_IN.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden and does well: it discloses the macOS Keychain prompt that requires the user to click Allow, the Windows Edge login flow, and a 5-minute wait budget. It omits what happens on timeout/failure and whether existing cookies are overwritten on macOS, which are the remaining gaps for an auth mutation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loads purpose, then platform-specific branches, then the trigger — a sensible order with no filler. It is a single dense run-on paragraph with nested parentheticals, which slightly hurts scanability.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema exists, so the description should ideally say what success/failure looks like; it does not describe the return value. Everything else an agent needs — prerequisites, user interaction, timeout, triggering condition — is present.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, so the baseline is 4; there is nothing for the description to compensate for. The description correctly adds no parameter detail, since none exist.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('Refresh the ClickUp session') and immediately situates it as the auth helper for reclickup's headless browser used by clickup_doc_write. An agent can tell this apart from the sibling without reading any schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives explicit triggers: 'Use on first use or when clickup_doc_write reports NOT_LOGGED_IN.' The condition is concrete and tied to a named sibling error. It does not state when not to call it (e.g., do not retry in a loop), so it stops short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
2 tool updates
v0.1.0- First observed
clickup_doc_write - First observed
clickup_relogin
TDQS
Scored across 2 tools
The two tools have clearly distinct purposes: one writes content to a ClickUp Doc, the other refreshes the browser session. There is no realistic ambiguity when choosing between them, and the dependency is explicitly documented.
Both names use snake_case with a consistent clickup_ prefix. However, clickup_doc_write follows a noun_verb pattern while clickup_relogin uses a bare verb, which is a minor inconsistency.
The server has only two tools, which feels thin even for a focused integration. The surface is narrowly scoped, but additional discovery or read operations would make the set more useful.
The server supports writing and appending to a known Doc page, but lacks tools to list docs, create a new Doc page, or read existing content. These are significant gaps for an agent that needs to discover or verify ClickUp Docs.
Maintenance
Related MCP Connectors
ClickUp MCP — wraps the ClickUp REST API v2 (BYO API key)
MCP-native open-source Notion alternative: read & write pages, databases and kanban boards.
Read and write Mission Control state via MCP — projects, tasks, subtasks, templates, status updates.
Marketo MCP server for AI. 130 tools to operate Marketo from Claude, Cursor, or ChatGPT.
Related MCP Servers
- MIT
- AlicenseNot gradedqualityCmaintenanceHigh-performance MCP server for integrating ClickUp with AI applications, featuring consolidated tools for task management, document operations, and bulk actions with intelligent caching and response optimization.20 npmMIT
- AlicenseBqualityBmaintenanceLightweight ClickUp MCP server for task management with 37 tools and token-optimized responses to reduce API verbosity.40182 npm4MIT
- AlicenseAqualityCmaintenanceA comprehensive MCP server for the ClickUp API exposing 166 tools to manage Spaces, Folders, Lists, Tasks, Docs, and more, enabling LLMs to read and drive a ClickUp Workspace.1001Apache 2.0