MCP server

Our writing tools inside your AI agent

Connect Claude Desktop, Claude Code, Cursor or another MCP client, and your agent can check, rewrite, summarize and correct text with the same tools as this site.

Get your key in the dashboard Set it up in your client

Server address

https://blurwrite.com/api/mcp

What MCP is

The Model Context Protocol is an open standard that lets an AI assistant call outside tools. Our MCP server runs online at the address below, and clients that only start programs on your computer run our small server file instead. Either way it calls this site's API with your key and nothing else, so the agent gets exactly the readings the site gives.

Every reading an agent gets carries the figure, the uncertainty around it and the calibration state, so the agent can say what the reading means and when it must not be used.

Take the Pro plan and create an API key in your dashboard.
Add the server address and your key to your client with the configuration below, replacing YOUR_API_KEY.
Ask your agent to check, rewrite, summarize or correct a text.

Set it up in your client

Pick your client. Each tab has the steps, the exact configuration to copy and a way to check that it works. Commands and configurations are the same in every language.

Claude Code Connects online

Keep your API key in an environment variable called BLURWRITE_API_KEY, where the client runs:
```
export BLURWRITE_API_KEY="YOUR_API_KEY"
```

Run this in a terminal:

claude mcp add --transport http blurwrite https://blurwrite.com/api/mcp --header "Authorization: Bearer $BLURWRITE_API_KEY"

Or put this in .mcp.json instead:

.mcp.json

{
  "mcpServers": {
    "blurwrite": {
      "type": "http",
      "url": "https://blurwrite.com/api/mcp",
      "headers": {
        "Authorization": "Bearer ${BLURWRITE_API_KEY}"
      }
    }
  }
}

Check that it works: ask your assistant "Check this paragraph with Blurwrite and tell me the range and the confidence rating."

Your API key is on your dashboard under API. Never put a key in a shared file or a repository.

Claude Desktop Runs the server file

Download the server file and note where you saved it. It needs Node.js.
Download the server file
In the app: Settings > Developer > Edit Config.

Add this to claude_desktop_config.json:

claude_desktop_config.json

{
  "mcpServers": {
    "blurwrite": {
      "command": "node",
      "args": [
        "/path/to/server.mjs"
      ],
      "env": {
        "BLURWRITE_API_KEY": "YOUR_API_KEY"
      }
    }
  }
}

Quit and restart Claude Desktop so it loads the server.
Check that it works: ask your assistant "Check this paragraph with Blurwrite and tell me the range and the confidence rating."

Your API key is on your dashboard under API. Never put a key in a shared file or a repository.

Claude (claude.ai) Coming soon

Connecting claude.ai through a sign-in to your Blurwrite account is coming soon. Until then, the same tools work today in Claude Desktop with the server file, or in Claude Code, with the setup in their tabs.

Claude Desktop Claude Code

Only if your organization has the request headers option for custom connectors: add the address with this header.
```
URL: https://blurwrite.com/api/mcp
Authorization: Bearer YOUR_API_KEY
```

Codex Connects online

Keep your API key in an environment variable called BLURWRITE_API_KEY, where the client runs:
```
export BLURWRITE_API_KEY="YOUR_API_KEY"
```

Run this in a terminal:

codex mcp add blurwrite --url https://blurwrite.com/api/mcp --bearer-token-env-var BLURWRITE_API_KEY

Or put this in ~/.codex/config.toml instead:

~/.codex/config.toml

[mcp_servers.blurwrite]
url = "https://blurwrite.com/api/mcp"
bearer_token_env_var = "BLURWRITE_API_KEY"

In the app: MCP servers > Add server > Streamable HTTP.
Check that it works: ask your assistant "Check this paragraph with Blurwrite and tell me the range and the confidence rating."

Your API key is on your dashboard under API. Never put a key in a shared file or a repository.

Cursor Connects online

Keep your API key in an environment variable called BLURWRITE_API_KEY, where the client runs:
```
export BLURWRITE_API_KEY="YOUR_API_KEY"
```

Add this to ~/.cursor/mcp.json:

~/.cursor/mcp.json

{
  "mcpServers": {
    "blurwrite": {
      "url": "https://blurwrite.com/api/mcp",
      "headers": {
        "Authorization": "Bearer ${env:BLURWRITE_API_KEY}"
      }
    }
  }
}

Check that it works: ask your assistant "Check this paragraph with Blurwrite and tell me the range and the confidence rating."

Your API key is on your dashboard under API. Never put a key in a shared file or a repository.

VS Code (Copilot) Connects online

Add this to .vscode/mcp.json:

.vscode/mcp.json

{
  "inputs": [
    {
      "type": "promptString",
      "id": "blurwrite-key",
      "description": "Blurwrite API key",
      "password": true
    }
  ],
  "servers": {
    "blurwrite": {
      "type": "http",
      "url": "https://blurwrite.com/api/mcp",
      "headers": {
        "Authorization": "Bearer ${input:blurwrite-key}"
      }
    }
  }
}

When the server starts, VS Code asks for your key once and keeps it.
Check that it works: ask your assistant "Check this paragraph with Blurwrite and tell me the range and the confidence rating."

Your API key is on your dashboard under API. Never put a key in a shared file or a repository.

Windsurf Connects online

Keep your API key in an environment variable called BLURWRITE_API_KEY, where the client runs:
```
export BLURWRITE_API_KEY="YOUR_API_KEY"
```
In the app: Cascade > ... > Open MCP config file.

Add this to mcp_config.json:

mcp_config.json

