Skip to main content
MCP server

Textlume writing tools in your AI agent

Connect Claude Desktop, Claude Code, Cursor or any other MCP client. Your agent can then check, rewrite, summarize and correct text with the tools this site runs.

Server address
https://textlume.com/api/mcp

About MCP

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.

  1. Subscribe to the Pro plan, then create an API key on your dashboard.
  2. Add the server address and your key to your client using the configuration below. Replace YOUR_API_KEY with your key.
  3. Ask your agent to check, rewrite, summarize or correct some text.

Setup for your client

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

  1. Store your API key in an environment variable named TEXTLUME_API_KEY on the machine where the client runs:

    export TEXTLUME_API_KEY="YOUR_API_KEY"
  2. Run this command in a terminal:

    claude mcp add --transport http textlume https://textlume.com/api/mcp --header "Authorization: Bearer $TEXTLUME_API_KEY"
  3. Or add it to .mcp.json instead:

    .mcp.json
    {
      "mcpServers": {
        "textlume": {
          "type": "http",
          "url": "https://textlume.com/api/mcp",
          "headers": {
            "Authorization": "Bearer ${TEXTLUME_API_KEY}"
          }
        }
      }
    }
  4. 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.

Notes for AI assistants

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.

View this setup as Markdown

A ready-made skill for Claude

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

Requests to try

Paste a request into your agent and add your text. The agent chooses the right tool on its own.

Detection

  • detect_textChecks one text.

    Request

    Run this essay through the AI detector and give me the range and the confidence rating.

    Result

    A figure between 0 and 100 with its margin, the confidence rating and a reading for each sentence.

  • detect_batchChecks several texts.

    Request

    Check each of these paragraphs separately and sort them from the highest reading to the lowest.

    Result

    For each text, a reading or an error under its own id. If one text fails, the others still return.

Rewriting

  • humanize_textHumanizes a text and runs the fact checks.

    Request

    Humanize this paragraph and report what the fact checks found.

    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

    Paraphrase this introduction in a more formal tone.

    Result

    The reworded text, checked for facts the same way as the humanizer output.

  • summarize_textSummarizes a text.

    Request

    Summarize this report as a bullet list.

    Result

    A summary as key sentences, one paragraph or bullet points.

Checking

  • check_grammarChecks grammar and spelling.

    Request

    Check the grammar in this email and apply the suggested fixes.

    Result

    Each issue with its position in the text, a short explanation and the suggested replacements.

Plan and limits

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.

Pro

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
Get a key on the dashboard

Top-up packs

  • AI detector50,000wordsfrom 5.99 USD
  • Humanizer10,000wordsfrom 9.99 USD
  • Paraphraser10,000wordsfrom 9.99 USD
  • Summarizer25,000wordsfrom 6.99 USD

How the API counts words

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.

See every counting rule

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.

Limits

  • 60requests per key in each window of 60 seconds
  • 4detect calls in flight per key
  • 2humanize, paraphrase or summarize calls in flight per key
  • 50texts per batch
  • 20,000words per call
  • 5active keys per account
  • Each call accepts up to 20,000 words, whether you send one text or a whole batch.
  • On every plan, the detector reads a single text of up to 90,000 characters, which is roughly 10,000 words. Longer texts get a 413 text_too_long response, even when the call is within its word limit.
  • When the engines are under load, Pro users on the site are served ahead of API calls, so an API call may have to wait.

Connect your agent

Sign in first, then create a key on your dashboard.

Get a key on the dashboardAbout the APIAPI docs