Das Model Context Protocol ist ein offener Standard, über den ein KI-Assistent externe Tools aufrufen kann. Unseren MCP-Server betreiben wir unter der Adresse unten. Für Clients, die nur Programme auf Ihrem eigenen Rechner starten können, gibt es stattdessen eine kleine Serverdatei. In beiden Fällen ruft der Server mit Ihrem Schlüssel die API dieser Website auf und tut sonst nichts. Der Agent erhält also dieselben Einschätzungen, die auch die Website zeigt.
Jede Einschätzung, die ein Agent erhält, enthält den Wert, seine Unsicherheit und den Kalibrierungsstand. So kann der Agent erklären, was die Einschätzung bedeutet und wann sie nicht verwendet werden sollte.
Wählen Sie Ihren Client. Jeder Tab enthält die Schritte, die genaue Konfiguration zum Kopieren und einen kurzen Test. Befehle und Konfiguration sind in allen Sprachen gleich.
Claude Code Verbindet sich mit dem gehosteten Server
Legen Sie Ihren API-Schlüssel auf dem Rechner, auf dem der Client läuft, in einer Umgebungsvariablen namens TEXTLUME_API_KEY ab:
Führen Sie diesen Befehl im Terminal aus:
Alternativ können Sie es in .mcp.json eintragen:
{
"mcpServers": {
"textlume": {
"type": "http",
"url": "https://textlume.com/api/mcp",
"headers": {
"Authorization": "Bearer ${TEXTLUME_API_KEY}"
}
}
}
}Um die Verbindung zu testen, fragen Sie Ihren Assistenten: "Bitte diesen Absatz mit Textlume prüfen und die Spanne und die Sicherheit nennen."
Ihren API-Schlüssel finden Sie im Dashboard unter API. Legen Sie Schlüssel nicht in geteilten Dateien oder Repositorys ab.
Claude Desktop Nutzt die Serverdatei
Laden Sie die Serverdatei herunter und merken Sie sich den Speicherort. Node.js muss installiert sein.
Serverdatei herunterladenÖffnen Sie in der App Settings > Developer > Edit Config.
Fügen Sie Folgendes in claude_desktop_config.json ein:
{
"mcpServers": {
"textlume": {
"command": "node",
"args": [
"/path/to/server.mjs"
],
"env": {
"TEXTLUME_API_KEY": "YOUR_API_KEY"
}
}
}
}Beenden Sie Claude Desktop und starten Sie die App neu, damit sie den Server lädt.
Um die Verbindung zu testen, fragen Sie Ihren Assistenten: "Bitte diesen Absatz mit Textlume prüfen und die Spanne und die Sicherheit nennen."
Ihren API-Schlüssel finden Sie im Dashboard unter API. Legen Sie Schlüssel nicht in geteilten Dateien oder Repositorys ab.
Claude (claude.ai) Demnächst
Die Verbindung mit claude.ai über die Anmeldung in Ihrem Konto bei Textlume kommt bald. Bis dahin funktionieren dieselben Tools bereits in Claude Desktop über die Serverdatei und in Claude Code. Die Einrichtung finden Sie in den jeweiligen Tabs.
Nur wenn Ihre Organisation bei eigenen Konnektoren Request-Header setzen kann: Tragen Sie die Adresse zusammen mit diesem Header ein.
ChatGPT Demnächst
Die Verbindung mit ChatGPT über die Anmeldung in Ihrem Konto bei Textlume kommt bald. Bis dahin funktionieren dieselben Tools bereits in Codex und Claude Code. Die Einrichtung finden Sie in den jeweiligen Tabs.
Codex Verbindet sich mit dem gehosteten Server
Legen Sie Ihren API-Schlüssel auf dem Rechner, auf dem der Client läuft, in einer Umgebungsvariablen namens TEXTLUME_API_KEY ab:
Führen Sie diesen Befehl im Terminal aus:
Alternativ können Sie es in ~/.codex/config.toml eintragen:
[mcp_servers.textlume]
url = "https://textlume.com/api/mcp"
bearer_token_env_var = "TEXTLUME_API_KEY"Öffnen Sie in der App MCP servers > Add server > Streamable HTTP.
Um die Verbindung zu testen, fragen Sie Ihren Assistenten: "Bitte diesen Absatz mit Textlume prüfen und die Spanne und die Sicherheit nennen."
Ihren API-Schlüssel finden Sie im Dashboard unter API. Legen Sie Schlüssel nicht in geteilten Dateien oder Repositorys ab.
Cursor Verbindet sich mit dem gehosteten Server
Legen Sie Ihren API-Schlüssel auf dem Rechner, auf dem der Client läuft, in einer Umgebungsvariablen namens TEXTLUME_API_KEY ab:
Fügen Sie Folgendes in ~/.cursor/mcp.json ein:
{
"mcpServers": {
"textlume": {
"url": "https://textlume.com/api/mcp",
"headers": {
"Authorization": "Bearer ${env:TEXTLUME_API_KEY}"
}
}
}
}Um die Verbindung zu testen, fragen Sie Ihren Assistenten: "Bitte diesen Absatz mit Textlume prüfen und die Spanne und die Sicherheit nennen."
Ihren API-Schlüssel finden Sie im Dashboard unter API. Legen Sie Schlüssel nicht in geteilten Dateien oder Repositorys ab.
VS Code (Copilot) Verbindet sich mit dem gehosteten Server
Fügen Sie Folgendes in .vscode/mcp.json ein:
{
"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}"
}
}
}
}Beim ersten Start des Servers fragt VS Code nach Ihrem Schlüssel und speichert ihn.
Um die Verbindung zu testen, fragen Sie Ihren Assistenten: "Bitte diesen Absatz mit Textlume prüfen und die Spanne und die Sicherheit nennen."
Ihren API-Schlüssel finden Sie im Dashboard unter API. Legen Sie Schlüssel nicht in geteilten Dateien oder Repositorys ab.
Windsurf Verbindet sich mit dem gehosteten Server
Legen Sie Ihren API-Schlüssel auf dem Rechner, auf dem der Client läuft, in einer Umgebungsvariablen namens TEXTLUME_API_KEY ab:
Öffnen Sie in der App Cascade > ... > Open MCP config file.
Fügen Sie Folgendes in mcp_config.json ein:
{
"mcpServers": {
"textlume": {
"serverUrl": "https://textlume.com/api/mcp",
"headers": {
"Authorization": "Bearer ${env:TEXTLUME_API_KEY}"
}
}
}
}Beenden Sie Windsurf und starten Sie die App neu, damit sie den Server lädt.
Um die Verbindung zu testen, fragen Sie Ihren Assistenten: "Bitte diesen Absatz mit Textlume prüfen und die Spanne und die Sicherheit nennen."
Ihren API-Schlüssel finden Sie im Dashboard unter API. Legen Sie Schlüssel nicht in geteilten Dateien oder Repositorys ab.
Gemini CLI Verbindet sich mit dem gehosteten Server
Legen Sie Ihren API-Schlüssel auf dem Rechner, auf dem der Client läuft, in einer Umgebungsvariablen namens TEXTLUME_API_KEY ab:
Führen Sie diesen Befehl im Terminal aus:
Alternativ können Sie es in ~/.gemini/settings.json eintragen:
{
"mcpServers": {
"textlume": {
"httpUrl": "https://textlume.com/api/mcp",
"headers": {
"Authorization": "Bearer YOUR_API_KEY"
}
}
}
}Um die Verbindung zu testen, fragen Sie Ihren Assistenten: "Bitte diesen Absatz mit Textlume prüfen und die Spanne und die Sicherheit nennen."
Ihren API-Schlüssel finden Sie im Dashboard unter API. Legen Sie Schlüssel nicht in geteilten Dateien oder Repositorys ab.
Other clients Gehosteter Server, Bridge oder Serverdatei
Ein Client, der sich per HTTP mit entfernten MCP-Servern verbindet, braucht nur diese beiden Angaben:
Ein Client, der nur lokale Server starten kann, erreicht die Adresse trotzdem über die quelloffene Bridge mcp-remote. Dafür ist Node.js nötig:
Oder starten Sie die Serverdatei direkt:
Serverdatei herunterladenIhren API-Schlüssel finden Sie im Dashboard unter API. Legen Sie Schlüssel nicht in geteilten Dateien oder Repositorys ab.
Für einen KI-Assistenten, der dies im Auftrag einer Person einrichtet: Die Serveradresse lautet https://textlume.com/api/mcp. Der Transport ist MCP über Streamable HTTP, und der API-Schlüssel der Person gehört in den Header "Authorization: Bearer <key>". Eine Anleitung für jeden Client als Markdown liegt unter https://textlume.com/mcp.md.
Mit diesem Skill weiß Claude, wann es welches Tool aufruft, wie es ein Ergebnis des KI-Detektors liest, welche Grenzen Ihr Tarif hat und was bei einem Fehler zu tun ist. Speichern Sie ihn als SKILL.md in einem Ordner namens textlume unter ~/.claude/skills (Claude Code) oder packen Sie den Ordner als ZIP und laden Sie ihn unter Einstellungen, Funktionen, Skills hoch (Claude-Apps). Der Skill ist auf Englisch und funktioniert in jeder Sprache.
SKILL.md herunterladen---
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.
Fügen Sie eine Anfrage in Ihren Agenten ein und hängen Sie Ihren Text an. Das passende Tool wählt der Agent selbst.
detect_textPrüft einen Text.
Anfrage
Ergebnis
Ein Wert zwischen 0 und 100 mit seiner Schwankungsbreite, die Sicherheit und eine Einschätzung für jeden Satz.
detect_batchPrüft mehrere Texte.
Anfrage
Ergebnis
Für jeden Text eine Einschätzung oder ein Fehler unter seiner eigenen id. Scheitert ein Text, kommen die übrigen trotzdem zurück.
humanize_textSchreibt einen Text mit dem Humanizer um und führt die Faktenprüfung aus.
Anfrage
Ergebnis
Der umgeschriebene Text, die Einschätzung des Detektors vorher und nachher und ein Hinweis zu jedem Satz, der wiederhergestellt wurde, damit ein Fakt stimmt.
paraphrase_textFormuliert einen Text um.
Anfrage
Ergebnis
Der umformulierte Text, auf Fakten geprüft wie die Ausgabe des Humanizers.
summarize_textFasst einen Text zusammen.
Anfrage
Ergebnis
Eine Zusammenfassung als Kernsätze, als Absatz oder in Stichpunkten.
check_grammarPrüft Grammatik und Rechtschreibung.
Anfrage
Ergebnis
Jeder Fehler mit seiner Position im Text, einer kurzen Erklärung und den vorgeschlagenen Ersetzungen.
Der MCP-Server arbeitet mit Ihrem API-Schlüssel. Jede Anfrage, die er stellt, zählt zum selben Tarif, Wortkontingent und denselben Limits wie eine direkte API-Anfrage.
29,99 USD pro Monat
Eine API-Anfrage zählt Wörter genau so wie die Website. Eine Anfrage an humanize nutzt die Humanizer-Wörter des Tarifs Pro, eine Anfrage an summarize die Wörter für den Zusammenfasser. Sind diese aufgebraucht, greifen Anfragen an humanize und paraphrase auf Ihr Wortguthaben aus Wortpaketen zu. Reicht kein Guthaben für eine Anfrage, wird sie abgelehnt und es wird nichts abgebucht. Jede Antwort nennt die verbrauchten und die verbleibenden Wörter.
Pro enthält die API, und eine Anfrage verbraucht dieselben Wörter wie die Website. Eine Detect-Anfrage geht von den Detektor-Wörtern des Tarifs ab, eine Humanize-Anfrage von den Humanizer-Wörtern, eine Summarize-Anfrage von den Wörtern für den Zusammenfasser. Ein eigenes API-Kontingent, das zuerst aufgebraucht wäre, gibt es nicht. Ist das Kontingent erschöpft, greifen Anfragen an Detektor, Humanizer oder Paraphrasierer auf das Wortguthaben des Kontos zu, genau wie auf der Website. Für die anderen Tools gibt es kein Wortguthaben. Eine Anfrage, die verbleibende Wörter und Guthaben zusammen nicht decken, wird mit 402 abgelehnt und kostet nichts. Jede erfolgreiche Antwort nennt die verbrauchten Wörter, ihre Herkunft und den Rest (außer wenn recorded false ist). Pro Abrechnungszeitraum endet die API-Nutzung eines Kontos bei 250.000 Wörtern, unabhängig vom Guthaben, damit ein entwendeter Schlüssel nicht alles auf einmal verbrauchen kann.
Melden Sie sich zuerst an und erstellen Sie dann im Dashboard einen Schlüssel.