reclickup-mcp
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
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.
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
# Heading, paragraphs, **bold**, [links](url) and pipe tables. 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. 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.
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/listandtools/call, and adds its own tools. Each request runs in its own thread, so a slow Doc write does not block other calls.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).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
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: the first start opens a browser tab for the official ClickUp MCP. Sign in and approve. 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.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:
mkdir -p ~/.claude/skills/clickup-user-story && curl -fsSL \ https://raw.githubusercontent.com/haonguyenstech/reclickup-mcp/master/skills/clickup-user-story/SKILL.md \ -o ~/.claude/skills/clickup-user-story/SKILL.md
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) |
|
|
|
|
| Upstream MCP URL |
Upstream (mcp-remote) stderr is logged to ~/.reclickup/upstream.log.
Caveats
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.4082 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