29.99 USD per month
- 50,000
- humanizer words per month, plus 50,000 paraphraser words
- 20,000
- words per call
- 60
- requests per key in each window of 60 seconds
- 4 / 2
- detect and rewrite calls in flight per key
The Model Context Protocol is an open standard for letting an AI assistant call external tools. Our MCP server is hosted at the address below. For clients that can only launch programs on your own machine, there is a small server file to run instead. In both cases the server calls this site's API with your key and does nothing else, so the agent receives the same readings the site shows.
Each reading an agent receives includes the figure, its uncertainty and the calibration state. That lets the agent explain what the reading means and when it should not be used.
Choose your client. Each tab lists the steps, the exact configuration to copy and a quick test. Commands and configuration are identical in every language.
Claude Code Connects to the hosted server
Store your API key in an environment variable named TEXTLUME_API_KEY on the machine where the client runs:
Run this command in a terminal:
Or add it to .mcp.json instead:
{
"mcpServers": {
"textlume": {
"type": "http",
"url": "https://textlume.com/api/mcp",
"headers": {
"Authorization": "Bearer ${TEXTLUME_API_KEY}"
}
}
}
}To test the connection, ask your assistant: "Use Textlume to check this paragraph and give me the range and the confidence rating."
You will find your API key on your dashboard, under API. Keep keys out of shared files and repositories.
Claude Desktop Uses the server file
Download the server file and remember where you saved it. Node.js is required.
Download the server fileIn the app, go to Settings > Developer > Edit Config.
Add the following to claude_desktop_config.json:
{
"mcpServers": {
"textlume": {
"command": "node",
"args": [
"/path/to/server.mjs"
],
"env": {
"TEXTLUME_API_KEY": "YOUR_API_KEY"
}
}
}
}Quit Claude Desktop and open it again so it picks up the server.
To test the connection, ask your assistant: "Use Textlume to check this paragraph and give me the range and the confidence rating."
You will find your API key on your dashboard, under API. Keep keys out of shared files and repositories.
Claude (claude.ai) Coming soon
Connecting claude.ai by signing in to your Textlume account is coming soon. For now, the same tools already work in Claude Desktop through the server file, and in Claude Code. Their tabs have the setup.
Only if your organization can set request headers on custom connectors: add the address together with this header.
ChatGPT Coming soon
Connecting ChatGPT by signing in to your Textlume account is coming soon. For now, the same tools already work in Codex and Claude Code. Their tabs have the setup.
Codex Connects to the hosted server
Store your API key in an environment variable named TEXTLUME_API_KEY on the machine where the client runs:
Run this command in a terminal:
Or add it to ~/.codex/config.toml instead:
[mcp_servers.textlume]
url = "https://textlume.com/api/mcp"
bearer_token_env_var = "TEXTLUME_API_KEY"In the app, go to MCP servers > Add server > Streamable HTTP.
To test the connection, ask your assistant: "Use Textlume to check this paragraph and give me the range and the confidence rating."
You will find your API key on your dashboard, under API. Keep keys out of shared files and repositories.
Cursor Connects to the hosted server
Store your API key in an environment variable named TEXTLUME_API_KEY on the machine where the client runs:
Add the following to ~/.cursor/mcp.json:
{
"mcpServers": {
"textlume": {
"url": "https://textlume.com/api/mcp",
"headers": {
"Authorization": "Bearer ${env:TEXTLUME_API_KEY}"
}
}
}
}To test the connection, ask your assistant: "Use Textlume to check this paragraph and give me the range and the confidence rating."
You will find your API key on your dashboard, under API. Keep keys out of shared files and repositories.
VS Code (Copilot) Connects to the hosted server
Add the following to .vscode/mcp.json:
{
"inputs": [
{
"type": "promptString",
"id": "textlume-key",
"description": "Textlume API key",
"password": true
}
],
"servers": {
"textlume": {
"type": "http",
"url": "https://textlume.com/api/mcp",
"headers": {
"Authorization": "Bearer ${input:textlume-key}"
}
}
}
}The first time the server starts, VS Code asks for your key and stores it.
To test the connection, ask your assistant: "Use Textlume to check this paragraph and give me the range and the confidence rating."
You will find your API key on your dashboard, under API. Keep keys out of shared files and repositories.
Windsurf Connects to the hosted server
Store your API key in an environment variable named TEXTLUME_API_KEY on the machine where the client runs:
In the app, go to Cascade > ... > Open MCP config file.
Add the following to mcp_config.json:
{
"mcpServers": {
"textlume": {
"serverUrl": "https://textlume.com/api/mcp",
"headers": {
"Authorization": "Bearer ${env:TEXTLUME_API_KEY}"
}
}
}
}Quit Windsurf and open it again so it picks up the server.
To test the connection, ask your assistant: "Use Textlume to check this paragraph and give me the range and the confidence rating."
You will find your API key on your dashboard, under API. Keep keys out of shared files and repositories.
Gemini CLI Connects to the hosted server
Store your API key in an environment variable named TEXTLUME_API_KEY on the machine where the client runs:
Run this command in a terminal:
Or add it to ~/.gemini/settings.json instead:
{
"mcpServers": {
"textlume": {
"httpUrl": "https://textlume.com/api/mcp",
"headers": {
"Authorization": "Bearer YOUR_API_KEY"
}
}
}
}To test the connection, ask your assistant: "Use Textlume to check this paragraph and give me the range and the confidence rating."
You will find your API key on your dashboard, under API. Keep keys out of shared files and repositories.
Other clients Hosted server, bridge or server file
A client that connects to remote MCP servers over HTTP only needs these two values:
A client that can only launch local servers can still reach the address through the open-source mcp-remote bridge, which requires Node.js:
Or run the server file directly:
Download the server fileYou will find your API key on your dashboard, under API. Keep keys out of shared files and repositories.
For an AI assistant configuring this on a user's behalf: the server address is https://textlume.com/api/mcp. The transport is MCP over Streamable HTTP, and the user's API key goes in the header "Authorization: Bearer <key>". Setup instructions for every client, in Markdown, are at https://textlume.com/mcp.md.
Add this skill and Claude knows when to call which tool, how to read a detector result, the limits of your plan and what to do when a call fails. Save it as SKILL.md in a folder named textlume under ~/.claude/skills (Claude Code) or zip that folder and upload it under Settings, Capabilities, Skills (Claude apps). The skill is in English, it works in every language.
Download SKILL.md---
name: textlume
description: Check text for AI writing, humanize or paraphrase it while keeping its facts, summarize it, and check its grammar with the Textlume MCP tools. Use when the textlume MCP server is connected and the user asks to check whether text reads as AI-written, rewrite AI-sounding text, reword, summarize or proofread.
---
# Textlume writing tools
Textlume gives an agent six tools over MCP: an AI detector, a humanizer, a paraphraser, a summarizer and a grammar checker. Every call goes through the Textlume API with the user's own API key.
## Setup
1. The user needs the Pro plan and an API key from the Textlume dashboard (API section).
2. Put the key in the environment as `TEXTLUME_API_KEY`. Never write the key into a file that gets committed, and never print it.
3. Connect the hosted server. In Claude Code:
```sh
claude mcp add --transport http textlume https://textlume.com/api/mcp --header "Authorization: Bearer $TEXTLUME_API_KEY"
```
In Claude Desktop or another client: server URL `https://textlume.com/api/mcp`, header `Authorization: Bearer <key>`. A client that only runs local servers can start the stdio server from https://textlume.com/mcp/server.mjs with `node server.mjs` and `TEXTLUME_API_KEY` set.
4. Check: list the tools. You should see `detect_text`, `detect_batch`, `humanize_text`, `paraphrase_text`, `summarize_text`, `check_grammar`.
## Which tool to call
### `detect_text` (POST /api/v1/detect)
When: The user asks whether a text reads as AI-written, wants an AI score, or wants to know which sentences read as machine-like.
What it does: Read how likely a text was written by a language model. Returns a figure from 0 to 100 with its margin, our confidence rating (low, medium or high), and a reading for every sentence. Use the figure only when calibrated is true: false means the language has no fitted curve yet.
Arguments:
- `text` (required): The text to check. Too short a text gets no reading (the error says the minimum)
- `language`: Two-letter code. Omitted, the service reads it from the text
- `contentType`: essay, article, email, code
### `detect_batch` (POST /api/v1/detect/batch)
When: The user hands over several texts at once (a folder of essays, a list of posts). One call, one result per item.
What it does: Check many texts in one call. Each item carries its own id and either a reading or an error; one item failing never fails the batch.
Arguments:
- `items` (required)
### `humanize_text` (POST /api/v1/humanize)
When: The user wants AI-sounding text to read more like a person wrote it. Show the before and after reading the tool returns.
What it does: Rewrite machine-sounding text so it reads more like a person wrote it, scored by our own detector before and after. It keeps every fact: a rewrite that changes one is refused and the original sentence is put back. It does not promise to defeat any other detector.
Arguments:
- `text` (required)
- `mode`: natural, formal, simple, academic, creative, shorten or expand
- `tab`: standard, academic, professional, casual
- `strength`: regular, aggressive
- `language`
### `paraphrase_text` (POST /api/v1/paraphrase)
When: The user wants the same meaning in different words (rewording, simplifying, shortening, a different register).
What it does: Reword a text while keeping its meaning. Same guarantees as humanize_text, with the paraphraser modes.
Arguments:
- `text` (required)
- `mode`: standard, fluency, formal, academic, simple, creative, expand or shorten
- `strength`: readable, balanced, strong
- `language`
### `summarize_text` (POST /api/v1/summarize)
When: The user wants the main points of a long text, as key sentences, a paragraph or bullets.
What it does: Summarise a text as key sentences, a paragraph or bullet points.
Arguments:
- `text` (required)
- `mode`: key-sentences, paragraph, bullets
- `length`: short, medium, long
### `check_grammar` (POST /api/v1/grammar)
When: The user wants spelling, grammar and punctuation checked. Apply only the fixes the user accepts.
What it does: Find grammar, spelling and punctuation problems, each with its position, an explanation and replacements.
Arguments:
- `text` (required)
- `language`: For example en-US or de-DE
## Reading a detector result
- Every result has a figure from 0 to 100, a margin, a confidence rating (low, medium, high) and a reading per sentence. Report the figure with its margin and the rating, never a bare percentage.
- If `calibrated` is false, the language has no fitted line yet. Say there is no reading for that language and do not quote the figure as a result.
- The figure says how machine-like the text reads, not what share a machine wrote, and it is not proof of who wrote it. Never call a text "detected". Point to the sentences that read as machine-like instead.
- Texts under 50 words get no reading. Short texts always get a low confidence rating.
## Rewrites
- `humanize_text` and `paraphrase_text` keep names, numbers, quotations and claims. A sentence whose rewrite would change a fact is put back as it was, and the result notes say so. Pass those notes on to the user.
- The before and after figures are Textlume's own detector. Do not promise the user that any other detector will agree.
- Hand the user the rewritten text in full. Do not rewrite it again yourself before showing it.
## Limits
- 60 requests per 60 seconds per key.
- At most 4 detector calls and 2 rewrite or summary calls at the same time per key.
- Up to 20,000 words per call. The detector reads up to 10,000 words (90,000 characters) per text. Split longer texts and say that you did.
- `detect_batch` takes up to 50 items.
- Words count against the monthly words of the user's plan.
## Errors
The tool result carries the API's own message. Act on the code:
- `no_key` or `bad_key` (401): the key is missing or wrong. Ask the user to set `TEXTLUME_API_KEY`. Do not retry.
- `out_of_scope` (403): the key was created without this tool's scope. The user creates a key with that scope on the dashboard.
- `plan_lapsed` (403): the Pro plan is not active. Tell the user, do not retry.
- words used up (402): the response has `available`, the words left this month. Offer to send a shorter text.
- `rate_limited` or `concurrency_limited` (429): wait the seconds in `retry-after`, then retry once. Send batches one after another, not in parallel.
- `text_too_long` (413): split the text and check the parts, and say so.
- `too_short` (422): the text is under 50 words. `not_calibrated` (422): no reading for that language.
- `engine_starting`, `engine_busy`, `engine_unavailable` (503) or `engine_timeout` (504): the service is not available right now. Wait and retry once. Never make up a result.
Paste a request into your agent and add your text. The agent chooses the right tool on its own.
detect_textChecks one text.
Request
Result
A figure between 0 and 100 with its margin, the confidence rating and a reading for each sentence.
detect_batchChecks several texts.
Request
Result
For each text, a reading or an error under its own id. If one text fails, the others still return.
humanize_textHumanizes a text and runs the fact checks.
Request
Result
The rewritten text, the detector reading before and after, and a note for each sentence that was restored to keep a fact intact.
paraphrase_textParaphrases a text.
Request
Result
The reworded text, checked for facts the same way as the humanizer output.
summarize_textSummarizes a text.
Request
Result
A summary as key sentences, one paragraph or bullet points.
check_grammarChecks grammar and spelling.
Request
Result
Each issue with its position in the text, a short explanation and the suggested replacements.
The MCP server runs on your API key. Every call it makes counts toward the same plan, word allowance and limits as a direct API call.
29.99 USD per month
An API call uses words exactly as the site does. A humanize call draws on the humanizer words of the Pro plan, and a summarize call draws on its summarizer words. Once those are gone, humanize and paraphrase calls use your top-up words. A call that no balance can cover is rejected and nothing is charged. Each response reports the words used and the words remaining.
Pro includes the API, and API calls use the same word allowance as the website. A detect call uses your plan's detector words, a humanize call its humanizer words and a summarize call its summarizer words, with no separate API allowance. Once a plan allowance is used up, detector, humanizer and paraphraser calls draw on your top-up balance, just like on the website. The other tools have no top-up balance. If the remaining words and balance together can't cover a call, it's refused with a 402 and costs nothing. Every successful response shows the words used, where they came from and what's left, unless recorded is false. API use for an account stops at 250,000 words per billing period whatever the balance, so a leaked key can't use up everything at once.
Sign in first, then create a key on your dashboard.