The Official ToHuman MCP Server: Humanize AI Text inside Claude, Cursor & Windsurf

What the ToHuman MCP server actually is

The ToHuman MCP server — package name @tohuman/mcp-server — is a small Node process that implements the Model Context Protocol and exposes one thing: a humanize tool that any MCP-compatible AI client can call. When your assistant decides to use the tool, the server POSTs the text to the ToHuman synchronous humanize API endpoint using your API key, waits for the humanized output, and returns it as a tool response. That's the whole surface area. No storage, no extra prompting, no proprietary transformation — the humanization model itself lives behind our API and the MCP server is a bridge to it.

It's official and first-party: published and maintained by the ToHuman team, backed by the same humanization model that runs the web UI and the API. Third-party AI humanizer MCP wrappers exist — they generally shell out to whichever vendor is cheapest that week. This one is the one the vendor built.

Why humanize inside your agent

The copy-paste flow is fine for one-offs — write in ChatGPT, paste into a humanizer web tool, paste the result back into a doc. It breaks down the moment you're actually working in an agent. A developer using Claude Code doesn't want to alt-tab to a browser for every paragraph. A writer using Cursor to draft a long post doesn't want to interrupt the loop. An email-drafting workflow inside Claude Desktop doesn't get to leave Claude Desktop.

The interesting datapoint is our own: 88% of all humanizations on ToHuman run through the API, not the copy-paste web UI. That skew has held steady for months. It's the strongest signal we have that our users are workflow-shaped — they want humanization as a step inside something bigger, not as a destination. The MCP server is the same API in the shape an agent natively speaks.

Two concrete benefits fall out of that:

• No context switch. "Humanize this" becomes a single turn in the same conversation. The assistant hands the humanized text back inline and can immediately act on it — paste it into a file, put it in an email draft, iterate on tone.
• Chainability. Because the humanized output is a tool response, the agent can pipe it into the next step. "Write a 500-word intro about remote work, humanize it, then save it to drafts/remote-work.md" is one turn. No human in the loop between generation and humanization.

Supported MCP clients

Any client that implements the Model Context Protocol spec. In practice, as of July 2026, that means:

The install block is essentially identical across clients — npx -y @tohuman/mcp-server, an env var with your API key, restart the client. Full walkthrough with per-client paths and screenshots on the MCP setup tutorial.

What it does under the hood

Deliberately unsurprising. The server exposes one tool:

humanize(text: string, intensity?: "minimal" | "subtle" | "medium" | "heavy") -> string

When called, it POSTs to the ToHuman synchronous humanize endpoint at https://tohuman.io/api/v1/humanize, using the TOHUMAN_API_KEY environment variable for auth, and returns the humanized text as the tool response. That's it. The server is stateless — it doesn't cache, doesn't log the text, doesn't wrap the response. Whatever the ToHuman humanizer API would return for that request is what the tool returns.

The intensity parameter maps to the same four levels the API exposes: minimal, subtle, medium (default), and heavy. Higher levels apply a deeper multi-pass rewrite. There's a 2,000-word input limit per call — a synchronous-endpoint constraint, not an MCP one. For longer documents you either chunk at paragraph boundaries or use the async batch endpoint directly (documented in the ToHuman API docs).

Install (the short version)

Node.js 18+ and a free ToHuman API key from your tohuman.io account. The two-line summary:

npm install -g @tohuman/mcp-server        # or use npx, no install
export TOHUMAN_API_KEY=your-key-here

Then register the server in your MCP client. Claude Desktop example:

{
  "mcpServers": {
    "tohuman": {
      "command": "npx",
      "args": ["-y", "@tohuman/mcp-server"],
      "env": { "TOHUMAN_API_KEY": "your-key-here" }
    }
  }
}

Restart the client. The humanize tool shows up in the tool list. Ask "humanize this paragraph" in a message and the assistant calls it. That's the whole flow.

The full setup tutorial has the per-client config paths (Claude Desktop, Claude Code, Cursor, Windsurf, Codex), the screenshot of the hammer icon, and the debugging steps if the tool doesn't show up after a restart. This page won't reproduce it — that's what the tutorial is for.

Who this is for

Three kinds of user have shown up so far:

