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

What the ToHuman MCP server actually is

The ToHuman MCP server is a hosted remote endpoint at https://tohuman.io/mcp that implements the Model Context Protocol (streamable HTTP transport) 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 passes the text to the ToHuman synchronous humanize API 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: hosted 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 ChatGPT 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 config is essentially identical across clients — the endpoint URL https://tohuman.io/mcp, an Authorization header with your API key, restart the client. Want a local server you can extend instead? The build-your-own MCP tutorial walks through it in ~50 lines of Python.

Running it inside ChatGPT rather than Claude is a different setup — the MCP connector page has the developer-mode caveats and the API-key requirement.

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 passes the text to the ToHuman synchronous humanize API, using the API key from your client's Authorization header 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).

Setup (the short version)

All you need is a free ToHuman API key from your tohuman.io account — the server is hosted, so there's nothing to install. In Claude Code it's one command:

claude mcp add --transport http tohuman https://tohuman.io/mcp \
  --header "Authorization: Bearer your-key-here"

Clients with native remote MCP support take a URL in their config. Cursor example (.cursor/mcp.json):

{
  "mcpServers": {
    "tohuman": {
      "url": "https://tohuman.io/mcp",
      "headers": { "Authorization": "Bearer your-key-here" }
    }
  }
}

Clients that only launch local stdio servers (Claude Desktop among them) connect through the open-source mcp-remote bridge — same endpoint, wrapped in a local process:

{
  "mcpServers": {
    "tohuman": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://tohuman.io/mcp",
               "--transport", "http-only",
               "--header", "Authorization:${TOHUMAN_AUTH}"],
      "env": { "TOHUMAN_AUTH": "Bearer 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.

Prefer a local server you can read and extend? The build-your-own tutorial walks through a ~50-line Python MCP server on the same API, including Claude Desktop and Cursor config and the debugging steps if the tool doesn't show up after a restart.

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 runs as a hosted remote endpoint at https://tohuman.io/mcp — nothing to install — 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 config is nearly identical across clients — you point the client at https://tohuman.io/mcp with your API key in an Authorization header, restart it, and the humanize tool appears in the tool list. Clients that only launch local stdio servers can connect through the open-source mcp-remote bridge.

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

Official and first-party. The endpoint at https://tohuman.io/mcp is hosted 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 to use.

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?

There's nothing to install — it's a hosted remote server. Point your MCP client at https://tohuman.io/mcp with your ToHuman API key in an Authorization: Bearer header. In Claude Code that's one command: claude mcp add --transport http tohuman https://tohuman.io/mcp --header "Authorization: Bearer YOUR_KEY". Clients that only support local stdio servers can bridge with the open-source mcp-remote adapter, or you can build your own local server in about 50 lines of Python — the full walkthrough 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.
• Build Your Own MCP Server (step-by-step) — a ~50-line Python MCP server on the same API, with Claude Desktop and Cursor config walkthroughs.
• 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.
• ChatGPT humanizer — the honest breakdown — what the same rewrite does to GPT output, the four intensity levels, and the production data behind them.