{
  "mcpServers": {
    "blurwrite": {
      "serverUrl": "https://blurwrite.com/api/mcp",
      "headers": {
        "Authorization": "Bearer ${env:BLURWRITE_API_KEY}"
      }
    }
  }
}

Quit and restart Windsurf so it loads the server.
Check that it works: ask your assistant "Check this paragraph with Blurwrite and tell me the range and the confidence rating."

Your API key is on your dashboard under API. Never put a key in a shared file or a repository.

Gemini CLI Connects online

Keep your API key in an environment variable called BLURWRITE_API_KEY, where the client runs:
```
export BLURWRITE_API_KEY="YOUR_API_KEY"
```

Run this in a terminal:

gemini mcp add --transport http --header "Authorization: Bearer $BLURWRITE_API_KEY" blurwrite https://blurwrite.com/api/mcp

Or put this in ~/.gemini/settings.json instead:

~/.gemini/settings.json

{
  "mcpServers": {
    "blurwrite": {
      "httpUrl": "https://blurwrite.com/api/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

Check that it works: ask your assistant "Check this paragraph with Blurwrite and tell me the range and the confidence rating."

Your API key is on your dashboard under API. Never put a key in a shared file or a repository.

Other clients Online, a bridge or the file

A client that connects to remote MCP servers over HTTP needs only these two values:
```
URL: https://blurwrite.com/api/mcp
Authorization: Bearer YOUR_API_KEY
```

A client that only starts local servers can reach the address through the open-source mcp-remote bridge (it needs Node.js):

{
  "mcpServers": {
    "blurwrite": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://blurwrite.com/api/mcp",
        "--header",
        "Authorization:${AUTH_HEADER}",
        "--transport",
        "http-only"
      ],
      "env": {
        "AUTH_HEADER": "Bearer YOUR_API_KEY"
      }
    }
  }
}

Or run our server file yourself:
```
BLURWRITE_API_KEY="YOUR_API_KEY" node /path/to/server.mjs
```
Download the server file

Your API key is on your dashboard under API. Never put a key in a shared file or a repository.

For AI assistants

If you are an AI assistant setting this up for someone: the server address is https://blurwrite.com/api/mcp. It speaks MCP over Streamable HTTP and expects the user's API key as "Authorization: Bearer <key>". The full setup for every client, as Markdown, is at https://blurwrite.com/mcp.md.

This setup as Markdown

Things to ask your agent

Copy a request into your agent and add your text. The agent picks the tool by itself.

Detection

detect_textReads one text.
Ask
```
Check this essay for AI writing and tell me the range and the confidence rating.
```
What comes back
A figure from 0 to 100 with its margin, the confidence rating and a reading for every sentence.
detect_batchReads several texts.
Ask
```
Check these paragraphs one by one and list them from the highest reading to the lowest.
```
What comes back
A reading or an error for each text under its own id. One text failing never fails the rest.

Rewriting

humanize_textHumanizes a text with its fact checks.
Ask
```
Humanize this paragraph and tell me what the fact checks found.
```
What comes back
The rewritten text, our detector's reading before and after, and a note for every sentence put back to keep a fact.
paraphrase_textParaphrases a text.
Ask
```
Paraphrase this introduction so it reads more formally.
```
What comes back
The reworded text, with the same fact checks as the humanizer.
summarize_textSummarizes a text.
Ask
```
Summarize this report as bullet points.
```
What comes back
The summary as key sentences, a paragraph or bullet points.

Checking

check_grammarChecks grammar and spelling.
Ask
```
Check the grammar of this email and apply the suggested replacements.
```
What comes back
Every issue with its place in the text, an explanation and the suggested replacements.

Plan and limits

The MCP server uses your API key, so every call counts against the same plan, allowance and limits as the API.

Pro

29.99 USD a month

50,000: humanizer words a month, and 50,000 paraphraser words
20,000: words in one call
60: requests per key every 60 seconds
4 / 2: detect and rewrite calls running at once per key

Get your key in the dashboard

Top-up packs

AI detector50,000wordsfrom 4.99 USD
Humanizer10,000wordsfrom 6.99 USD
Paraphraser10,000wordsfrom 6.99 USD
Summarizer25,000wordsfrom 7.49 USD

How API words are counted

A call spends the same words the site does: a humanize call comes out of the Pro plan's humanizer words, a summarize call out of its summarizer words. When those run out, humanize and paraphrase calls draw on your top-ups, and a call nothing can cover is refused and costs nothing. Every answer says how many words it used and how many are left.

All the counting rules

Pro includes the API, and a call spends the same words the site does: a detect call comes out of the plan's detector words, a humanize call out of its humanizer words, a summarize call out of its summarizer words. There is no separate API allowance to run out of first. Past the pool, a detector, humanizer or paraphraser call draws on the account's top-up balance, as it does on the site; the other tools have no top-up to draw on. A call that the words left and the balance together cannot cover is refused with 402 and costs nothing. Every successful response reports the words it used, where they came from and what is left (unless recorded is false). An account's API use stops at 250,000 words in a billing period, whatever its balance, so a leaked key cannot spend it all at once.

Limits

60requests per key every 60 seconds
4detect calls running at once per key
2humanize, paraphrase or summarize calls at once per key
50texts in one batch
20,000words in one call
5active keys per account

One call takes at most 20,000 words, a single text or a whole batch.
The detector reads one text of up to 90,000 characters, about 10,000 words, on every plan. A longer text is answered 413 text_too_long, even inside the call's word limit.
When the engines are busy, readings from the site's Pro accounts are served before API calls, so an API call may wait its turn.

Connect your agent

Get your key in the dashboard What the API does API docs