• Developers using AI coding assistants. Anyone driving Claude Code, Cursor, Windsurf, or Codex for day-to-day work. Humanizing docstrings, README rewrites, generated changelogs, and marketing copy embedded in a repo — all without leaving the editor.
• Agent / workflow builders. People composing multi-step LLM chains inside Claude Desktop, Continue, or the OpenAI Agents SDK. "Draft, humanize, save" as one turn instead of three.
• Writers who live in Claude Desktop. Long-form drafting inside the desktop app, with humanization as a mid-flow action instead of a copy-paste-to-browser round-trip.

If you're a one-off user who occasionally needs to humanize a paragraph, the web UI is still the right shape for you — the MCP server is the pipeline surface, and pipelines are what the numbers say most of our users actually want.

Frequently Asked Questions

What is the ToHuman MCP server?

The ToHuman MCP server is the official first-party Model Context Protocol server for the ToHuman humanizer API. It ships as the npm package @tohuman/mcp-server and exposes a single tool — humanize(text, intensity) — that any MCP-compatible AI client (Claude Desktop, Claude Code, Cursor, Windsurf, Codex, the OpenAI Agents SDK) can call. Instead of copy-pasting AI output into a web humanizer, your assistant humanizes text in the same conversation, in-workflow.

Which AI clients does the ToHuman MCP server work with?

Any client that implements the Model Context Protocol. That includes Claude Desktop, Claude Code, Cursor, Windsurf, Codex CLI, Cline, Continue, and the OpenAI Agents SDK. The install and config are identical across clients — you drop the same npx block into that client's mcpServers config, restart it, and the humanize tool appears in the tool list.

Is this an official ToHuman MCP server or a third-party wrapper?

Official and first-party. The package @tohuman/mcp-server is published and maintained by ToHuman. Several third-party AI humanizer MCP wrappers exist on the market — they call various humanization APIs from outside the vendor. This one is built and updated by the same team that owns the underlying humanization model.

What does the MCP server do under the hood?

It's a thin, stateless MCP bridge. When your AI client calls the humanize tool, the server POSTs the text to the ToHuman synchronous humanize API endpoint using your API key, waits for the humanized output, and returns it as a tool response. It doesn't store the text, doesn't add extra prompting, and doesn't modify the humanization behavior. If the ToHuman API can do it, the MCP server can expose it.

Do I need a paid ToHuman plan to use the MCP server?

No. The MCP server uses your ToHuman API key, which is available on the free tier. Free-tier limits apply as they would to any other API call. If you're a heavier user (long documents, batch runs) you'll want a paid plan for the higher rate limits, but the MCP server itself is free and MIT-licensed.

Why humanize text inside the agent instead of copy-pasting into a web tool?

Two reasons. First, workflow friction — a copy-paste round-trip to a browser tab breaks flow, and for developers driving Claude Code or Cursor it doesn't fit at all. Second, chainability — with MCP the humanized text is a tool response inside the conversation, so the assistant can immediately do the next step (paste it into a file, send it in an email draft, iterate on tone). Our own product data reflects this pattern already: 88% of ToHuman humanizations run through the API, not the web UI. The MCP server is that same API, surfaced in the tool-calling shape that agents natively speak.

How do I install the ToHuman MCP server?

Install requires Node.js 18+. You can either install globally with npm install -g @tohuman/mcp-server or use npx on demand (no install). Then add the server to your MCP client's config (claude_desktop_config.json for Claude Desktop, .cursor/mcp.json for Cursor, and so on) with your TOHUMAN_API_KEY as an environment variable. The full step-by-step walkthrough, including per-client config paths, is on the tutorial page.

Related Reading

• The ToHuman AI Humanizer API — the underlying API the MCP server calls. Sync and async endpoints, rate limits, intensity levels.
• MCP Server Setup Tutorial (step-by-step) — full per-client walkthrough with config paths for Claude Desktop, Claude Code, Cursor, Windsurf, and Codex.
• ToHuman API Docs — endpoint reference, auth, error codes, and the async batch pattern for documents over 2,000 words.
• How to Humanize AI Text with an API — n8n, Zapier & MCP integration guide — the broader integration landscape once you've picked a humanization surface.