Skip to main content
Glama

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_write fills 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 uvx line. 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 clickup_* tools of the official server

Proxied unchanged from https://mcp.clickup.com/mcp through mcp-remote, so they stay current.

clickup_doc_write

Writes into a Doc page (page_url) from markdown (or a Quill delta). mode is replace (default) or append. If the page is untitled, it is named after the first # line. Reloads the page and returns the widths, green cells and alignment of every table. Takes about 25 s.

clickup_relogin

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 with clickup_get_document_pages can 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

NOT_READY

The official server is still connecting, or waits for the ClickUp sign-in in the browser. Nothing was sent.

STALE_CONNECTION

The connection to ClickUp had stopped answering (network or VPN change); reclickup restarted it.

BUSY

Another Doc write or sign-in is using reclickup's browser.

NOT_LOGGED_IN / LOGIN_PENDING

reclickup's browser needs a ClickUp session: call clickup_relogin (again).

TIMEOUT

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.py speaks MCP over stdio. It starts npx -y mcp-remote@0.15.1 https://mcp.clickup.com/mcp, forwards tools/list, tools/call, resources/* (the official tools' MCP Apps views, e.g. the task card of clickup_get_task) and prompts/*, 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.py runs 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_jwt cookie) is copied once into that profile:

    • macOS: from a running debug Edge on :9222 if one is signed in, else decrypted from your real Edge profile. Keychain asks once for "Microsoft Edge Safe Storage": click Allow.

    • Windows: clickup_relogin opens 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-mcp

First 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, call clickup_relogin once 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/skills

    The skill is a folder: SKILL.md plus scripts/ (the converters it runs) and reference/.

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

RECLICKUP_PORT

9335

CDP port of the headless Edge

RECLICKUP_IDLE_STOP

600

Seconds of inactivity before the headless Edge is closed

RECLICKUP_BROWSER

auto

Path to the Edge executable

RECLICKUP_EDGE_PROFILE

~/Library/Application Support/Microsoft Edge/Default

Real Edge profile to copy the session from (macOS)

RECLICKUP_CALL_BUDGET

50

Seconds a call to an official tool may take before it answers NOT_READY (clients drop calls after ~60 s)

RECLICKUP_LOGIN_WAIT

40

Windows: seconds clickup_relogin waits for the sign-in before answering LOGIN_PENDING

RECLICKUP_SLOW_CALL

20

Seconds before a slow official call triggers a connection check

RECLICKUP_SAVE_WAIT

4

Seconds clickup_doc_write lets ClickUp save before reloading to verify

RECLICKUP_NPX

npx on PATH

npx to run mcp-remote

RECLICKUP_UPSTREAM

https://mcp.clickup.com/mcp

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 -v

The 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 on

Caveats

  • clickup_doc_write relies 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_write only targets Doc pages (/v/dc/… or /docs/… links).

License

MIT

Available Tools

2 tools
clickup_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.

NameRequiredDescriptionDefault
modeNoreplace
deltaNoQuill delta {ops:[...]} as built for a task (840px tables are refitted to the Doc's 720px).
titleNoPage title, used only if the page is untitled. Defaults to the markdown's first '# ' line.
markdownNoDraft ticket markdown (the *_DRAFT.md content). A leading '# Title' line is skipped.
page_urlYeshttps://app.clickup.com/<ws>/v/dc/<docId>/<pageId>

TDQS

A4.3/5.0
Behavior4/5

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.

Conciseness4/5

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.

Completeness4/5

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.

Parameters4/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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.

NameRequiredDescriptionDefault

No parameters

TDQS

A4.3/5.0
Behavior4/5

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.

Conciseness4/5

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.

Completeness4/5

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.

Parameters4/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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.

  1. 2 tool updatesv0.1.0
    • First observedclickup_doc_write
    • First observedclickup_relogin

TDQS

A4.1/5.0

Scored across 2 tools

Disambiguation5/5

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.

Naming Consistency4/5

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.

Tool Count3/5

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.

Completeness2/5

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

ActivityMaintained
ResponsivenessSyncing

Related MCP Connectors

Related MCP Servers