# 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.

## 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.

## 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.

## Server address

```text
URL: https://blurwrite.com/api/mcp
Authorization: Bearer YOUR_API_KEY
```

## Things to ask your agent

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

### Detection

- `detect_text`: Reads 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_batch`: Reads 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_text`: Humanizes 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_text`: Paraphrases 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_text`: Summarizes a text.
  - Ask: "Summarize this report as bullet points."
  - What comes back: The summary as key sentences, a paragraph or bullet points.

### Checking

- `check_grammar`: Checks 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.

## 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.

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

### Claude Code (Connects online)

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

2. Run this in a terminal:
   
   ```sh
   claude mcp add --transport http blurwrite https://blurwrite.com/api/mcp --header "Authorization: Bearer $BLURWRITE_API_KEY"
   ```

3. Or put this in .mcp.json instead:
   
   ```json
   {
     "mcpServers": {
       "blurwrite": {
         "type": "http",
         "url": "https://blurwrite.com/api/mcp",
         "headers": {
           "Authorization": "Bearer ${BLURWRITE_API_KEY}"
         }
       }
     }
   }
   ```

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

### Claude Desktop (Runs the server file)

1. Download the server file and note where you saved it. It needs Node.js. https://blurwrite.com/mcp/server.mjs

2. In the app: Settings > Developer > Edit Config.

3. Add this to claude_desktop_config.json:
   
   ```json
   {
     "mcpServers": {
       "blurwrite": {
         "command": "node",
         "args": [
           "/path/to/server.mjs"
         ],
         "env": {
           "BLURWRITE_API_KEY": "YOUR_API_KEY"
         }
       }
     }
   }
   ```

4. Quit and restart Claude Desktop so it loads the server.

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

### 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.

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

### ChatGPT (Coming soon)

Connecting ChatGPT through a sign-in to your Blurwrite account is coming soon. Until then, the same tools work today in Codex and Claude Code, with the setup in their tabs.

### Codex (Connects online)

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

2. Run this in a terminal:
   
   ```sh
   codex mcp add blurwrite --url https://blurwrite.com/api/mcp --bearer-token-env-var BLURWRITE_API_KEY
   ```

3. Or put this in ~/.codex/config.toml instead:
   
   ```toml
   [mcp_servers.blurwrite]
   url = "https://blurwrite.com/api/mcp"
   bearer_token_env_var = "BLURWRITE_API_KEY"
   ```

4. In the app: MCP servers > Add server > Streamable HTTP.

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

### Cursor (Connects online)

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

2. Add this to ~/.cursor/mcp.json:
   
   ```json
   {
     "mcpServers": {
       "blurwrite": {
         "url": "https://blurwrite.com/api/mcp",
         "headers": {
           "Authorization": "Bearer ${env:BLURWRITE_API_KEY}"
         }
       }
     }
   }
   ```

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

### VS Code (Copilot) (Connects online)

1. Add this to .vscode/mcp.json:
   
   ```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}"
         }
       }
     }
   }
   ```

2. When the server starts, VS Code asks for your key once and keeps it.

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

### Windsurf (Connects online)

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

2. In the app: Cascade > ... > Open MCP config file.

3. Add this to mcp_config.json:
   
   ```json
   {
     "mcpServers": {
       "blurwrite": {
         "serverUrl": "https://blurwrite.com/api/mcp",
         "headers": {
           "Authorization": "Bearer ${env:BLURWRITE_API_KEY}"
         }
       }
     }
   }
   ```

4. Quit and restart Windsurf so it loads the server.

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

### Gemini CLI (Connects online)

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

2. Run this in a terminal:
   
   ```sh
   gemini mcp add --transport http --header "Authorization: Bearer $BLURWRITE_API_KEY" blurwrite https://blurwrite.com/api/mcp
   ```

3. Or put this in ~/.gemini/settings.json instead:
   
   ```json
   {
     "mcpServers": {
       "blurwrite": {
         "httpUrl": "https://blurwrite.com/api/mcp",
         "headers": {
           "Authorization": "Bearer YOUR_API_KEY"
         }
       }
     }
   }
   ```

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

### Other MCP clients (Online, a bridge or the file)

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

2. A client that only starts local servers can reach the address through the open-source mcp-remote bridge (it needs Node.js):
   
   ```json
   {
     "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"
         }
       }
     }
   }
   ```

3. Or run our server file yourself: (Download the server file: https://blurwrite.com/mcp/server.mjs)
   
   ```sh
   BLURWRITE_API_KEY="YOUR_API_KEY" node /path/to/server.mjs
   ```

## Plan and limits

Take the Pro plan, at 29.99 USD a month. The MCP server uses your API key, so every call counts against the same plan, allowance and limits as the API.

- Each key makes at most 60 requests every 60 seconds.
- Each key has at most 4 detect calls (a batch counts as one) and 2 humanize, paraphrase or summarize calls running at once; one more is answered 429 concurrency_limited with a Retry-After.
- 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.
- An account holds up to 5 active keys, so a key can be rotated without downtime.