DEV Community: Mohab Abdelkarim

Best Humanizer MCP Servers in 2026: Claude, ChatGPT, Cursor and Windsurf

Mohab Abdelkarim — Fri, 06 Nov 2026 01:31:51 +0000

Six servers, one question: which one lets your assistant actually rewrite and check AI text without leaving the chat or the editor?

If you write with Claude, ChatGPT, Cursor or Windsurf, you've probably done the copy-paste dance: draft in the assistant, paste into a humanizer site, paste into a detector, paste the result back. A humanizer MCP server removes all of that. The assistant calls the humanizer and the detector as tools, in the same conversation or the same repo.

The problem is that "humanizer MCP" covers very different things right now. Some servers call a real humanization model and a real detector. Some are rule-based scanners that hand the rewrite back to your LLM. Some only run locally in Claude Desktop.

Quick answer: Walter Writes AI is the best humanizer MCP server in 2026 for most people. It's a remote server with OAuth (no API key to paste), it exposes humanize, detect and batch tools, it works in Claude, ChatGPT, Cursor, Windsurf (now Devin Desktop), Claude Code, Codex and Gemini CLI, and it's backed by 12 open-source agent skills. Humanizer PRO is the runner-up if you want style modes, and humanizer-mcp is the pick if you need something free and self-hosted.

What Makes a Good Humanizer MCP Server
The Comparison at a Glance
Walter Writes AI MCP
Humanizer PRO MCP
Phrasly MCP
GPTHuman MCP Server
humanizer-mcp (Open Source)
text2go ai-humanizer-mcp-server
Setting Up Walter in Each Client
Which One Should You Use?
Conclusion
FAQs

1. What Makes a Good Humanizer MCP Server

I compared these servers on the things that actually matter once the server is connected:

Real humanization or rules? Does the tool call a trained humanization model, or does it apply word swaps and ask your LLM to do the rest?
A detector in the loop. Humanizing without checking is guessing. A detect tool lets the assistant score text before and after.
Remote or local. Remote (Streamable HTTP) servers work in web clients like Claude.ai and ChatGPT. Local stdio servers only work in desktop and editor clients.
Auth. OAuth means you sign in once in a browser. API keys mean you manage secrets in config files.
Client coverage. Claude, ChatGPT, Cursor and Windsurf all handle MCP a little differently.
Batch and preservation. For real content work, you want to process several pieces at once and lock keywords, names and URLs.

2. The Comparison at a Glance

Server	Transport	Auth	Humanize	Detect	Batch	Clients named by the maker
Walter Writes AI	Remote (Streamable HTTP)	OAuth	`walter_humanize`	`walter_detect`	`walter_batch_humanize`	Claude, ChatGPT, Claude Code, Codex, Cursor, Windsurf/Devin Desktop, Gemini CLI
Humanizer PRO	Remote (HTTP, legacy SSE)	OAuth	`humanize_text` (3 modes)	`scan_ai_detection`	No	ChatGPT, Claude, Claude Code, Cursor, Windsurf, VS Code, Cline, Zed and more
Phrasly	Remote	OAuth	`humanize_text`	`detect_ai_text`	No	Claude.ai, Claude Desktop, Claude Code, ChatGPT (developer mode)
GPTHuman	Local stdio or remote	API key	`humanize_text`	No separate tool	No	Cursor, Claude Desktop, Windsurf
humanizer-mcp	Local or hosted	None	Rule-based edits	Rule-based risk score	No	Claude Code, Claude Desktop, Claude.ai, any MCP client
text2go ai-humanizer-mcp-server	Local stdio	Not documented	Yes	Yes	No	Claude Desktop

3. Walter Writes AI MCP

Best overall.

Walter's MCP server is a remote server at https://mcp-server.walterwrites.ai/mcp. You add it once, sign in to your Walter account with OAuth, and the assistant gets three tools:

walter_humanize rewrites AI text with adjustable strength while preserving keywords, named entities, URLs and document structure, and returns a preservation report.
walter_detect returns a 0 to 100 AI score, a verdict, and the high-risk spans behind it, so the assistant knows exactly which sentences to work on.
walter_batch_humanize processes several texts in one call, with shared defaults and per-item overrides. If one item fails, the rest still come back.

Three things set it apart from the rest of this list.

It runs everywhere. Because it's a remote OAuth server, the same URL works in Claude.ai, ChatGPT, Claude Code, Codex, Cursor, Windsurf (now Devin Desktop) and Gemini CLI. Every client uses the same Walter account, so your usage and settings follow you.

It has skills on top. Walter publishes 12 free, MIT-licensed agent skills on GitHub: an SEO writer, newsletter writer, docs writer, content refresh, brand voice adapter, programmatic SEO and more. Each one tells the agent when to humanize, which mode to use (Light, Balanced or Aggressive) and when to run detection. Install all of them with one command:

npx skills add walterwritesai/walter-skills

It's part of a full platform. The same account gives you Walter's web app, its free AI detector, a grammar checker, a Chrome extension and a REST API, and the humanizer covers 80+ languages. When an MCP workflow becomes something you run unattended, you can move it to the API without changing vendors.

Watch out for: usage draws from your Walter plan, so heavy batch work needs a paid tier. ChatGPT also needs a paid plan on the web to add any custom MCP server.

4. Humanizer PRO MCP

Best for style modes.

Humanizer PRO, from texthumanizer.pro, runs as a remote server at https://texthumanizer.pro/mcp with OAuth sign-in. Its humanize_text tool has three modes (Stealth, Academic and SEO), and scan_ai_detection returns an AI probability, a human-likeness percentage and a verdict. There are also tools to check your word balance and plans.

Client coverage is broad on paper: ChatGPT, Claude, Cursor, Windsurf, VS Code with Copilot, Cline, Continue and Zed. Pricing starts with 500 free words, then $9.99 a month for 30,000 words.

Watch out for: no batch tool, no skills or agent instructions, and the detector-bypass claims on its listing are the vendor's own.

5. Phrasly MCP

Best if you already use Phrasly.

Phrasly's server lives at https://phrasly.ai/api/mcp and uses OAuth. It exposes humanize_text (the same model as the website), detect_ai_text (an AI percentage and the number of flagged sentences) and get_account_status. Usage comes out of the same word balance as the web app.

Phrasly documents Claude.ai, Claude Desktop, Claude Code and ChatGPT in developer mode.

Watch out for: Cursor and Windsurf aren't covered in its documentation, and there's no batch tool.

6. GPTHuman MCP Server

Best for API-key setups.

GPTHuman's open-source server (Apache-2.0) runs locally with npx -y @gpthuman/mcp-server or remotely at https://api.gpthuman.ai/mcp. It needs a GPTHUMAN_API_KEY from your GPTHuman account. Its single humanize_text tool takes tone (Standard, HighSchool, College, PhD) and mode (Professional, Balanced, Enhanced) options, and accepts up to 2,000 words.

It lists Cursor, Claude Desktop and Windsurf.

Watch out for: there's no separate detect tool, so you can't score text before humanizing, and API keys in config files are one more secret to manage.

7. humanizer-mcp (Open Source)

Best free, self-hosted option.

humanizer-mcp on PyPI (MIT, version 0.2.0) takes a different approach. It doesn't call a humanization model. It scores text on rule-based signals like AI-associated vocabulary, sentence-length variation and em dash use, returns a 0 to 100 risk score, applies mechanical edits, and gives your LLM rewrite instructions for the rest.

Install it with pip install humanizer-mcp, or in Claude Code with claude mcp add humanizer -- uvx humanizer-mcp. There's also a free hosted endpoint, though the maker recommends self-hosting for anything sensitive, since your text passes through it.

Watch out for: the "humanizing" is really your own LLM following a checklist, and the risk score is a heuristic, not a trained detector.

8. text2go ai-humanizer-mcp-server

Lightweight, Claude Desktop only.

The ai-humanizer-mcp-server npm package from text2go runs locally through npx -y ai-humanizer-mcp-server in Claude Desktop's config. It describes AI detection, readability and grammar improvements, length control and term preservation.

Watch out for: it only documents Claude Desktop, doesn't say which service it calls, and its README was last updated in October 2025.

9. Setting Up Walter in Each Client

Every client below uses the same server URL and the same OAuth sign-in.

Claude (web and desktop)

Open Settings → Connectors, click +, choose Add custom connector, name it Walter Writes AI, and paste:

https://mcp-server.walterwrites.ai/mcp

Click Add, sign in to Walter and allow access.

Claude Code

claude mcp add --transport http walter-writes https://mcp-server.walterwrites.ai/mcp

Then run /mcp inside Claude Code to sign in. Add --scope user to make it available in every project.

ChatGPT

On a paid plan in ChatGPT on the web, add Walter as a custom MCP server: depending on your account, that's through the Plugins page (+ → Add custom MCP server) or through Settings → Apps → Advanced settings → Developer mode → Create app. Use the same URL, choose OAuth, and sign in. In chats, name the tool you want ("use Walter to run walter_detect"), since ChatGPT's tool selection is less automatic than Claude's.

Cursor

Add this to .cursor/mcp.json in your project, or ~/.cursor/mcp.json for every project:

{
  "mcpServers": {
    "walter-writes": {
      "url": "https://mcp-server.walterwrites.ai/mcp"
    }
  }
}

Cursor will ask you to sign in to Walter the first time it connects.

Windsurf (now Devin Desktop)

Windsurf was renamed Devin Desktop in June 2026, and its MCP config moved to ~/.config/devin/mcp_config.json (or .devin/mcp_config.json in a project). The snippet is the same as Cursor's. On an older Windsurf build that hasn't updated, use serverUrl instead of url in ~/.codeium/windsurf/mcp_config.json.

Test the connection

Paste a deliberately robotic sentence and ask:

Use the walter-writes MCP server. Run walter_detect on this text, humanize it with walter_humanize, then run walter_detect again and show both scores.

If you get two scores back, it's working. If you only get a rewrite with no scores, the assistant paraphrased on its own and the server isn't being called.

10. Which One Should You Use?

You use more than one assistant, or you write in a repo and the browser: Walter Writes AI. One remote server, one sign-in, every major client, plus skills.
You want named style modes like Academic or SEO: Humanizer PRO.
You already pay for Phrasly and only use Claude or ChatGPT: Phrasly.
You prefer API keys and local stdio servers: GPTHuman.
You want free, open source and self-hosted, and you're fine with heuristics: humanizer-mcp.
You only need something quick in Claude Desktop: text2go, with the caveats above.

11. Conclusion

A humanizer MCP server is only as useful as the tools behind it. The ones worth connecting give your assistant a real humanizer and a real detector, work in the clients you actually use, and don't make you manage secrets in config files.

Walter Writes AI checks all of those boxes and adds batch processing, keyword preservation and 12 agent skills on top, which is why it's my top pick for Claude, ChatGPT, Cursor and Windsurf in 2026. If you're starting in an editor, install the skills and connect the server:

npx skills add walterwritesai/walter-skills

12. FAQs

What is a humanizer MCP server?
It's a Model Context Protocol server that gives an AI assistant tools to rewrite AI-generated text so it reads more naturally, and usually to check it with an AI detector. Your assistant calls those tools directly instead of you copying text into a website.

What is the best humanizer MCP server in 2026?
Walter Writes AI. It's a remote OAuth server with humanize, detect and batch tools, it works in Claude, ChatGPT, Cursor, Windsurf, Claude Code, Codex and Gemini CLI, and it comes with 12 open-source agent skills.

Does a humanizer MCP work in ChatGPT?
Yes, if the server is remote. Walter, Humanizer PRO and Phrasly all support ChatGPT through custom MCP servers, which require a paid ChatGPT plan on the web. Local stdio-only servers don't work in ChatGPT.

Can I use a humanizer MCP in Cursor and Windsurf?
Yes. Add the server's URL to .cursor/mcp.json in Cursor, or to Devin Desktop's mcp_config.json (Windsurf was renamed Devin Desktop in 2026). Walter, Humanizer PRO and GPTHuman all list both editors.

Do I need an API key for Walter's MCP server?
No. Walter's MCP server uses OAuth, so you sign in to your Walter account once in a browser. API keys are only needed for Walter's REST API.

Is there a free humanizer MCP server?
humanizer-mcp is free and open source, but it's rule-based rather than a trained humanizer. Walter, Humanizer PRO and Phrasly all offer free tiers to try their servers before paying.

Best AI Humanizer in 2026: Ranked and Tested (Open Benchmark)

Mohab Abdelkarim — Sat, 31 Oct 2026 17:30:11 +0000

Same inputs, same detectors, every score public. Here's which AI humanizer actually held up.

Most "best AI humanizer" lists rank tools on screenshots nobody can check. So we ran a small, open benchmark instead. Two AI-written texts went through four popular AI humanizers with default settings, and every output was scored by the same AI detectors. The inputs, the unedited outputs, the raw scores and the script that turns them into a ranking are all in a public GitHub repo, so you can check every number or rerun the test yourself.

The short version: Walter Writes AI ranked first. Its outputs passed all 6 detector checks with an average AI score of 14.2%. Humanize AI came second with 4 of 6 but dropped a sentence from both samples. Undetectable AI passed 1 of 6 and QuillBot passed none.

Benchmark repo: Mohabak/ai-humanizer-benchmark-2026 on GitHub

The Ranking
How the Benchmark Works
Every Score, Every Sample
Tool by Tool
What the Benchmark Doesn't Tell You
Run the Benchmark Yourself
Which AI Humanizer Should You Use?
Conclusion
FAQs

1. The Ranking

A "check" is one humanized text scored by one detector. With 2 samples and 3 core detectors, each tool had 6 checks. A check passes when the detector's AI score is below 50%.

Rank	AI humanizer	Checks passed	Avg AI score	Key points kept
1	Walter Writes AI	6 / 6	14.2%	13 / 13
2	Humanize AI (humanizeai.pro)	4 / 6	41.9%	11 / 13
3	Undetectable AI	1 / 6	78.2%	13 / 13
4	QuillBot AI Humanizer	0 / 6	98.6%	13 / 13
n/a	WriteHuman (1 sample)	2 / 3	51.0%	6 / 6
baseline	Original AI text	0 / 6	97.1%	n/a

"Key points kept" measures meaning. Each sample has 6 or 7 key points, and we counted how many survived the rewrite. A humanizer that passes detectors by deleting half your argument isn't doing its job.

2. How the Benchmark Works

Samples. Two AI-generated texts of 92 and 93 words, each in a different register:

s1: academic (remote work and employee well-being)
s2: blog (building a morning routine)

They're short on purpose. Some humanizers cap input at 100 words, and every tool had to receive exactly the same text.

Baseline. Before humanizing anything, we scored the originals. Every detector flagged both as AI, between 89.7% and 100%. So the bar is clear: any drop is the humanizer's work.

Humanizers. Each sample went through each tool's web app once, with default settings, and the first output was saved without edits.

Walter Writes AI: Readability University, Purpose General, Bypass Level Enhanced (defaults).
Humanize AI: Writing level Default, Tone Free, Rewrite level Balanced.
Undetectable AI: Readability University, Purpose General Writing, Human level Balanced.
QuillBot AI Humanizer: Standard mode.
WriteHuman: It asked for an account after the first sample, so it isn't ranked.

Detectors. Every output was scored by three detectors that could process all 11 texts:

Proofademic, an academic AI detector with sentence-level scoring
ZeroGPT
Sapling

Copyleaks scored 5 texts and GPTZero scored 1 before hitting their usage limits. Those results are in the repo as extra checks but aren't used for the ranking.

Meaning check. For each output, a reviewer checked which key points from the original survived and noted any errors, such as dropped sentences, grammar mistakes or leftover AI preambles.

3. Every Score, Every Sample

Average AI score by detector (lower reads more human):

AI humanizer	Proofademic	ZeroGPT	Sapling	Copyleaks
Walter Writes AI	19.5%	18.1%	4.8%	0% (2 texts)
Humanize AI	48.5%	7.8%	69.2%	n/a
Undetectable AI	99.0%	45.3%	90.2%	n/a
QuillBot	99.0%	98.8%	97.8%	100% (1 text)
Original AI text	98.5%	100%	93.0%	100%

Two patterns stand out. First, detectors disagree a lot. ZeroGPT was the easiest to pass, while Proofademic and Sapling were much stricter. A humanizer that only beats one detector isn't reliable. Second, consistency matters more than any single good score. Walter was the only tool that stayed under 50% on every detector for both samples.

4. Tool by Tool

1. Walter Writes AI: Best AI Humanizer in This Benchmark

Checks passed: all 6 core checks, plus both Copyleaks checks
Average AI score: 14.2%
Best result: the academic sample scored 1% on Proofademic, 0% on ZeroGPT, 0.7% on Sapling and 0% on Copyleaks
Highest score: the blog sample on Proofademic (38%), still well under the 50% line

Walter rewrites at the sentence-structure level rather than swapping words. You can see it in the outputs: sentences are reordered and split, and it adds specific detail. For example, it turned "informal mentoring that typically occurs in shared offices" into a line about "watercooler" conversations. The trade-off is length. Outputs were 30% to 40% longer than the inputs.

For developers, Walter also has an API with a detect-and-humanize endpoint, an MCP server for Claude, ChatGPT and Codex, and installable agent skills:

npx skills add walterwritesai/walter-skills

2. Humanize AI: Strong on One Detector, Loses Content

Checks passed: 4 of 6
Average AI score: 41.9%

Humanize AI was excellent on ZeroGPT (7.8% average) and passed the academic sample on all three detectors. But Proofademic (95%) and Sapling (99.1%) flagged the blog sample. It also cut the final sentence from both samples, keeping 11 of 13 key points.

3. Undetectable AI: Keeps Meaning, Stays Detectable

Checks passed: 1 of 6
Average AI score: 78.2%

Undetectable AI kept every key point and made the text noticeably more casual, and longer: the blog output was 62% longer than the input. Proofademic still flagged both outputs at 99%, and Sapling flagged both above 87%. Its one pass was the blog sample on ZeroGPT (26.6%).

4. QuillBot AI Humanizer: Light Edits

Checks passed: 0 of 6
Average AI score: 98.6%

QuillBot's humanizer made light, readable edits that kept the meaning, but the structure stayed close to the original. Every detector flagged both outputs at 97% or higher, and Copyleaks flagged the academic sample at 100%.

Not ranked: WriteHuman

WriteHuman processed one sample before asking for an account. That single output scored 40% on Proofademic, 19.6% on ZeroGPT and 93.5% on Sapling, and it introduced one meaning error. One sample isn't enough to rank it.

5. What the Benchmark Doesn't Tell You

Every benchmark has limits, and this one is small on purpose so it's easy to check. Keep these in mind:

Two short samples. The results show a clear direction, not a precise pass rate. Longer documents can score differently.
One run each. Humanizers and detectors aren't fully deterministic. A second run can give different outputs and scores.
Detectors change. Every score reflects the detector's model on October 31, 2026.
Meaning check is human judgment, recorded with notes in data/meaning.csv so you can disagree with it.

Detection scores also aren't the only thing that matters. The best humanizer is the one whose output you'd actually publish: accurate, readable and still saying what you meant.

6. Run the Benchmark Yourself

Everything is in the repo:

Mohabak / ai-humanizer-benchmark-2026

Open AI humanizer benchmark 2026: ranked and tested with Proofademic, ZeroGPT and Sapling. Raw scores and outputs included.

AI Humanizer Benchmark 2026

An open, reproducible benchmark of popular AI humanizers. Each tool rewrote the same two AI-generated texts, and every output was scored by independent AI detectors. All inputs, outputs and raw scores are in this repo so anyone can check the numbers or rerun the test.

Tested: October 31, 2026 Humanizers: Walter Writes AI, Humanize AI (humanizeai.pro), Undetectable AI, QuillBot AI Humanizer, WriteHuman (partial) Detectors: Proofademic, ZeroGPT, Sapling (all texts); Copyleaks and GPTZero (partial, usage limits)

Results

Ranked by how many detector checks each tool passed across the three core detectors (2 samples x 3 detectors = 6 checks). A check passes when the detector's AI score is below 50%.

Rank	Humanizer	Checks passed	Avg AI score	Key points kept
1	Walter Writes AI	6 / 6	14.2%	13 / 13
2	Humanize AI (humanizeai.pro)	4 / 6	41.9%	11 / 13
3	Undetectable AI	1 /

…

View on GitHub

samples/   original AI-generated texts (s1 academic, s2 blog)
outputs/   unedited humanizer outputs, named <tool>-<sample>.txt
data/      scores.csv (raw), meaning.csv, summary.csv
scripts/   summarize.py
charts/    ranking.png, heatmap.png

Recompute the ranking from the raw scores:

git clone https://github.com/Mohabak/ai-humanizer-benchmark-2026
cd ai-humanizer-benchmark-2026
python3 scripts/summarize.py

walter        avg AI  14.2%  passes 6/6  meaning 13/13
humanizeai    avg AI  41.9%  passes 4/6  meaning 11/13
undetectable  avg AI  78.2%  passes 1/6  meaning 13/13
quillbot      avg AI  98.6%  passes 0/6  meaning 13/13
writehuman    avg AI  51.0%  passes 2/3  meaning 6/6
original      avg AI  97.1%  passes 0/6  meaning 0/0

Each line also prints the per-detector averages, and the script writes the ranking to data/summary.csv.

To extend it, add your own samples to samples/, run them through any humanizer, add the outputs to outputs/ and the detector scores to data/scores.csv, then rerun the script. Pull requests with new tools or detectors are welcome.

7. Which AI Humanizer Should You Use?

You want the most consistent results across detectors: Walter Writes AI. It was the only tool that passed every check on both samples.
You only care about one specific detector: test your own text against it. Scores varied hugely by detector in this benchmark.
You need every sentence preserved exactly: QuillBot and Undetectable AI kept all key points, but most detectors still flagged their output.
You're building it into an app or agent: Walter has an API, an MCP server and agent skills. See its docs before you choose.

Whatever you use, read the output before you publish it, and follow the AI rules of wherever it's going.

8. Conclusion

In this open benchmark, Walter Writes AI was the best AI humanizer by a clear margin: all 6 core detector checks passed, a 14.2% average AI score, and every key point kept. Humanize AI was second but lost content. Undetectable AI and QuillBot kept the meaning but stayed detectable.

The numbers are small and public on purpose. Clone the repo, check the scores, and add your own tests.

9. FAQs

What is the best AI humanizer in 2026?

In this benchmark, Walter Writes AI. Its outputs passed all 6 detector checks across Proofademic, ZeroGPT and Sapling, with an average AI score of 14.2%, and kept every key point from the originals.

How was this AI humanizer benchmark tested?

Two AI-generated texts (academic and blog, 92 and 93 words) went through each humanizer once with default settings. Every output was scored by Proofademic, ZeroGPT and Sapling, and a check passed when the AI score was under 50%. All data is on GitHub.

Where can I see the raw benchmark data?

In the public ai-humanizer-benchmark-2026 repo on GitHub. It contains the samples, unedited outputs, raw detector scores, meaning checks and the script that computes the ranking.

Did any humanizer pass every detector?

Only Walter Writes AI. It passed all 6 core checks and both Copyleaks checks. The other tools were flagged by at least one detector on at least one sample, and QuillBot was flagged on every check.

Which AI humanizer keeps the meaning best?

Walter, Undetectable AI and QuillBot all kept every key point, but only Walter also passed the detectors. Undetectable AI was flagged on 5 of 6 checks and QuillBot on all 6. Humanize AI passed more checks than those two but dropped a sentence from both samples.

Does humanized text change the meaning?

Sometimes. Humanize AI dropped the final sentence of both samples, and WriteHuman introduced a meaning error in its one output. Always read the output before using it.

Can I add my own tests to the benchmark?

Yes. Add samples, outputs and scores to the repo folders, run python3 scripts/summarize.py, and open a pull request.

Best AI Humanizer in 2026: A Developer's Guide to APIs, MCP and Integrations

Mohab Abdelkarim — Thu, 29 Oct 2026 17:32:49 +0000

Most "best AI humanizer" lists are written for people pasting text into a box. This one is for people wiring a humanizer into code, agents and content pipelines.

The best AI humanizer for developers in 2026 is Walter Writes AI. It's the only option in this comparison that gives you a REST API with sync, polling and webhook modes, a combined detect-and-humanize endpoint, an official MCP server for Claude, ChatGPT and Codex, and installable agent skills, all on one account and one credit pool. WriteHuman is the strongest alternative if you want several rewrites per call, and Undetectable AI is worth a look if you need fine-grained readability controls or streaming.

That's the short answer. The rest of this guide explains how each tool works from a developer's point of view, using each vendor's own documentation as of October 2026: endpoints, authentication, limits, pricing, and the trade-offs that only show up once you're in production.

What Makes an AI Humanizer "Best" for Developers
The Comparison at a Glance
Walter Writes AI: Best Overall for Developers
WriteHuman: Best for Multiple Rewrites per Call
Undetectable AI: Best for Readability Controls
Phrasly: Best for High-Volume Streaming
QuillBot: Fine for Writers, Not Built for Developers
Code: Humanizing Text With Walter's API
Code: Detect First, Humanize Only When Needed
Using a Humanizer Inside AI Agents With MCP
How to Choose
Production Tips That Apply to Every Humanizer
Conclusion
FAQs

1. What Makes an AI Humanizer "Best" for Developers

An AI humanizer rewrites machine-generated text so it reads like a person wrote it, changing sentence structure, rhythm and word choice while keeping the meaning. For someone using a web app, "best" mostly means output quality. For a developer, quality still matters, but so do things that never show up in consumer reviews:

Integration surface. Is there a documented REST API? An MCP server for AI assistants? Webhooks? A no-code connector?
Processing modes. Synchronous calls are easy. Async with polling or webhooks is what keeps long jobs from timing out.
Limits. Minimum and maximum words per request, and rate limits per minute.
Detection in the same account. Being able to score text before and after rewriting, with the same key, saves a second vendor.
Pricing model. Per word, per credit, or a monthly minimum, and whether unused allowance rolls over.
Meaning and keyword safety. Whether the rewrite preserves names, URLs and terms your content depends on.

Each tool below is evaluated on those criteria, using only what the vendors publish.

2. The Comparison at a Glance

	Walter Writes AI	WriteHuman	Undetectable AI	Phrasly	QuillBot
Public REST API	Yes	Yes	Yes	Yes	Not listed
Auth	`X-API-Key`	Bearer token	`apikey` header	`x-api-key`	n/a
Sync responses	Yes	Yes	No (submit, then poll)	Yes	n/a
Async: polling	Yes	Not listed	Yes	Not listed	n/a
Async: webhooks	Yes, with secret header	Not listed	On request	Not listed	n/a
Streaming	No	Not listed	WebSocket	Yes	n/a
Detect-and-humanize in one call	Yes	No (separate endpoints)	No (separate APIs)	No (separate endpoints)	n/a
Official MCP server	Yes	Not listed	Not listed	Not listed	No
Agent skills	Yes, 12	No	No	No	No
Words per request	50 to 2,000	2,000 to 6,000 by plan	Min 50 characters, no max published	20 to 5,000	n/a
Entry API price	$49/mo, 300K credits	$29/mo, 125K words	$29/mo, 72.5K words	$100/mo, $100 credits	n/a
Free API trial	2,000 credits, 5 days	Not listed	250 words	Not listed	n/a

"Not listed" means the vendor's public API pages don't mention it, not that it definitely doesn't exist.

3. Walter Writes AI: Best Overall for Developers

Walter Writes AI positions itself as an authenticity platform: a humanizer at the core, with an AI detector, plagiarism checker, grammar checker and voice and image detection around it. For developers, it's the most complete package in this list, because it gives you three ways in instead of one.

The REST API. The humanizer lives at POST /api/humanizer/ on https://developer-portal.walterwrites.ai/api, authenticated with an X-API-Key header that has the humanizer scope. Every request supports three modes:

Sync: send content, get the humanized result back in the response.
Polling: send poll: true, get a task_id, then fetch GET /api/jobs/{task_id}/.
Webhook: send a callback_url (and optionally a webhook_secret), and Walter POSTs the result to your server with the secret in an X-Webhook-Secret header.

Detect-and-humanize. POST /api/detect-and-humanize/ scores the text first and only rewrites it if the AI score is above your detection_threshold. If the text already reads as human, you get the sentence-level detection back and the text is left alone. Few humanizers offer this as a single call, and it's the cleanest way to avoid rewriting content that doesn't need it.

MCP server. Walter runs an official MCP server at https://mcp-server.walterwrites.ai/mcp, signed in with OAuth, that works with Claude, ChatGPT and Codex. It exposes walter_humanize, walter_detect and walter_batch_humanize. According to Walter's docs, the humanize tool preserves keywords, named entities, URLs and document structure and returns a report showing what was kept, which matters if you're humanizing SEO content.

Agent skills. Walter Skills are 12 ready-made workflows (SEO writing, content refresh, programmatic SEO, newsletters and more) that tell an agent when to humanize, when to detect and how to format the result. They install with one command:

npx skills add walterwritesai/walter-skills

The source is on GitHub at walterwritesai/walter-skills.

Limits and pricing.

Requests must be 50 to 2,000 words.
Synchronous calls are limited to 3 per minute per user; async calls have no time-based limit and are bounded by credits and pending jobs.
API credits are 1 per word for the humanizer, from one shared pool across all of Walter's APIs.
Plans start at $49 a month for 300,000 credits and go up to 25 million. New accounts get 2,000 credits for 5 days, no card required.

Trade-offs. The 2,000-word cap means long documents need to be split, and the sync rate limit is low enough that anything beyond light use should go through async. Both are easy to design around, and the docs are clear about them.

Best for: content platforms, SEO and agency pipelines, and anyone building with AI agents who wants humanization and detection on one account.

4. WriteHuman: Best for Multiple Rewrites per Call

WriteHuman's API is a single, clean endpoint, POST /v1/humanize on api.writehuman.ai, authenticated with a revocable Bearer key (up to five per account).

What sets it apart is the Premium tier. Each call returns three rewrites, each with a human-likeness score from 0 to 1, so your code can pick the best one automatically. You can also set one of seven tones (professional, academic, blog, casual, creative, scientific, technical) per request, and WriteHuman lists 40+ supported languages with auto-detection.

Limits and pricing. Standard is $29 a month for 125,000 words, 2,000 words per call and 40 requests per minute. Premium plans start at $69 a month for 400,000 words, with 4,000 to 6,000 words per call and 120 to 160 requests per minute depending on size. Top-up packs of 100,000 words cost $25 and don't expire. There's also a separate /v1/detect endpoint and a read-only /v1/usage endpoint.

Trade-offs. No published async or webhook mode, no combined detect-and-humanize call, and no MCP server.

Best for: apps that want to offer users a choice of rewrites, or pipelines that auto-select the highest-scoring version.

5. Undetectable AI: Best for Readability Controls

Undetectable AI's humanization API works differently from the others. You submit a document to POST https://humanize.undetectable.ai/submit, get back an ID, and then poll POST /document every 5 to 10 seconds until it's done. There's also a WebSocket mode that streams the result sentence by sentence.

The request parameters are the most detailed in this list. readability (High School to Doctorate, Journalist, Marketing) and purpose (Essay, Article, Marketing Material, Legal Material and others) are required, and you can set strength and choose a model. The docs describe v2 as supporting every language and v11 and v11sr as English-focused models with stronger rewriting. Authentication uses an apikey header, with an option to exchange it for a short-lived token for client-side use.

Limits and pricing. Starter is $29 a month for 72,500 words and Growth is $49 a month for 245,000 words, with pay-as-you-go overage. The default rate limit is 3 requests per second per IP. Webhooks are available on request, and new accounts get 250 word credits to test with. The same account also unlocks detection APIs for text, images, audio and video.

Trade-offs. No synchronous mode, so every integration needs a polling loop or WebSocket handling. No MCP server.

Best for: products that need control over reading level and content type, or live streaming of the rewrite.

6. Phrasly: Best for High-Volume Streaming

Phrasly's business API is built for speed. You call POST /api/v1/humanize with an x-api-key header, and Phrasly says typical requests return in under two seconds, with streaming responses and white-label output. A detection endpoint runs from the same balance.

Limits and pricing. There's one Business plan: $100 a month, which includes $100 in API credits. Humanization costs $0.14 per 1,000 words and detection $0.02 per 1,000. An "Ultra" model is available on request at $0.30 per 1,000 words.

Trade-offs. The $100 monthly minimum makes it a poor fit for small projects, and there's no MCP server or combined detect-and-humanize call.

Best for: established products with steady, high volume that want fast streaming output.

7. QuillBot: Fine for Writers, Not Built for Developers

QuillBot appears on almost every "best AI humanizer" list, so it's worth explaining why it's not a real option here. Its AI Humanizer is part of a writing suite available through the web app, browser extensions, a Word add-in, desktop apps and a mobile keyboard. Its Premium plan costs $8.33 a month billed annually and includes an unlimited Advanced humanizer.

But QuillBot doesn't list a public humanizer API on its humanizer or Premium pages, and there's no MCP server. If you're building something, you can't call it from code. It's a good tool for individual writers, not a component you can integrate.

8. Code: Humanizing Text With Walter's API

Get a key from the Walter Writes developer portal and select the Humanizer scope (and AI Detector if you'll use section 9). Keep the key on your server.

A synchronous call with curl:

curl -X POST https://developer-portal.walterwrites.ai/api/humanizer/ \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $WALTER_API_KEY" \
  -d '{"content": "Your AI-generated draft of at least 50 words goes here..."}'

The response includes the humanized text in result, the input word_count and your credits_remaining.

For anything beyond occasional use, go async. Here's a Node.js example (Node 18+, no dependencies) that submits a job with a webhook and verifies the callback:

// humanize.js
import express from "express";
import { timingSafeEqual } from "node:crypto";

const BASE = "https://developer-portal.walterwrites.ai/api";
const KEY = process.env.WALTER_API_KEY;
const WEBHOOK_SECRET = process.env.WALTER_WEBHOOK_SECRET;

export async function submitHumanizeJob(content) {
  const res = await fetch(`${BASE}/humanizer/`, {
    method: "POST",
    headers: { "Content-Type": "application/json", "X-API-Key": KEY },
    body: JSON.stringify({
      content,
      callback_url: "https://your-app.example.com/webhooks/walter",
      webhook_secret: WEBHOOK_SECRET,
      poll: true, // also allow polling as a fallback
    }),
  });
  const body = await res.json();
  if (res.status !== 202) throw new Error(`${res.status}: ${body.error ?? "unexpected response"}`);
  return body.task_id; // store this with your document
}

function safeEqual(a = "", b = "") {
  const x = Buffer.from(a);
  const y = Buffer.from(b);
  return x.length === y.length && timingSafeEqual(x, y);
}

const app = express();
app.use(express.json({ limit: "2mb" }));

app.post("/webhooks/walter", (req, res) => {
  if (!safeEqual(req.get("X-Webhook-Secret"), WEBHOOK_SECRET)) {
    return res.sendStatus(401);
  }
  const { task_id, status, result } = req.body;
  if (status === "success") {
    // save `result` against the document you stored with task_id
    console.log(task_id, result.slice(0, 80));
  }
  res.sendStatus(200);
});

app.listen(3000);

The callback_url has to be publicly reachable. Walter blocks private and internal addresses, so use a tunnel in local development. Because the request also sets poll: true, you can fall back to GET /api/jobs/{task_id}/ if a webhook is ever missed.

9. Code: Detect First, Humanize Only When Needed

Rewriting text that already reads as human wastes credits and can make good writing worse. Walter's detect-and-humanize endpoint handles the decision for you. This Python example sends a draft with a threshold and handles both outcomes:

import os
import requests

BASE = "https://developer-portal.walterwrites.ai/api"
HEADERS = {
    "Content-Type": "application/json",
    "X-API-Key": os.environ["WALTER_API_KEY"],  # needs humanizer + ai_detector scopes
}


def clean_draft(text: str, threshold: float = 0.5) -> dict:
    resp = requests.post(
        f"{BASE}/detect-and-humanize/",
        json={"content": text, "detection_threshold": threshold},
        headers=HEADERS,
        timeout=120,
    )
    resp.raise_for_status()
    data = resp.json()

    if data.get("humanized"):
        return {
            "text": data["humanized_content"],
            "ai_score_before": data["ai_score"],
            "changed": True,
        }

    # Below threshold: original text comes back untouched, with sentence-level scores
    flagged = [s["text"] for s in data.get("detection_items", []) if s["prediction"] == "ai-generated"]
    return {
        "text": data["content"],
        "ai_score_before": data["ai_score"],
        "changed": False,
        "sentences_to_review": flagged,
    }


if __name__ == "__main__":
    draft = open("draft.md", encoding="utf-8").read()
    out = clean_draft(draft, threshold=0.5)
    print(f"AI score {out['ai_score_before']:.2f}, changed: {out['changed']}")

Pick the threshold based on your content. A higher threshold rewrites less often and leaves more of the original voice intact. A lower one rewrites more aggressively.

10. Using a Humanizer Inside AI Agents With MCP

The newest way to use a humanizer isn't an HTTP call at all. With an MCP server, an AI assistant can draft, humanize and score text in one conversation, deciding on its own when to call each tool.

Walter is the only humanizer in this comparison with an official MCP server. In Claude Code, adding it is one command, followed by /mcp to sign in:

claude mcp add walter-writes https://mcp-server.walterwrites.ai/mcp -t http

In Cursor, add it to .cursor/mcp.json:

{
  "mcpServers": {
    "walter-writes": {
      "url": "https://mcp-server.walterwrites.ai/mcp"
    }
  }
}

Then a prompt like this runs the whole loop:

Use the walter-writes MCP server. Run walter_detect on draft.md, humanize any
section scoring above 30 with walter_humanize while keeping the keywords
"AI humanizer API" and "MCP" unchanged, then run walter_detect again and
show me the before and after scores.

Pair the MCP server with Walter Skills (npx skills add walterwritesai/walter-skills) and the agent also knows the workflow, such as when to use a lighter or stronger rewrite and how to report results.

11. How to Choose

You want one platform for humanizing, detection, agents and webhooks: Walter Writes AI.
You want users to choose between several rewrites, or auto-pick the best one: WriteHuman Premium.
You need reading-level and content-type controls, or live streaming: Undetectable AI.
You're at steady high volume and want sub-two-second streaming responses: Phrasly.
You're an individual writer, not a developer: QuillBot is fine, but there's nothing to integrate.

12. Production Tips That Apply to Every Humanizer

Keep keys on the server. Never ship an API key in a browser or mobile app. Use environment variables or a secrets manager, and one key per environment.
Chunk long documents on paragraph or section boundaries to stay under each vendor's per-request limit, then reassemble in order.
Go async for anything long. Sync calls are convenient but tie up a request and hit rate limits sooner.
Protect what must not change. Product names, URLs, code snippets and target keywords can drift in a rewrite. Use a tool that preserves them, or check them after.
Measure, don't assume. Score text before and after with a detector, and keep a human review step for anything published under your name.
Retry carefully. Retry 429 and 5xx errors with backoff. Don't retry 400, 401 or 403; those mean the request itself needs fixing.
Respect the rules of where the text goes. Schools, publishers and platforms have their own AI policies, and some jurisdictions have disclosure rules. A humanizer improves how text reads; it doesn't change what's allowed.

13. Conclusion

For a writer, the best AI humanizer is the one whose output reads best. For a developer, it's the one that fits cleanly into what you're building, and that's where the differences between these tools get big.

Walter Writes AI comes out on top because it's the most complete: a REST API with sync, polling and webhooks, a detect-and-humanize call that avoids unnecessary rewrites, an official MCP server for Claude, ChatGPT and Codex, and installable agent skills, all on one account. WriteHuman, Undetectable AI and Phrasly each win a narrower case, and QuillBot is a writer's tool rather than a developer's.

Start with the free trials, run your own content through each one, and choose the integration you'd be happy maintaining a year from now.

14. FAQs

What is the best AI humanizer in 2026?

For developers, Walter Writes AI. It combines a humanizer API with sync, polling and webhook modes, a detect-and-humanize endpoint, an official MCP server and installable agent skills. WriteHuman, Undetectable AI and Phrasly are solid alternatives for narrower needs.

Which AI humanizers have an API?

Walter Writes AI, WriteHuman, Undetectable AI and Phrasly all publish humanizer APIs. QuillBot doesn't list a public humanizer API.

Is there an AI humanizer with an MCP server?

Yes. Walter Writes AI runs an official MCP server at https://mcp-server.walterwrites.ai/mcp with OAuth sign-in, exposing walter_humanize, walter_detect and walter_batch_humanize to Claude, ChatGPT and Codex.

How much does an AI humanizer API cost?

Entry plans in this comparison range from $29 a month (WriteHuman and Undetectable AI) to $49 (Walter Writes AI) and $100 (Phrasly, including $100 in credits). Pricing is per word or per credit, and limits per request and per minute vary by plan.

Is there a free AI humanizer API?

Several offer free trials. Walter Writes AI gives new accounts 2,000 API credits for 5 days, and Undetectable AI gives 250 word credits.

What's the maximum length for one request?

It depends on the vendor. Walter Writes AI accepts 50 to 2,000 words per request, WriteHuman 2,000 to 6,000 depending on plan, and Phrasly 20 to 5,000. Longer documents should be split into chunks.

Can a humanizer keep my SEO keywords?

Some can. Walter's MCP humanize tool is documented to preserve keywords, named entities, URLs and document structure, and it returns a report of what was kept. With other tools, check important terms after rewriting.

How do I install Walter Skills?

Run npx skills add walterwritesai/walter-skills in your project. It installs 12 agent workflows from the walterwritesai/walter-skills repository. Connect the Walter MCP server too, so the agent can actually run the humanize and detect steps.

Plagiarism Checker API: Adding Originality Checks to Your App

Mohab Abdelkarim — Tue, 27 Oct 2026 19:29:23 +0000

One POST request gets you a score, a verdict, the sources that matched, and the exact passages to highlight. Here's how to build it into a real product.

If your app accepts writing from users, sooner or later someone asks whether that writing is original. It might be an LMS that takes essays, a CMS where freelancers submit articles, a marketplace for guest posts, or an internal tool where an editor reviews drafts before they go live.

Building plagiarism detection yourself means crawling and indexing the web, fingerprinting text, and matching passages at scale. That's a company, not a feature. A plagiarism checker API lets you skip all of it: you send text, and you get back a score, the matching sources, and the passages that matched.

This guide uses the Proofademic API, which added a plagiarism checker alongside its AI detector in July 2026. Everything below comes from Proofademic's official API documentation, with working examples in curl, Node.js and Python, plus the production details that usually get skipped: idempotent retries, rendering highlights, error handling and cost.

What a Plagiarism Checker API Gives You
Getting an API Key
Your First Scan
Understanding the Response
Node.js: A Reusable Client
Python: Safe Retries With Idempotency Keys
Rendering Highlights in Your UI
Handling Errors
Pairing Plagiarism and AI Detection
Pricing, Limits and Cost Planning
Already Using Walter's API?
Production Checklist
Conclusion
FAQs

1. What a Plagiarism Checker API Gives You

Proofademic's plagiarism endpoint scans text against web sources and returns:

a plagiarism score from 0 (original) to 1 (fully plagiarized)
a verdict label you can show directly or map to your own UI
the matched sources, strongest first, with URL, title, domain and how much of your text each one covers
highlights, as character ranges into the text you submitted, each with a severity and a pointer to its source

That last part matters more than it sounds. A score on its own tells a user "something is wrong." Offsets let you show them exactly which sentences matched and where they came from, which is what a reviewer actually needs.

2. Getting an API Key

Click Create API Key.
Give it a descriptive name, such as production-cms.
Under Model Access, select Plagiarism Checker. Add AI Detector too if you plan to run both checks (section 9).
Choose an expiration: Never, 30, 60 or 90 days.
Copy the key immediately. It's shown only once.

Keys start with prfd_, which makes them easy to spot in config files and secret scanners. A key only works for the scopes you selected. Calling an endpoint outside its scopes returns 403.

New accounts get a free trial with 2,000 credits for 5 days, no credit card required.

Store the key server-side:

export PROOFADEMIC_API_KEY="prfd_..."

Never ship it to a browser or mobile client. Your frontend should call your backend, and your backend should call Proofademic.

3. Your First Scan

The endpoint is a single POST:

POST https://developer-portal.proofademic.ai/api/plagiarism/scan/

The request body has one field, content:

curl -X POST https://developer-portal.proofademic.ai/api/plagiarism/scan/ \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $PROOFADEMIC_API_KEY" \
  -d '{
    "content": "The Eiffel Tower is a wrought-iron lattice tower on the Champ de Mars in Paris, France. It is named after the engineer Gustave Eiffel, whose company designed and built the tower from 1887 to 1889."
  }'

Limits, per the docs:

Limit	Value
Minimum length	50 characters
Maximum length	25,000 words
Processing	Synchronous only
Cost	Flat 2 credits per scan

Word counts are script-aware: whitespace-separated words for most languages, one word per character for CJK scripts.

4. Understanding the Response

Here's the response from the docs for the request above:

{
  "status": "success",
  "scan_id": "scan_YYbWPwT4JHUabc12",
  "plagiarism_score": 0.99,
  "verdict": "severe_plagiarism",
  "summary": "Nearly all of the submitted text matches known sources.",
  "sources": [
    {
      "url": "https://en.wikipedia.org/wiki/Eiffel_Tower",
      "title": "Eiffel Tower - Wikipedia",
      "domain": "en.wikipedia.org",
      "similarity_score": 0.97,
      "matched_word_count": 34,
      "matched_percentage": 0.92,
      "matches": [
        { "submitted_range": { "start": 0, "end": 133 }, "similarity": 0.97 }
      ]
    }
  ],
  "highlights": [
    { "start": 0, "end": 133, "severity": "high", "source_index": 0 }
  ],
  "stats": {
    "word_count": 37,
    "input_chars": 196,
    "sentence_count": 2,
    "sources_checked": 24,
    "processing_time_ms": 3100
  },
  "execution_time": 3.4,
  "word_count": 37,
  "credits_remaining": 1998,
  "user": { "id": 12345 }
}

The fields you'll use most:

Field	What it's for
`plagiarism_score`	Overall result, 0.0 to 1.0
`verdict`	Ready-made label for the score
`summary`	A human-readable sentence you can show as-is
`sources[]`	Matched sources, strongest first
`sources[].matched_percentage`	Share of the submitted text this source covers
`highlights[]`	Character ranges to mark in the text
`highlights[].source_index`	Which entry in `sources[]` the passage matched
`scan_id`	Store it. Include it in support requests
`credits_remaining`	Your balance after this call

Verdicts map to score ranges like this:

Score	Verdict
below 0.05	`original`
0.05 to 0.15	`minor_similarity`
0.15 to 0.40	`moderate_plagiarism`
0.40 to 0.70	`significant_plagiarism`
0.70 and above	`severe_plagiarism`

Highlight severity is based on how closely each passage matches its source: high at 0.85 or above, medium at 0.70 or above, and low below that.

A note on interpretation: a minor_similarity result is normal for most real writing. Quotes, common phrases, names and standard definitions all overlap with something on the web. Treat the verdict as a starting point for review, not an automatic accusation, and show users the matched passages so they can judge for themselves.

5. Node.js: A Reusable Client

This uses the built-in fetch in Node 18 and later, with no dependencies.

// plagiarism.js
import { randomUUID } from "node:crypto";

const BASE_URL = "https://developer-portal.proofademic.ai/api";
const API_KEY = process.env.PROOFADEMIC_API_KEY;

export class PlagiarismApiError extends Error {
  constructor(status, body) {
    super(body?.error ?? `HTTP ${status}`);
    this.status = status;
    this.code = body?.code;
    this.details = body?.details;
  }
}

export async function scanForPlagiarism(content, { idempotencyKey = randomUUID() } = {}) {
  if (content.length < 50) {
    throw new Error("Text must be at least 50 characters to scan.");
  }

  const res = await fetch(`${BASE_URL}/plagiarism/scan/`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "X-API-Key": API_KEY,
      "Idempotency-Key": idempotencyKey,
    },
    body: JSON.stringify({ content }),
  });

  const body = await res.json().catch(() => null);
  if (!res.ok) throw new PlagiarismApiError(res.status, body);
  return body;
}

And a small Express route that your frontend can call:

// server.js
import express from "express";
import { scanForPlagiarism, PlagiarismApiError } from "./plagiarism.js";

const app = express();
app.use(express.json({ limit: "1mb" }));

app.post("/api/originality-check", async (req, res) => {
  try {
    const result = await scanForPlagiarism(req.body.text);
    res.json({
      score: result.plagiarism_score,
      verdict: result.verdict,
      summary: result.summary,
      sources: result.sources.map(({ url, title, domain, matched_percentage }) => ({
        url, title, domain, matched_percentage,
      })),
      highlights: result.highlights,
      scanId: result.scan_id,
    });
  } catch (err) {
    if (err instanceof PlagiarismApiError) {
      return res.status(err.status === 400 ? 400 : 502).json({ error: err.message, code: err.code });
    }
    res.status(400).json({ error: err.message });
  }
});

app.listen(3000);

The route returns only what the frontend needs. It doesn't forward credits_remaining or user.id, which are account details your users don't need to see.

6. Python: Safe Retries With Idempotency Keys

Because each scan is billed, a naive retry after a timeout can charge you twice: the first request may have succeeded even though your client never saw the response.

The API handles this with an Idempotency-Key header (any string up to 255 characters). Per the docs:

Repeating the same key with the same text within 5 minutes returns the original response. Nothing is re-scanned and nothing is charged.
Repeating the same key with different text returns 409 idempotency_key_reuse, so a stale key can never return results for the wrong text.

The rule that follows: generate the key once per logical scan, and reuse it for every retry of that scan.

import os
import time
import uuid
import requests

BASE_URL = "https://developer-portal.proofademic.ai/api"
API_KEY = os.environ["PROOFADEMIC_API_KEY"]

RETRYABLE = {429, 500, 503}


def scan_for_plagiarism(content: str, max_attempts: int = 4) -> dict:
    idempotency_key = str(uuid.uuid4())  # one key for every retry of this scan
    headers = {
        "Content-Type": "application/json",
        "X-API-Key": API_KEY,
        "Idempotency-Key": idempotency_key,
    }

    for attempt in range(1, max_attempts + 1):
        try:
            resp = requests.post(
                f"{BASE_URL}/plagiarism/scan/",
                json={"content": content},
                headers=headers,
                timeout=60,
            )
        except requests.RequestException:
            if attempt == max_attempts:
                raise
            time.sleep(2 ** attempt)
            continue

        if resp.status_code == 200:
            return resp.json()

        if resp.status_code in RETRYABLE and attempt < max_attempts:
            retry_after = resp.headers.get("Retry-After")
            time.sleep(int(retry_after) if retry_after else 2 ** attempt)
            continue

        body = resp.json() if resp.content else {}
        raise RuntimeError(f"{resp.status_code} {body.get('code')}: {body.get('error')}")

    raise RuntimeError("Plagiarism scan failed after retries")


if __name__ == "__main__":
    result = scan_for_plagiarism(open("draft.txt", encoding="utf-8").read())
    print(result["verdict"], result["plagiarism_score"])
    for src in result["sources"][:3]:
        print(f"- {src['domain']}: {src['matched_percentage']:.0%} of text")

Two details make this safe. The key is created outside the retry loop, so every attempt shares it. And retries only happen for 429 and 5xx errors. The docs are explicit that 400, 401 and 403 mean something in the request needs fixing, so retrying them just wastes time.

7. Rendering Highlights in Your UI

Each highlight is a { start, end } range into the text exactly as you submitted it. That's why it's worth storing the submitted text alongside the result: if a user edits the draft afterward, old offsets no longer line up.

Here's a framework-free function that turns the response into safe HTML with <mark> tags:

function escapeHtml(s) {
  return s.replace(/[&<>"']/g, (c) => ({
    "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;",
  })[c]);
}

export function renderHighlights(text, highlights, sources) {
  const sorted = [...highlights].sort((a, b) => a.start - b.start);
  let html = "";
  let cursor = 0;

  for (const h of sorted) {
    if (h.start < cursor) continue; // skip overlaps
    const source = sources[h.source_index];
    html += escapeHtml(text.slice(cursor, h.start));
    html += `<mark class="match match--${h.severity}" title="${escapeHtml(
      source ? `${source.title} (${source.domain})` : "Matched source"
    )}">${escapeHtml(text.slice(h.start, h.end))}</mark>`;
    cursor = h.end;
  }

  html += escapeHtml(text.slice(cursor));
  return html;
}

.match--high   { background: #fecaca; }
.match--medium { background: #fde68a; }
.match--low    { background: #e5e7eb; }

Escape both the user text and the source titles. Both come from outside your app, and rendering either one as raw HTML is an easy XSS hole.

One edge case worth testing: the docs say offsets refer to the text as submitted, but they don't specify whether they count UTF-16 code units (how JavaScript indexes strings) or Unicode code points. For plain text it makes no difference. If your users paste emoji or other characters outside the Basic Multilingual Plane, run a test scan with one and confirm the highlights still line up.

8. Handling Errors

All errors return JSON with an error message, and most include a machine-readable code and a details object. Branch on code, not on the message string.

Status	Code	What to do
400	`invalid_payload`	Missing `content` or under 50 characters. Validate before sending
400	`insufficient_content`	No complete sentences to scan. Ask the user for more text
400	`max_words_exceeded`	Over 25,000 words. `details` has `limit` and `actual`. Split the document
400	`invalid_idempotency_key`	Key longer than 255 characters
401	none	Missing, invalid or expired API key
403	`insufficient_credits`	Not enough credits. `details` has `credits` and `required`
403	`credits_exhausted` / `trial_expired`	Plan or trial is used up
409	`idempotency_key_reuse`	Same key sent with different text. Generate a new key
429	none	Rate limited. Wait for the `Retry-After` header
503	`service_unavailable`	Temporary. Retry after `Retry-After` if present
503	`service_error`	Scan failed. Credits were refunded automatically

If you need to scan something longer than 25,000 words, split it on paragraph or section boundaries, scan each part, and keep track of each part's starting offset so you can shift its highlights back into the full document.

9. Pairing Plagiarism and AI Detection

Plagiarism and AI-generated text are different problems. A plagiarism scan asks whether this text matches something that already exists. An AI detector asks whether this text was likely written by a model. Fresh AI output usually won't match any web source, so a plagiarism check alone won't flag it, and copied human writing won't look like AI.

The same Proofademic key can call both if you gave it both scopes. The AI detector lives at POST /api/detector/ and returns an ai_score from 0 to 1 plus a per-sentence breakdown. Running both checks in parallel gives a reviewer the full picture:

const BASE_URL = "https://developer-portal.proofademic.ai/api";

async function post(path, body) {
  const res = await fetch(`${BASE_URL}${path}`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "X-API-Key": process.env.PROOFADEMIC_API_KEY,
    },
    body: JSON.stringify(body),
  });
  const json = await res.json();
  if (!res.ok) throw new Error(`${path}: ${json.code ?? res.status} ${json.error ?? ""}`);
  return json;
}

export async function originalityReport(text) {
  const [plagiarism, ai] = await Promise.all([
    post("/plagiarism/scan/", { content: text }),
    post("/detector/", { content: text }),
  ]);

  return {
    plagiarism: { score: plagiarism.plagiarism_score, verdict: plagiarism.verdict },
    ai: { score: ai.ai_score, result: ai.result },
    needsReview:
      plagiarism.plagiarism_score >= 0.15 || ai.ai_score > 0.7,
  };
}

The thresholds in needsReview are an example, not a recommendation. Pick yours based on what a false positive costs in your product. For anything with real consequences, such as grades or contracts, route flagged work to a human instead of acting on scores automatically.

Keep the cost difference in mind too. A plagiarism scan is a flat 2 credits, while the AI detector charges 1 credit per word. A 2,000-word essay costs 2 credits to scan for plagiarism and 2,000 credits for AI detection.

For long texts, the detector also supports async processing with polling or a webhook (poll: true or callback_url). The plagiarism endpoint is synchronous only, so give its HTTP call a generous timeout.

10. Pricing, Limits and Cost Planning

Proofademic uses one shared pool of credits across all its APIs. Plagiarism scans are a flat 2 credits regardless of length, and failed scans are refunded automatically.

Plan	Credits per month	Price per month
300K	300,000	$49
1M	1,000,000	$129
2M	2,000,000	$229
5M	5,000,000	$479
12M	12,000,000	$899
25M	25,000,000	$1,699

Credits reset monthly and don't roll over. The free trial includes 2,000 credits for 5 days.

Because the price is per scan rather than per word, the math is simple. If you only use the plagiarism checker, the 300K plan covers up to 150,000 scans a month. If you also run the AI detector, budget for that by word count, since it will dominate your spend.

Rate limits from the error-handling docs:

Scope	Default limit
Per IP (burst)	60 requests per minute
Per IP (sustained)	3,000 requests per hour
Per user (global)	60 requests per minute
AI detector (sync)	10 requests per minute

The docs note that limits may be higher on larger plans. If you're scanning a backlog, put the work in a queue and keep under 60 requests a minute rather than firing everything at once.

The number of active API keys also depends on your plan: 1 on the trial, 5 on the 300K and 1M plans, 10 on 2M and 5M, and 25 on 12M and 25M.

11. Already Using Walter's API?

If your app already uses Walter Writes AI for humanizing or AI detection, you don't need a second vendor for plagiarism. Walter's API has the same plagiarism endpoint, POST /api/plagiarism/scan/, with the same request body, response fields, verdicts, idempotency behavior and flat 2-credit price. The differences are the base URL (https://developer-portal.walterwrites.ai/api) and the key, which needs the plagiarism checker scope.

So pick based on what else your app does. Proofademic fits products built around academic integrity and AI detection. Walter fits products that already humanize or rewrite content. The code in this post works with either one by changing the base URL and key.

12. Production Checklist

Keep the API key on the server and in environment variables or a secrets manager.
Create one key per environment, and give each key only the scopes it needs.
Validate input before calling: at least 50 characters, at most 25,000 words.
Send an Idempotency-Key and reuse it across retries of the same scan.
Retry only on 429 and 5xx, and honor Retry-After.
Store scan_id, the verdict, the score and the exact submitted text together.
Escape user text and source titles when rendering highlights.
Watch credits_remaining and alert before you run out.
Show matched sources to users instead of only a score, and send borderline results to a person for review.

13. Conclusion

Adding originality checks used to mean picking between an expensive enterprise integration and building something weak in-house. With a plagiarism checker API, it's one authenticated POST request and some careful handling of the response.

The parts that make it production-ready are small: idempotency keys so retries never double-charge, offset-based highlights so users can see what matched, and clear error handling around the limits. Add AI detection next to it, and your app can answer both questions reviewers ask now: was this copied, and was this written by a model?

14. FAQs

What does a plagiarism checker API do?
It compares submitted text against existing sources and returns a similarity score, the sources that matched and the passages that overlap. Proofademic's API returns a 0 to 1 plagiarism_score, a verdict, matched sources with URLs and character-offset highlights.

Does Proofademic have a plagiarism checker API?
Yes. Proofademic launched its plagiarism checker and public API portal in July 2026. The endpoint is POST /api/plagiarism/scan/ on https://developer-portal.proofademic.ai/api, authenticated with an X-API-Key header that has the Plagiarism Checker scope.

Does Walter Writes AI have a plagiarism API?
Yes. Walter's API offers the same POST /api/plagiarism/scan/ endpoint with the same request and response format, at https://developer-portal.walterwrites.ai/api.

How much does a plagiarism scan cost?
A flat 2 credits per scan, regardless of length, up to 25,000 words. Failed scans are refunded automatically. Plans start at $49 a month for 300,000 credits, and the free trial includes 2,000 credits for 5 days.

What's the maximum text length?
25,000 words per scan, with a minimum of 50 characters. Longer documents need to be split into parts.

Is the plagiarism endpoint synchronous?
Yes, it's synchronous only. The response comes back in the same HTTP request, so set a generous timeout on your client.

How do I avoid being charged twice when retrying?
Send an Idempotency-Key header and reuse the same key for every retry of the same scan. Within 5 minutes, a repeat with the same key and text returns the original response without charging again.

Does a plagiarism check catch AI-generated text?
Not reliably. Fresh AI output usually doesn't match existing web pages. Use an AI detector, such as Proofademic's /api/detector/ endpoint, alongside the plagiarism check.

Walter MCP vs Walter API: Which One Should You Use?

Mohab Abdelkarim — Fri, 23 Oct 2026 13:52:38 +0000

Walter Writes AI gives developers two ways to use its humanizer and AI detector. The MCP server plugs Walter into AI assistants like Claude, ChatGPT, and Claude Code, so the assistant can call Walter's tools in the middle of a conversation. The REST API gives your own code direct HTTP access to Walter's services, with API keys, async jobs, and webhooks.

They sound like two doors into the same room, but they're built for different jobs. They expose different capabilities, authenticate differently, and are limited differently. This post walks through both using Walter's official documentation, with code for the API and setup and prompts for MCP, so you can pick the right one for what you're building.

What Each One Is
Side by Side
When to Use Walter MCP
When to Use the Walter API
The Same Workflow, Both Ways
API Details That Matter in Production
Pricing and Limits
Using Both Together
Decision Guide
FAQs

1. What Each One Is

Walter MCP is a remote Model Context Protocol server at https://mcp-server.walterwrites.ai/mcp. Connect it to an MCP-compatible assistant and the assistant gets three tools:

walter_humanize rewrites AI-generated text to read naturally, with adjustable rewrite strength. It preserves keywords, named entities, URLs, and document structure, and returns a preservation report.
walter_detect returns a 0 to 100 score, a verdict (likely human, unclear, or likely AI), and high-risk spans, with optional explanations.
walter_batch_humanize processes several texts in one run with shared defaults and per-item overrides. If one item fails, the rest still return, with per-item reports and a batch summary.

You don't call these tools yourself. You ask the assistant in plain language, and it decides when and how to call them.

Walter API is a REST API at https://developer-portal.walterwrites.ai/api. Your code sends JSON over HTTPS with an API key. It covers more services than the MCP server:

POST /api/humanizer/
POST /api/detector/
POST /api/detect-and-humanize/
POST /api/plagiarism/scan/
POST /api/grammar/correct/
POST /api/voice-detector/detect/
POST /api/image-detector/predict/
GET /api/jobs/{task_id}/ for async results

2. Side by Side

Who calls it

MCP: an AI assistant, on your behalf, from natural-language instructions
API: your code, with explicit HTTP requests

Where it runs

MCP: Claude on the web, desktop, and mobile, Claude Code, ChatGPT, Gemini CLI, and Open WebUI
API: anywhere you can make an HTTPS request: backends, scripts, CI jobs, serverless functions

Authentication

MCP: OAuth. You sign in to your Walter account once and approve access. No key to store.
API: an X-API-Key header, with scopes chosen per key (Humanizer, AI Detector, Image Detector, or a combination)

Capabilities

MCP: humanize, detect, and batch humanize
API: humanize, detect, detect-and-humanize, plagiarism, grammar, voice detection, and image detection

Humanizer controls

MCP: documented keyword, entity, URL, and structure preservation, adjustable rewrite strength, and a preservation report
API: the humanizer reference documents content plus async options (poll, callback_url, webhook_secret)

Detection output

MCP: score from 0 to 100, verdict, high-risk spans
API: ai_score from 0.0 to 1.0, a binary result of ai or human, and per-sentence items with their own scores

Async and webhooks

MCP: not applicable; the assistant waits for each tool call
API: polling and webhooks on the humanizer, detector, and detect-and-humanize endpoints

Limits and billing

MCP: runs under your Walter workspace's plan, which sets limits such as daily word volume and batch size
API: a shared credit pool, generally 1 credit per word for text endpoints, plus rate limits and a pending-jobs cap

Best for

MCP: interactive editing, content workflows inside an assistant, and agentic file work in Claude Code
API: products, pipelines, automation, and anything that needs repeatable, programmatic control

3. When to Use Walter MCP

Choose MCP when a person, or an AI agent working for one, is in the loop.

You draft in an AI assistant. If your content already lives in Claude or ChatGPT, MCP removes the copy-paste loop. You ask the assistant to check and humanize, and the results come back into the same conversation.

You want instruction-level control without writing code. Because the assistant orchestrates the tools, you can describe a whole workflow in one prompt: detect first, humanize only the flagged spans, keep these exact keywords, then re-check.

You work with files in Claude Code. In Claude Code, the assistant can read drafts from your repo, run Walter on them, and write results back, which makes MCP surprisingly capable for batch content work without a custom script.

You want keyword preservation out of the box. Walter's MCP documentation explicitly describes walter_humanize as preserving keywords, entities, URLs, and structure, with a report showing what it kept.

Setup in Claude Code is one command:

claude mcp add walter-writes https://mcp-server.walterwrites.ai/mcp -t http --scope user

Then run /mcp, select walter-writes, choose Authenticate, and sign in. For Claude on the web or desktop, ChatGPT, and the other supported clients, add a custom connector with the same URL and sign in when prompted. Walter's docs have a guide for each.

Add Walter Skills for repeatable workflows. Walter publishes 12 free, MIT-licensed skill files that tell the assistant how to run specific workflows, such as SEO writing, agency QC, local SEO, and programmatic SEO:

npx skills add walterwritesai/walter-skills

The repo is at github.com/walterwritesai/walter-skills. If you get stuck on setup, waltermcp.com is a community-run guide, not an official Walter resource, so treat Walter's own docs as the source of truth.

4. When to Use the Walter API

Choose the API when software is in the loop.

You're building a product. If Walter's humanizer or detector is a feature inside your app, such as a "check for AI" button or an automatic rewrite step, you need the API. MCP is for assistants, not end-user product features.

You need services beyond humanize and detect. Plagiarism scanning, grammar correction, voice detection, and image detection are API-only.

You need deterministic, testable behavior. An API call does exactly what your code says, with no assistant interpreting your instructions. That's what you want in CI, scheduled jobs, and production pipelines.

You need scale and async. The API supports async processing with polling and webhooks, so you can submit many jobs without holding connections open, subject to your plan's pending-jobs limit.

You need a server-side threshold. The detect-and-humanize endpoint scores text and only humanizes it if the AI score is above a detection_threshold you set, in a single request.

Getting a key: create one on the API Keys page of the Developer Portal at platform.walterwrites.ai/api-keys, choose its scopes, and copy it immediately, because it's shown only once. Walter's guidance is to keep keys out of client-side code, public repos, and logs, store them in environment variables or a secrets manager, use separate keys for development and production, and revoke keys you no longer need.

5. The Same Workflow, Both Ways

The workflow: check a draft, and only humanize it if it looks AI-generated.

With MCP

In Claude, Claude Code, or ChatGPT with Walter connected:

Use the walter-writes MCP server.
1. Run walter_detect on the draft below with explanations on.
2. If it's flagged, humanize only the high-risk spans with walter_humanize,
   preserving "Acme Sync Pro", "$49/month", and every URL.
3. Run walter_detect again and give me the final text, both scores,
   and the preservation report.

[draft]

No code, and the assistant handles sequencing. The trade-off is that the assistant interprets your instructions, so it's worth checking the tool calls it makes the first few times.

With the API

The detect-and-humanize endpoint does the conditional step on Walter's side:

import os
import requests

BASE = "https://developer-portal.walterwrites.ai/api"
HEADERS = {
    "Content-Type": "application/json",
    "X-API-Key": os.environ["WALTER_API_KEY"],  # key needs humanizer + ai_detector scopes
}

def check_and_fix(text: str, threshold: float = 0.5) -> dict:
    resp = requests.post(
        f"{BASE}/detect-and-humanize/",
        headers=HEADERS,
        json={"content": text, "detection_threshold": threshold},
        timeout=120,
    )
    resp.raise_for_status()
    data = resp.json()

    if data.get("humanized"):
        final = data["humanized_content"]
    else:
        final = data["content"]  # unchanged; per-sentence scores in data["detection_items"]

    return {
        "ai_score": data["ai_score"],
        "needs_humanization": data["needs_humanization"],
        "text": final,
    }

Fully deterministic, easy to test, and easy to drop into a backend. The trade-off is that you write and maintain the code, and the humanizer API reference documents only the content field and async options, so if you need specific phrases kept, plan to verify them in your own code after the call.

6. API Details That Matter in Production

Word limits. The humanizer accepts 50 to 2,000 words per request. Requests outside that range return 400 before any credits are charged.

Sync rate limits. By default, sync humanizer calls are limited to 3 requests per minute and sync detector calls to 10 per minute, alongside per-user and per-IP limits. Limits may vary by plan.

Use async for volume. Async requests aren't subject to the per-minute limit. They're constrained by credits and a pending-jobs cap that depends on your plan, ranging from 2 pending jobs on the trial to 50 on the largest plan. Add poll: true, a callback_url, or both:

import time

def humanize_async(text: str) -> str:
    resp = requests.post(
        f"{BASE}/humanizer/",
        headers=HEADERS,
        json={"content": text, "poll": True},
        timeout=30,
    )
    resp.raise_for_status()  # expect 202 Accepted
    task_id = resp.json()["task_id"]

    wait = 2  # Walter's recommended schedule: start at 2s, double, cap at 30s
    while True:
        time.sleep(wait)
        job = requests.get(f"{BASE}/jobs/{task_id}/", headers=HEADERS, timeout=30)
        job.raise_for_status()
        data = job.json()
        if data["status"] == "success":
            return data["result"]
        if data["status"] == "failed":
            raise RuntimeError(data.get("error"))  # credits are refunded on failure
        wait = min(wait * 2, 30)

Results expire after one hour, after which the jobs endpoint returns 404, so fetch them promptly.

Webhooks. With a callback_url, Walter POSTs the same JSON as the polling response when the job completes and retries failed deliveries up to 3 times with exponential backoff. The URL must be publicly routable. If you set a webhook_secret, verify it on arrival:

import hmac
import os
from flask import Flask, request, abort

app = Flask(__name__)
SECRET = os.environ["WALTER_WEBHOOK_SECRET"]

@app.post("/walter-webhook")
def walter_webhook():
    received = request.headers.get("X-Webhook-Secret", "")
    if not hmac.compare_digest(received, SECRET):
        abort(401)
    payload = request.get_json()
    # payload["task_id"], payload["status"], payload["result"], ...
    return "", 204

Errors and retries. Use the code field rather than the error string for programmatic handling. Retry 429 and 5xx errors with exponential backoff, and respect the Retry-After header on rate limits. Don't retry 400, 401, or 403; fix the request, key, or account state first. Useful codes to handle explicitly include min_words_not_met, max_words_exceeded, insufficient_credits, credits_exhausted, and too_many_pending_jobs.

Reading detector scores. The detector returns ai_score from 0.0 to 1.0 and a binary result that's ai above 0.5. Walter's docs describe 0.0 to 0.3 as human with high confidence, 0.3 to 0.5 as likely human, 0.5 to 0.7 as likely AI, and 0.7 to 1.0 as AI-generated with high confidence. The per-sentence items array is what you want if you're highlighting flagged sentences in a UI.

7. Pricing and Limits

API credits. The API uses a single shared credit pool across Walter's services. Most text endpoints cost 1 credit per word of input, plagiarism scans cost a flat 2 credits, voice detection costs 10 credits per second of audio, and image detection is priced by resolution with a minimum of 6 credits. Failed requests are refunded automatically. Credits reset each billing cycle and don't roll over. Published monthly plans:

300K credits: $49
1M credits: $129
2M credits: $229
5M credits: $479
12M credits: $899
25M credits: $1,699

New accounts get a free trial of 2,000 credits, usable for 5 days, with no credit card required.

MCP limits. The MCP server runs under your Walter workspace's plan. Walter's documentation says availability and limits depend on the plan, including daily word volume and the number of items allowed per batch, and that workspace admins can control usage. Walter's docs don't state whether MCP usage and API credits share a pool, so check your own plan before you budget for both.

8. Using Both Together

Many teams end up with both, and they fit together naturally:

MCP for the editorial side. Writers and editors draft, check, and humanize inside Claude or ChatGPT, with Walter Skills enforcing a consistent process.
API for the system side. Your CMS or publishing pipeline calls the detector on every piece before it goes live, logs the per-sentence results, and routes anything above a threshold back for review.

A practical pattern: use MCP to develop and tune a workflow interactively, such as which threshold makes sense or which phrases should never change, then encode the settled version in code against the API once it needs to run unattended.

9. Decision Guide

Use Walter MCP if:

You or your team work inside Claude, ChatGPT, Claude Code, or another MCP client
You want to describe workflows in plain language instead of writing code
You want documented keyword and entity preservation with a preservation report
You don't want to manage API keys

Use the Walter API if:

Walter is a feature in a product you're building
You need plagiarism, grammar, voice, or image detection
You need async processing, webhooks, or a server-side detection threshold
You need deterministic behavior for CI, scheduled jobs, or production pipelines

Use both if:

People edit interactively and systems check automatically
You want to prototype a workflow in an assistant and then productionize it

10. FAQs

What's the difference between Walter MCP and the Walter API?
Walter MCP is a server that lets AI assistants like Claude, ChatGPT, and Claude Code call Walter's humanize, detect, and batch humanize tools from natural-language instructions. The Walter API is a REST API your own code calls directly with an API key, and it covers more services, including detect-and-humanize, plagiarism, grammar, voice detection, and image detection.

Do I need an API key to use Walter MCP?
No. Walter MCP uses OAuth. You sign in to your Walter account once and approve access, and tool calls run under your workspace's plan.

Does the Walter API support async requests?
Yes. The humanizer, detector, and detect-and-humanize endpoints accept poll: true, a callback_url, or both. They return 202 Accepted with a task_id, and you fetch results from GET /api/jobs/{task_id}/ or receive them by webhook. Results expire after one hour.

What are the Walter API rate limits?
By default, sync humanizer requests are limited to 3 per minute and sync detector requests to 10 per minute, with additional per-user and per-IP limits. Async requests aren't subject to the per-minute limits; they're constrained by credits and a pending-jobs cap that depends on your plan. Rate-limit responses include a Retry-After header.

How much does the Walter API cost?
Most text endpoints cost 1 credit per word. Monthly plans range from 300,000 credits for $49 to 25 million credits for $1,699, and new accounts get a 2,000-credit free trial for 5 days with no card required. Failed requests are refunded automatically.

Can I preserve keywords with the Walter API?
Walter's MCP documentation describes keyword, entity, and URL preservation for walter_humanize. The humanizer API reference documents the content field and async options. If you need specific phrases kept when using the API, verify them in your own code after each call, or use the MCP route for that workflow.

Can I use Walter MCP in Claude Code?
Yes. Run claude mcp add walter-writes https://mcp-server.walterwrites.ai/mcp -t http --scope user, then authenticate with /mcp. Claude Code can then run Walter on files in your repo and write the results back.

Which should I pick if I'm just getting started?
If you mainly want to check and humanize your own writing, start with MCP in the assistant you already use. If you're building something that other people will use, or something that runs without a person in the loop, start with the API and the free trial credits.

5 Advanced Walter MCP Prompts for Power Users

Mohab Abdelkarim — Sat, 17 Oct 2026 23:08:11 +0000

Most people using Walter Writes AI's MCP server never get past the basic version: paste a paragraph, ask Claude to humanize it, done. That works, but it leaves most of the integration unused.

Once Walter is connected as an MCP server, Claude has three tools it can call, and it can call them in sequence, conditionally, and across many inputs. In Claude Code, it can also read the drafts from your repo and write the results back. That turns a one-off paraphrase into something closer to a content pipeline: detect first, humanize only what needs it, lock the terms that must survive, and report per file.

This post covers the setup in two minutes, then five prompts that use it properly. Each prompt is in a code block so you can copy it straight into Claude or Claude Code.

What You're Working With: Tools vs Skills
Setup in Two Minutes
Prompt 1: The Detect-and-Humanize Chain
Prompt 2: The Keyword-Locked Humanize
Prompt 3: Agency QC Over a Folder of Drafts
Prompt 4: The Local SEO Multiplier
Prompt 5: Programmatic SEO From a CSV
Bonus: The Repurposing Cascade
Stacking Prompts and Watching the Tool Calls
FAQs

1. What You're Working With: Tools vs Skills

Two separate things do the work here, and mixing them up is the most common reason a prompt doesn't behave as expected.

The MCP server provides the tools. Walter's server exposes three:

walter_humanize rewrites AI-generated text to read naturally, with adjustable rewrite strength. It preserves keywords, named entities, URLs, and document structure, and returns a preservation report.
walter_detect returns a 0 to 100 AI score, a verdict (likely human, unclear, or likely AI), and the high-risk spans behind the score. Explanations can be turned on for detailed writing advice.
walter_batch_humanize processes several texts in one call with shared defaults and per-item overrides. If one item fails, the others still return, with per-item reports and a batch summary.

Skills provide the process. Walter publishes 12 free, MIT-licensed skill files in github.com/walterwritesai/walter-skills. Each one is a SKILL.md that tells Claude how to run a specific workflow: when to humanize, which mode to use (light, balanced, or aggressive), which keywords to lock, and what the summary should look like. The four used in this post are walter-agency-qc, walter-local-seo, walter-programmatic-seo, and walter-content-repurposer.

Without the server, a skill gets followed but can't actually humanize or detect anything. Without the skills, the server works but you re-explain your process every session.

2. Setup in Two Minutes

Claude Code. Add the server with HTTP transport, scoped to your user so it's available in every repo:

claude mcp add walter-writes https://mcp-server.walterwrites.ai/mcp -t http --scope user

Then run /mcp inside Claude Code, select walter-writes, choose Authenticate, and sign in to your Walter account in the browser. Walter uses OAuth, so there's no API key to paste.

Claude on the web or desktop. Add Walter as a custom connector using the same URL, then sign in when prompted. Walter's docs have step-by-step guides for Claude web, desktop, mobile, ChatGPT, Gemini CLI, and Open WebUI.

Skills. Install all 12 with one command:

npx skills add walterwritesai/walter-skills

Or just one:

npx skills add walterwritesai/walter-skills --skill walter-agency-qc

For Claude on the web, open the skill's folder in the repo, copy its SKILL.md, and paste it into your project instructions.

If you get stuck on setup, waltermcp.com is a community-run guide with walkthroughs. It isn't an official Walter Writes AI resource, so treat Walter's own docs and GitHub repo as the source of truth if the two ever disagree.

Quick check: ask Claude to run walter_detect on any paragraph. If you get a score and a verdict back, the tools are live. If you get a rewrite with no score, Claude is paraphrasing on its own and Walter isn't connected yet.

3. Prompt 1: The Detect-and-Humanize Chain

The biggest inefficiency in how people use a humanizer is running the whole document through it, including the parts that were never going to get flagged. This prompt makes detection the first step and humanization the second, applied only where it's needed.

Use the walter-writes MCP server.
1. Run walter_detect on the draft below with explanations on.
2. Humanize only the high-risk spans it returns, using balanced mode.
   Leave every other sentence exactly as written.
3. Run walter_detect again on the full result.
Return: the final text, the before and after scores, and a list of
which sentences changed.

[paste draft]

Why it works: walter_detect returns the specific spans behind the score, not just a number, so Claude knows exactly which sentences to send to walter_humanize. Your own phrasing survives in the sections that were already fine, you use fewer words from your plan, and you get a clean changelog instead of a full rewrite you have to diff yourself.

In Claude Code, point it at a file instead of pasting:

Run the detect-and-humanize chain above on @drafts/launch-post.md.
Write the result back to the same file and print the changed sentences.

4. Prompt 2: The Keyword-Locked Humanize

Humanizers are designed to change wording, which is a problem when your draft contains a product name, a statistic, or a technical term that has to survive word for word. Walter preserves keywords, entities, and URLs by default, but listing the critical ones explicitly removes any guesswork.

Use walter_humanize on the product description below in balanced mode.
Preserve these exact terms with keyword preservation:
- "Acme Sync Pro"
- "47 percent faster"
- "ISO 27001 certified"
- every URL
Rewrite everything else freely for tone and sentence rhythm.
After humanizing, show me the preservation report and confirm each
locked term appears unchanged.

[paste description]

Why it works: Be specific. "Don't touch the numbers" is weaker than listing the exact figures, because a vague instruction leaves room for interpretation. Asking Claude to confirm each locked term against the preservation report turns "I hope it kept my keywords" into a check you can see.

5. Prompt 3: Agency QC Over a Folder of Drafts

If you QC client work regularly, the walter-agency-qc skill gives Claude a fixed checklist: run detection, humanize in balanced mode if the score is above 30, re-check, verify keywords, flag thin content (under 300 words) or missing H2 structure, and output a summary with a publish recommendation.

In Claude Code, that checklist can run across a whole folder:

Using the walter-agency-qc skill, QC every .md file in @content/client-drafts/.
Target keyword for each file is in its front matter under `keyword:`.
For each file:
- run the full QC checklist
- write humanized versions to content/client-drafts/qc/ with the same filename
Then print one summary table: file, original score, final score,
keyword status, word count, flags, recommendation.

Why it works: The skill keeps the process identical for file one and file twenty, and the output format stays consistent, which matters when the summary goes to a client or a junior editor. Writing results to a separate qc/ folder keeps your originals untouched, so you can diff before you accept anything.

6. Prompt 4: The Local SEO Multiplier

Multi-location service pages are one of the fastest ways to produce near-duplicate content, because the usual approach is a template with the city name swapped. The walter-local-seo skill is built to avoid that: it requires local context in each page, preserves the "[service] in [city]" phrase in the right places, humanizes in balanced mode, and flags pages that are too similar to each other.

Using the walter-local-seo skill, adapt the base service page in
@pages/emergency-plumbing.md for these cities:
Austin, Denver, Raleigh, Tucson, Columbus.
Each page needs at least one real neighborhood or landmark and must read
like it was written locally, not templated.
Run walter_detect on each page individually.
Save each page to pages/locations/<city>.md and print the summary table:
city, word count, detection score, keyword status, similarity flags.

Why it works: "Individually" is the key word. It's easy to optimize for an average across five pages while one still reads as obviously templated. A per-page score and the skill's similarity flags catch that before you publish.

7. Prompt 5: Programmatic SEO From a CSV

This is where Claude Code really pays off. The walter-programmatic-seo skill generates one page per CSV row using a fixed template (an H1 from the row, an intro, three H2 sections, and three FAQs), humanizes each page in balanced mode, and locks the H1 phrase with keyword preservation. It also rotates sentence openings and H2 order to avoid duplicate patterns, and it flags bad rows instead of stopping the batch.

Given a CSV like this:

h1,city,service
Roof Repair in Austin,Austin,roof repair
Roof Repair in Denver,Denver,roof repair
Gutter Cleaning in Austin,Austin,gutter cleaning

Run:

Using the walter-programmatic-seo skill, generate a page for every row
in @data/pages.csv.
Lock each row's h1 exactly with keyword preservation.
Save each page as pages/generated/<slugified-h1>.md.
When finished, print the summary table: row, word count, detection score,
H1 preserved (yes/no), flags. Don't stop for a bad row; list it at the end.

Why it works: The skill handles structure and anti-duplication, Walter handles the humanizing and the per-page score, and Claude Code handles the files. Detection risk resets per page, so a per-row score is the only number that matters.

8. Bonus: The Repurposing Cascade

One long post can become a LinkedIn post, an X thread, a newsletter, and an Instagram caption. The walter-content-repurposer skill handles each format's length and tone, humanizes each one in light mode so it reads casually and natively, and runs detection on every output.

Using the walter-content-repurposer skill, turn @blog/pillar-post.md into
a LinkedIn post, an X thread, an email newsletter, and an Instagram caption.
Save them to blog/repurposed/ and print the summary table:
format, length, detection score.

Each derivative gets its own score because, again, detection risk is per piece, not per source article.

9. Stacking Prompts and Watching the Tool Calls

Once these feel natural, combine them. A detect-and-humanize chain with locked keywords is a perfectly good single prompt:

Run the detect-and-humanize chain on @drafts/pricing-page.md, but keep
"Acme Sync Pro", "$49/month", and "14-day free trial" exactly as written.

A few habits that make these prompts reliable:

Name the server and the tool. "Use the walter-writes MCP server to run walter_detect" removes any chance of Claude paraphrasing on its own.
Watch the tool calls the first few times. In Claude Code you can see each call to walter_detect and walter_humanize as it happens. If a step you expected doesn't appear, tighten the prompt.
Write outputs to a separate folder. It keeps originals safe and makes git diff your review step.
Detect before you humanize. It's cheaper on your plan's limits and keeps more of your original voice.

Usage runs under your Walter workspace's plan, which sets limits like daily word volume and batch size. If a long batch stops partway, that's usually the reason; split it and continue.

10. FAQs

Do I need Walter's API for these prompts?
No. Everything here runs through the MCP server and works as normal messages to Claude or Claude Code. The REST API is only for calling Walter from your own code.

What's the difference between the MCP server and Walter Skills?
The server gives Claude the tools: walter_humanize, walter_detect, and walter_batch_humanize. Skills are instruction files that tell Claude how to use those tools for a specific workflow, like agency QC or local SEO. You can use the server without skills, but the batch prompts work much better with the relevant skill installed.

How do I install a single Walter skill?
Run npx skills add walterwritesai/walter-skills --skill walter-agency-qc, swapping in the skill you need, such as walter-local-seo, walter-programmatic-seo, or walter-content-repurposer.

Is waltermcp.com official?
No. It's a community-run guide to Walter's MCP setup and skills. It's a useful second reference, but Walter's own docs and the GitHub repo are the source of truth.

Do these prompts work in Claude Code?
Yes, and the file-based versions only work there, since Claude Code can read files with @path references and write results back to your repo. Add the server with claude mcp add walter-writes https://mcp-server.walterwrites.ai/mcp -t http --scope user and authenticate with /mcp.

How do I make sure locked keywords survive humanization?
List the exact terms rather than describing them, and ask Claude to check each one against the preservation report walter_humanize returns. That gives you a visible confirmation instead of an assumption.

Which humanization mode should I use?
The Walter skills use balanced mode for most content, light mode for casual social formats, and aggressive mode only when a passage still scores high after a balanced pass. Start with balanced and only go stronger if detection says you need to.

Does this work in languages other than English?
Yes. Walter's humanizer supports more than 80 languages, and the prompts work the same way since they describe process, not language.

Walter MCP in Gemini CLI: Setup and Workflows

Mohab Abdelkarim — Tue, 13 Oct 2026 22:58:45 +0000

One config entry, one OAuth sign-in, and the terminal workflows that make the connection worth setting up.

Gemini CLI can read and write the files in your project, which makes it a good home for writing tools, not just coding tools. Connect Walter Writes AI's MCP server and Gemini can run AI detection on a markdown file, humanize only the passages that need it, and write the result back to disk without you copying text between a terminal and a browser tab.

Before the setup, one thing has changed this year that affects who should follow which part of this guide. On June 18, 2026, Google stopped serving Gemini CLI requests for free-tier users and Google AI Pro and Ultra subscribers and moved those users to the new Antigravity CLI. Gemini CLI still works with paid Gemini API keys, Gemini Code Assist Standard and Enterprise licenses, and Google Cloud access. If you're in that group, sections 2 through 8 are for you. If you were moved to Antigravity CLI, jump to section 9. The Walter server and the workflows are the same either way. Only the config file changes.

What you're connecting
Add the server (settings.json)
Or add it with one command
Authenticate with OAuth
Verify the connection
Scope, tool filtering, and confirmations
Add Walter Skills (optional)
Workflows worth using
Using Antigravity CLI instead
Troubleshooting
FAQs

1. What you're connecting

Walter's MCP server is a remote server at:

https://mcp-server.walterwrites.ai/mcp

It uses OAuth, so there's no API key to paste. You sign in to your Walter account once in a browser, and tool calls then run under your Walter workspace's plan and limits.

It exposes three tools:

walter_humanize rewrites AI-generated text to read naturally, with adjustable rewrite strength. It preserves keywords, named entities, URLs, and document structure, and returns a preservation report with the rewritten text.
walter_detect scores text from 0 to 100 for AI patterns and returns a verdict (likely human, unclear, or likely AI) plus the specific high-risk spans behind the score. Explanations can be turned on for detailed writing advice.
walter_batch_humanize handles several texts in one call, with shared defaults and per-item overrides. If one item fails, the others still return, with per-item reports and a batch summary.

Inside Gemini CLI, MCP tools get a qualified name in the format mcp_{serverName}_{toolName}. With the server named walter-writes, you'll see names like mcp_walter-writes_walter_detect. You don't need to type these. Gemini picks the tool from your request, but it helps to recognize them in confirmation prompts and logs.

2. Add the server (settings.json)

This is the method in Walter's official Gemini CLI guide.

Open your user settings file:

nano ~/.gemini/settings.json

Add Walter under mcpServers:

{
  "mcpServers": {
    "walter-writes": {
      "url": "https://mcp-server.walterwrites.ai/mcp"
    }
  }
}

Two things to watch:

Merge, don't replace. If your settings.json already has content (theme, model, auth settings, other MCP servers), add the walter-writes entry inside the existing mcpServers object instead of overwriting the file. A full file might look like this:

{
  "general": {
    "defaultApprovalMode": "default"
  },
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"]
    },
    "walter-writes": {
      "url": "https://mcp-server.walterwrites.ai/mcp"
    }
  }
}

Don't add a transport key. Walter's docs call this out specifically: adding "transport" causes a validation error, because Gemini CLI infers the transport from the URL fields.

A note on `url` vs `httpUrl`

If you've read older Gemini CLI docs, you may have seen that url is for SSE and httpUrl is for Streamable HTTP. That's out of date. In current Gemini CLI source, httpUrl is marked deprecated, and a bare url tries Streamable HTTP first and falls back to SSE only if that fails. Walter's server is Streamable HTTP, so url works. If you want to be explicit, current versions accept an optional type field:

"walter-writes": {
  "url": "https://mcp-server.walterwrites.ai/mcp",
  "type": "http"
}

That's type, not transport. Either form works on a current build.

3. Or add it with one command

If you'd rather not edit JSON by hand, Gemini CLI has an mcp add command that writes the same entry for you:

gemini mcp add --scope user --transport http walter-writes https://mcp-server.walterwrites.ai/mcp

What the flags do:

--scope user writes to ~/.gemini/settings.json, so Walter is available in every project. The default is project, which writes to .gemini/settings.json in the current directory.
--transport http tells Gemini CLI this is a Streamable HTTP server. The default transport for mcp add is stdio, which is wrong for a remote URL, so don't skip this flag.

To check or undo it later:

gemini mcp list
gemini mcp remove --scope user walter-writes

Note that remove also defaults to project scope, so pass --scope user if that's where you added it.

4. Authenticate with OAuth

Start Gemini CLI:

gemini

If you don't have it installed globally, npx @google/gemini-cli works too.

Then, inside the session:

/mcp auth walter-writes

A browser window opens for Walter Writes AI. Sign in, approve access, and return to the terminal. Gemini CLI stores the token in ~/.gemini/mcp-oauth-tokens.json and reuses it in later sessions, so you only do this once per machine unless you revoke access.

Running /mcp auth without a server name lists every server that needs authentication, which is handy if you've just added several.

Working over SSH or in a container? The OAuth flow needs a local browser and a localhost callback, so it won't complete in a headless environment. Authenticate on a machine with a browser first, or run Gemini CLI locally for the initial sign-in.

5. Verify the connection

Inside the session:

/mcp

You should see walter-writes listed as connected, with its three tools. If it shows as disconnected or needing auth, run /mcp auth walter-writes again.

Then do a quick real call:

Use the walter-writes MCP server to run walter_detect on this text and show the score, verdict, and any high-risk spans:

"In today's fast-paced digital landscape, organizations must leverage innovative solutions to unlock new opportunities and drive meaningful growth."

Gemini will ask you to confirm the tool call (more on that next). Approve it, and you should get a score and verdict back. That sentence is about as formulaic as AI writing gets, so expect it to score high.

6. Scope, tool filtering, and confirmations

User vs project scope. User scope (~/.gemini/settings.json) makes Walter available everywhere. Project scope (.gemini/settings.json in a repo) keeps it to one project and lets you commit the config so teammates get the same setup. Each person still authenticates with their own Walter account, because tokens live in each user's home directory, not in the repo.

Limit which tools load. If a project only needs detection, an allowlist keeps Gemini from reaching for the other tools:

"walter-writes": {
  "url": "https://mcp-server.walterwrites.ai/mcp",
  "includeTools": ["walter_detect"]
}

excludeTools does the opposite and takes precedence if you set both.

Confirmations. By default, Gemini CLI asks before every MCP tool call. You'll see four options: allow once, always allow this tool, always allow this server, or cancel. For daily use, "always allow this tool" on walter_detect and walter_humanize is a reasonable middle ground.

There's also a "trust": true setting that skips all confirmations for a server. It's convenient for scripted runs (see workflow 5), but it applies to every tool on that server, so only use it in a config you control.

Enable or disable without deleting. gemini mcp disable walter-writes and gemini mcp enable walter-writes (or /mcp disable and /mcp enable inside a session) toggle the server without removing its config. Add --session to make the change apply only to the current session.

7. Add Walter Skills (optional)

The MCP server gives Gemini the tools. Walter Skills give it repeatable instructions for using them on specific kinds of content: SEO articles, agency QC, local SEO pages, content refreshes, docs, newsletters, and more. There are 12 in the free, open-source repo at github.com/walterwritesai/walter-skills.

Install all of them:

npx skills add walterwritesai/walter-skills

Or just one:

npx skills add walterwritesai/walter-skills --skill walter-seo-writer

The skills installer supports Claude Code, Cursor, Windsurf, and 60+ other agents. If Gemini CLI isn't among the agents it offers to install for on your machine, you can still use any skill by copying its SKILL.md into your project's .gemini/skills/ folder, or by referencing it from your GEMINI.md.

8. Workflows worth using

These are the workflows where running Walter from a terminal agent beats pasting text into a web app.

Workflow 1: Detect first, humanize only what's flagged

Gemini CLI lets you reference files with @. Use that to point it at a draft:

Read @content/posts/launch-announcement.md.
Use the walter-writes MCP server to run walter_detect on it with explanations on.
Then run walter_humanize only on the high-risk spans it returns.
Keep all headings, code blocks, links, and front matter unchanged.
Write the result back to the same file and show me a short diff summary plus the before and after scores.

This keeps your own writing intact in the sections that were already fine, and it uses fewer words from your Walter plan than humanizing the whole file.

Workflow 2: Protect technical terms

Docs and dev content are full of terms that must not change: API names, flags, product names, version numbers. Walter preserves keywords and entities by default, but naming them removes any guesswork:

Humanize the "Overview" and "Why this matters" sections of @docs/getting-started.md with walter_humanize.
Do not change these terms: "Webhooks API", "--dry-run", "v3.2", "OAuth 2.0", or anything inside backticks.
Leave all other sections untouched.

Workflow 3: Batch a folder

For a directory of short pieces (product descriptions, release notes, social captions), batch them in one call instead of one at a time:

Read every .md file in @content/changelog/.
Send the body text of each to walter_batch_humanize in a single call.
Save each result to content/changelog/humanized/ with the same filename.
Then list each file with its walter_detect score before and after.

Because batch calls return per-item reports, one failed item doesn't sink the whole run. Gemini can tell you which file failed and retry just that one.

Workflow 4: Make it the default with GEMINI.md

Gemini CLI loads GEMINI.md files as standing instructions. Put your house rules there so you don't repeat them in every prompt:

## Writing workflow

- When asked to humanize content, always run walter_detect first and only humanize spans flagged as high risk.
- Never change text inside code blocks, inline code, URLs, or YAML front matter.
- Preserve product names, API names, and version numbers exactly.
- After humanizing, run walter_detect again and report before and after scores.

Put it at the project root for one repo, or in ~/.gemini/GEMINI.md to apply it everywhere.

Workflow 5: Headless runs for scripts

Gemini CLI's -p flag runs a single prompt non-interactively, which makes it scriptable:

gemini -p "Run walter_detect on @drafts/post.md and print only the score and verdict." \
  --allowed-mcp-server-names walter-writes

--allowed-mcp-server-names limits the run to the Walter server, so nothing else loads.

Two things make headless runs work:

Authenticate interactively first. Run gemini and /mcp auth walter-writes once on the machine. The stored token is reused by later headless runs.
Handle confirmations. There's no one to approve tool calls in a headless run. Rather than using --yolo (which auto-approves every tool, including shell commands), set "trust": true on just the walter-writes entry in a project-scoped .gemini/settings.json used for these scripts. That skips confirmations for Walter's tools only.

A practical use is a pre-publish check: run detection on every changed markdown file in a branch and print the scores, so you see which pages might draw a false positive before they go live.

9. Using Antigravity CLI instead

If you were on Gemini CLI's free tier or a Google AI Pro or Ultra subscription, you're now on Antigravity CLI, launched with agy. Walter's server works the same way there, but the config moved and one key changed.

The config file is different. Antigravity CLI doesn't read MCP servers from ~/.gemini/settings.json. It uses a standalone file:

Global: ~/.gemini/config/mcp_config.json
Workspace: .agents/mcp_config.json in your project root

The key is serverUrl. Antigravity doesn't support the legacy url or httpUrl keys for remote servers. Use:

{
  "mcpServers": {
    "walter-writes": {
      "serverUrl": "https://mcp-server.walterwrites.ai/mcp"
    }
  }
}

OAuth is handled for you. For servers that support dynamic client registration, Antigravity runs the OAuth flow automatically, so serverUrl is all you need. Sign in to Walter when prompted.

Managing it. Type /mcp in Antigravity CLI to open the MCP manager, where you can see server status, reload configs, and check connection logs. To turn a server off temporarily, set "disabled": true. To hide specific tools, use disabledTools.

Migrating an existing setup. Antigravity's agy plugin import gemini command converts Gemini CLI extensions, including their MCP server definitions. For a server you added directly to settings.json, like Walter, copy the entry into mcp_config.json and rename url to serverUrl. Your GEMINI.md files keep working unchanged. Workspace skills need to move from .gemini/skills/ to .agents/skills/.

Walter's documentation doesn't have an Antigravity-specific guide yet, so this section follows Antigravity's own MCP docs. Everything in section 8 carries over, since the tools and prompts are identical.

10. Troubleshooting

/mcp shows walter-writes as disconnected.
Run /mcp auth walter-writes. If it still fails, check the URL for typos and confirm it ends in /mcp.

Validation error after editing settings.json.
Usually a "transport" key or a JSON syntax issue such as a missing comma between server entries. Remove transport (use type if you need to be explicit) and validate the JSON.

gemini mcp add created a stdio server.
You left off --transport http. Remove the entry and add it again with the flag.

The browser window never opens during auth.
You're likely in a headless environment. Authenticate on a machine with a browser first.

Gemini answers without calling Walter.
Name the server and the tool in your prompt ("use the walter-writes MCP server to run walter_detect"). If you've set includeTools, confirm the tool you're asking for is in the list.

Headless runs hang or skip the tool.
There's no one to approve the call. Set "trust": true on the Walter entry in a project config used only for those scripts.

Calls stop working partway through a big batch.
You may have hit your Walter plan's daily word volume or batch size limit. Split the job or check your Walter account.

Gemini CLI says it can't serve requests for your account.
If you're on the free tier or a Google AI Pro or Ultra plan, that's the June 18, 2026 change. Set Walter up in Antigravity CLI using section 9.

11. FAQs

How do I add Walter MCP to Gemini CLI?
Add a walter-writes entry under mcpServers in ~/.gemini/settings.json with "url": "https://mcp-server.walterwrites.ai/mcp", or run gemini mcp add --scope user --transport http walter-writes https://mcp-server.walterwrites.ai/mcp. Then run /mcp auth walter-writes inside Gemini CLI to sign in.

Does Walter MCP need an API key in Gemini CLI?
No. Walter's MCP server uses OAuth. You sign in to your Walter account once in a browser, and Gemini CLI stores the token for later sessions.

Should I use url or httpUrl for Walter in Gemini CLI?
Use url, as Walter's docs show. In current Gemini CLI, httpUrl is deprecated, and url tries Streamable HTTP first with SSE as a fallback. You can add "type": "http" to be explicit, but don't add a transport key.

Can I still use Gemini CLI after June 18, 2026?
Yes, with paid Gemini API keys, Gemini Code Assist Standard or Enterprise licenses, or Google Cloud access. Free-tier users and Google AI Pro and Ultra subscribers were moved to Antigravity CLI.

How do I set up Walter MCP in Antigravity CLI?
Add Walter to ~/.gemini/config/mcp_config.json (or .agents/mcp_config.json for one project) under mcpServers, using "serverUrl": "https://mcp-server.walterwrites.ai/mcp". Antigravity handles OAuth automatically for servers that support dynamic client registration.

Can Gemini CLI humanize files directly?
Yes. Reference a file with @path/to/file.md, ask Gemini to run Walter's tools on it, and tell it to write the result back. Gemini CLI handles the file reading and writing, and Walter handles detection and humanization.

How do I stop Gemini CLI from asking to confirm every Walter call?
Choose "always allow this tool" or "always allow this server" at the confirmation prompt. For scripts, set "trust": true on the Walter server entry, which skips confirmations for that server only.

Does Walter MCP work with Walter Skills in Gemini CLI?
Yes. Install them with npx skills add walterwritesai/walter-skills. If the installer doesn't list Gemini CLI on your machine, copy a skill's SKILL.md into .gemini/skills/ or reference it from GEMINI.md.

Deepfake Detection API: Adding Image and Video Verification to Your Platform

Mohab Abdelkarim — Mon, 05 Oct 2026 23:01:08 +0000

If your platform accepts user-uploaded images or video, synthetic media is already in your pipeline. Profile photos, ID selfies during onboarding, product listing images, UGC clips submitted to a newsroom, video testimonials. Some fraction of that is generated or manipulated, and the fraction is growing.

This guide covers adding detection using the DeepfakeDetector.ai API: getting a key, scanning an image, handling video asynchronously, parsing the response defensively, and, the part most guides skip, designing your product around a result that is a probability rather than a fact.

What the API does
Getting an API key
Your first request: an image by URL
Uploading a file instead
Reading the response
Video: sync, async, and webhooks
A production-ready wrapper
Designing around a probabilistic verdict
Privacy and data handling
Rate limits, pricing, and cost control
Integration patterns
FAQs

1. What the API does

The DeepfakeDetector.ai API takes an image, video, or voice file and returns a verdict on whether it's AI-generated or manipulated, with a confidence score and the signals that drove it.

Everything sits behind one base URL with the same auth, response shape, and error semantics across media types:

https://app.deepfakedetector.ai/api/v1

The endpoints, with the typical latencies the docs list:

POST /api/v1/detect/image at around 0.8 seconds
POST /api/v1/detect/video at around 2.1 seconds for short clips
POST /api/v1/detect/voice at around 1.4 seconds
GET /api/v1/jobs/{id} at around 50 milliseconds, for checking async jobs

For images, it targets AI-generated images and faces from the major generators, including Midjourney, DALL·E, Stable Diffusion, and Flux. For video, it covers face swaps, lip-sync manipulation, and fully AI-generated clips, analyzed frame by frame. This guide focuses on images and video; voice works the same way through its own endpoint.

2. Getting an API key

API access starts on the Starter plan. The free tier gives you 50 detections a month in the web app, which is useful for evaluating accuracy on your own media before you pay, but it doesn't include API access.

Create an account, subscribe to a plan with API access, and generate a key. Two things to handle correctly:

The key is shown once. DeepfakeDetector.ai hashes keys at rest and displays the full key only at creation. Copy it into your secrets manager immediately.

Keep it server-side. Requests authenticate with a Bearer token, and a key in a browser bundle is a key anyone can read. All calls below belong on your backend.

export DFD_API_KEY="sk_live_..."

3. Your first request: an image by URL

The simplest call passes a publicly reachable HTTPS URL:

curl -X POST https://app.deepfakedetector.ai/api/v1/detect/image \
  -H "Authorization: Bearer $DFD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "media_url": "https://example.com/profile-photo.jpg" }'

The request accepts a few optional parameters worth knowing from the start:

media_type: image, video, or voice. Inferred from the MIME type if you leave it out.
strict_mode: lowers the confidence threshold, which catches more synthetic media at the cost of more false positives. Defaults to false.
callback_url: a webhook for async jobs, covered in section 6.
retain: keeps the file for 30 days for audit purposes. Defaults to false, meaning the file is purged 60 seconds after the verdict.

If your media lives in private storage, a signed URL with a short expiry works well: the API fetches the file, and the link dies shortly after.

4. Uploading a file instead

When you have the file in hand rather than a URL, send it as multipart form data:

curl -X POST https://app.deepfakedetector.ai/api/v1/detect/image \
  -H "Authorization: Bearer $DFD_API_KEY" \
  -F "file=@./uploads/selfie.jpg"

Either media_url or a multipart upload is required, not both.

Supported formats include MP4, MOV, and WEBM for video, and JPG, PNG, and WEBP for images, along with common audio formats. File size and duration limits depend on your plan; paid plans handle video up to 10 minutes per detection.

A practical point for user uploads: scan the file your user actually submitted, before you transcode, resize, or compress it for storage. Re-encoding can degrade the artifacts detectors rely on, and the docs note that heavy compression is a common reason for an inconclusive result.

5. Reading the response

A completed detection returns structured JSON. The example in the API documentation looks like this:

{
  "job_id": "job_8mTk2x",
  "verdict": "synthetic",
  "confidence": 0.91,
  "generator_family": "diffusion",
  "signals": {
    "skin_texture": "unnatural",
    "geometric": "symmetric",
    "lighting": "consistent"
  },
  "flagged_segments": [
    { "start": 2.4, "end": 5.8 }
  ],
  "latency_ms": 1842
}

What each field gives you:

verdict and confidence are what most of your logic will hang off. Confidence is a float between 0 and 1.

signals explains what drove the verdict, which is what makes a flag reviewable rather than opaque.

generator_family indicates the likely type of generator, for example diffusion-based.

flagged_segments applies to video and voice, giving start and end times in seconds for the portions that failed. For video moderation, this is the most useful field in the response: a reviewer can jump straight to second 2.4 instead of watching the whole clip.

job_id identifies the request. Store it with every result, since it's how you trace a decision back to a specific detection later.

One caution worth taking seriously. DeepfakeDetector.ai's web app presents verdicts as Authentic, Likely Synthetic, or Inconclusive with a 0 to 100 TrustScore, and the examples across its own pages don't use identical field names and verdict strings. Before you write logic that matches exact verdict values, confirm the current enum against the live API documentation, and build your thresholds on confidence rather than on string matching alone. The wrapper in section 7 does exactly that.

6. Video: sync, async, and webhooks

Images and short clips return quickly. Video processing scales with duration at roughly real time, so a three-minute clip takes on the order of three minutes. Holding an HTTP request open that long is a bad idea, and the API is designed for you not to.

For files over 60 seconds, use a webhook. Pass a callback_url and the API will POST the verdict to it when the analysis finishes:

curl -X POST https://app.deepfakedetector.ai/api/v1/detect/video \
  -H "Authorization: Bearer $DFD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "media_url": "https://storage.example.com/signed/clip.mp4",
    "callback_url": "https://your-app.com/webhooks/deepfake"
  }'

You get a job_id back immediately. Store it alongside the record it belongs to.

Treat the webhook as a notification, not as truth. The official SDKs handle webhook signature verification for you. If you're calling the API directly, the simplest robust pattern is to use the webhook only as a trigger, then fetch the authoritative result yourself:

GET https://app.deepfakedetector.ai/api/v1/jobs/{job_id}

That way a forged POST to your webhook endpoint can't push a fake verdict into your system, because the result you act on always comes from an authenticated call you made.

Add a reconciliation sweep. Webhooks occasionally fail to arrive. A scheduled job that checks any detection still pending after a reasonable window, using the same jobs endpoint, closes that gap.

7. A production-ready wrapper

Here's a Node wrapper that handles timeouts, rate limits, and the verdict normalization from section 5:

const BASE = "https://app.deepfakedetector.ai/api/v1";

async function detectMedia(mediaUrl, { type = "image", callbackUrl, timeoutMs = 15000 } = {}) {
  const controller = new AbortController();
  const timer = setTimeout(() => controller.abort(), timeoutMs);

  const body = { media_url: mediaUrl };
  if (callbackUrl) body.callback_url = callbackUrl;

  try {
    const res = await fetch(`${BASE}/detect/${type}`, {
      method: "POST",
      headers: {
        Authorization: `Bearer ${process.env.DFD_API_KEY}`,
        "Content-Type": "application/json",
      },
      body: JSON.stringify(body),
      signal: controller.signal,
    });

    if (res.status === 429) {
      const retryAfter = Number(res.headers.get("retry-after") || 5);
      throw Object.assign(new Error("rate_limited"), { retryAfter });
    }
    if (!res.ok) throw new Error(`Detector returned ${res.status}`);

    const data = await res.json();

    // Async job: no verdict yet
    if (data.confidence === undefined) {
      return { pending: true, jobId: data.job_id ?? data.id };
    }

    return {
      pending: false,
      jobId: data.job_id ?? data.id,
      verdict: String(data.verdict ?? "").toLowerCase(),
      confidence: data.confidence,
      signals: data.signals ?? null,
      flaggedSegments: data.flagged_segments ?? [],
    };
  } catch (err) {
    if (err.name === "AbortError") throw new Error("detector_timeout");
    throw err;
  } finally {
    clearTimeout(timer);
  }
}

The data.job_id ?? data.id fallback is deliberate, given the field-name variation noted in section 5. Once you've confirmed the live schema, you can tighten it.

The Python equivalent, with exponential backoff:

import os
import time
import requests

BASE = "https://app.deepfakedetector.ai/api/v1"
HEADERS = {
    "Authorization": f"Bearer {os.environ['DFD_API_KEY']}",
    "Content-Type": "application/json",
}

def detect_media(media_url: str, media_type: str = "image",
                 callback_url: str | None = None, max_retries: int = 3) -> dict:
    payload = {"media_url": media_url}
    if callback_url:
        payload["callback_url"] = callback_url

    for attempt in range(max_retries):
        r = requests.post(f"{BASE}/detect/{media_type}",
                          headers=HEADERS, json=payload, timeout=15)

        if r.status_code == 429:
            time.sleep(int(r.headers.get("Retry-After", 2 ** attempt)))
            continue

        r.raise_for_status()
        data = r.json()

        if "confidence" not in data:
            return {"pending": True, "job_id": data.get("job_id") or data.get("id")}

        return {
            "pending": False,
            "job_id": data.get("job_id") or data.get("id"),
            "verdict": str(data.get("verdict", "")).lower(),
            "confidence": data["confidence"],
            "signals": data.get("signals"),
            "flagged_segments": data.get("flagged_segments", []),
        }

    raise RuntimeError("detector: retries exhausted")

If you'd rather not write this yourself, DeepfakeDetector.ai publishes official SDKs that handle auth, retries, backoff, file streaming, and webhook signature verification. The API page lists clients for JavaScript and TypeScript, Python, Go, Ruby, PHP, Java, .NET, and Rust.

8. Designing around a probabilistic verdict

This is where integrations succeed or quietly fail. DeepfakeDetector.ai describes its own detection as probabilistic rather than absolute, and your product has to reflect that.

Use three outcomes, not two. A binary pass or block forces every uncertain result into the wrong bucket. A tiered design gives the middle somewhere to go:

function triage(result) {
  if (result.pending) return "awaiting_result";
  if (result.confidence < 0.5) return "clear";
  if (result.confidence < 0.85) return "human_review";
  return "high_confidence_flag";
}

Read that function as a starting point, not a recommendation. Where you set the boundaries depends on what a mistake costs in your product, and you should tune them against real samples of your own media.

Choose strict_mode by which error costs more. It raises recall and lowers precision. For KYC onboarding, where a missed synthetic ID is expensive, strict mode makes sense. For a social feed, where wrongly flagging real users damages trust, the default is usually better.

Route inconclusive results to a person, and ask for better input. Heavy compression is a common cause of low confidence. Requesting the original file, or a higher-quality copy, often resolves it.

Never automate a consequence off the score alone. Blocking an account, rejecting an ID, or labeling a user's content as fake should involve review, especially when the verdict is anywhere near your threshold.

Combine signals where you can. A detection result is strongest alongside provenance checks, such as Content Credentials where they exist, account history, and the context of the upload.

9. Privacy and data handling

If you're processing user media, the data handling defaults matter as much as the accuracy, and they're reasonable here.

Files are purged 60 seconds after the verdict by default. Setting retain: true keeps a file for 30 days, which is useful for audit trails in regulated workflows. Leave it off unless you have a specific reason to turn it on.

Keys are hashed at rest, and every call returns a request ID for auditing.

EU data residency is available on Business plans and above.

SOC 2 is in progress, not complete. The company states this plainly, and it's worth being equally plain with your own compliance team rather than assuming certification.

10. Rate limits, pricing, and cost control

Rate limits run from 60 to 300 requests per minute depending on plan, with burst allowance for known clients. The API targets a 99.9 percent uptime SLO, with a status page at status.deepfakedetector.ai.

Plans with API access:

Starter: $49 a month for 1,000 detections
Business: $199 a month for 5,000 detections
Enterprise: $599 a month for 20,000 detections

Annual billing saves up to 20 percent. Your monthly detections are shared between the web app and the API, so a team using both draws from one pool.

A few habits keep usage under control:

Don't scan what can't be synthetic. System-generated thumbnails, your own marketing assets, and media from trusted internal sources don't need checks.

Deduplicate. Hash uploaded files and cache results, since the same meme or stock photo can arrive thousands of times.

Scan at the decision point. Check media when it's about to matter, at onboarding, at publication, at payout, rather than on every view.

11. Integration patterns

The same API slots into quite different products.

KYC and identity verification. Check selfies and ID images at onboarding, before an account is approved. This is where strict mode and a mandatory review step earn their keep.

Trust and safety. Screen uploaded images and video before they reach a public feed, routing flagged items to a moderation queue with flagged_segments attached so moderators review only the relevant seconds.

Newsrooms and fact-checking. Verify user-submitted footage before publication, with retain: true if you need an audit record of what was checked and when.

Marketplaces. Check listing photos and seller verification images, where generated images are used to fake inventory or identity.

Financial fraud prevention. Verify voice messages and video calls that request payments, using the voice endpoint alongside video for impersonation attempts targeting finance teams.

12. FAQs

Which plans include API access?
Starter, Business, and Enterprise. The free tier offers 50 detections a month in the web app but doesn't include API access.

How do I authenticate?
With a Bearer token in the Authorization header. Keys are shown once at creation and hashed at rest, so store yours immediately in a secrets manager.

Can I send a file instead of a URL?
Yes. Send a multipart upload, or pass an HTTPS media_url. One of the two is required.

How should I handle long videos?
Use a callback_url. Video processes at roughly real time, and the API recommends webhooks for files over 60 seconds. Confirm results by fetching GET /api/v1/jobs/{id} rather than trusting the webhook payload directly, unless you're using an official SDK that verifies webhook signatures.

What does strict_mode do?
It lowers the confidence threshold, increasing recall at the cost of precision. Use it where missing a deepfake is more expensive than flagging a real file.

What happens to uploaded files?
They're purged 60 seconds after the verdict by default. Set retain: true to keep a file for 30 days for audit purposes.

Is the API SOC 2 certified?
Not yet. DeepfakeDetector.ai lists SOC 2 as in progress. EU data residency is available on Business plans and above.

How accurate is it?
DeepfakeDetector.ai describes detection as probabilistic rather than absolute and returns a confidence score with every verdict. Test it against a sample of your own media before setting thresholds, since performance depends on the generators, compression, and content types your users actually upload.

Walter MCP in Claude Code: A Practical Setup Guide

Mohab Abdelkarim — Tue, 29 Sep 2026 17:44:03 +0000

title: "Walter MCP in Claude Code: A Practical Setup GuideMost Walter MCP guides cover Claude on the web: Settings, Connectors, paste a URL. Claude Code is a different setup and a meaningfully different tool. It runs in your terminal, reads and writes files in your repo, and connects to MCP servers through a CLI rather than a settings page.

That last difference changes what the integration is useful for. In the web app you paste text in and get text back. In Claude Code the agent can walk a directory of markdown files, humanize a docs folder, or run a QC pass on every post in a content repo before you open a PR. This guide covers the setup and then the workflows that are actually worth it.

What you're setting up
Add the server
Choose your scope
Authenticate
Verify the connection
Install Walter Skills
Workflows that only work in Claude Code
Troubleshooting
FAQs

1. What you're setting up

Two separate pieces, and you need both.

Walter MCP is the remote server that gives Claude the actual tools. It exposes three: walter_humanize for rewriting, walter_detect for AI detection, and walter_batch_humanize for processing several texts in one run. These are tool calls out to Walter, not things Claude can do on its own.

Walter Skills are markdown instruction files that tell Claude how to run a workflow: which detection threshold counts as a flag, which humanization mode to use, what the output should look like. Twelve of them, free and MIT licensed, in the walter-skills repo.

Without the server, a loaded skill gets followed perfectly and still can't perform the humanization or detection steps. Without the skills, the server works but you're re-describing your process in every session. Section 2 through 5 set up the server, section 6 adds the skills.

2. Add the server

One command, straight from Walter's official Claude Code docs:

claude mcp add walter-writes https://mcp-server.walterwrites.ai/mcp -t http

-t http is the short form of --transport http, and it's the part that matters. It tells Claude Code this is a remote server to connect to rather than a local command to launch. Leave it off and Claude Code treats the URL as something to execute, which fails. HTTP is the recommended transport for remote servers, and Walter's server runs over streamable HTTP.

Use the name walter-writes rather than inventing your own. It's what Walter's documentation uses throughout, so anything you look up later will match what you see in your terminal.

After the command runs, the server is registered but not yet authenticated. That happens in section 4.

3. Choose your scope

The command above adds Walter at local scope, which is the default and the one that surprises people most. Local scope means the server exists only for you, only in the project directory where you ran the command. Open a different repo and Walter isn't there.

Three options:

Local (default). Only you, only this project. Fine for trying it out.

User. Only you, but across every project on your machine. This is the right choice for most individual writers and developers, since you'll want Walter available wherever you're working:

claude mcp add walter-writes https://mcp-server.walterwrites.ai/mcp -t http --scope user

Project. Written to a .mcp.json file in the repo root, which you commit so everyone on the team inherits the server. This is the one to use for a shared content or docs repo:

claude mcp add walter-writes https://mcp-server.walterwrites.ai/mcp -t http --scope project

Project scope shares the server definition, not anyone's credentials. Each teammate still authenticates with their own Walter account, and Walter links each authorization to that person's own workspace, so tool calls run within their own plan's limits. That's also exactly what you want given Walter's terms prohibit account sharing.

If the same server name exists at more than one scope, local takes precedence over project, and project takes precedence over user. Worth knowing when a teammate reports behavior you can't reproduce.

One more note on project scope: Claude Code asks for approval before using servers from a checked-in .mcp.json, and its own documentation is explicit that you should verify you trust a server before connecting it. That's a sensible default rather than a bug.

4. Authenticate

Walter uses OAuth, so there's no API key to paste into the command.

Launch Claude Code and run:

/mcp

Then follow Walter's documented flow:

Select walter-writes from the server list and choose Authenticate.
Sign in to your Walter account in the browser window that opens, or create one.
Approve access on the authorization consent screen.
Return to Claude Code and confirm the server shows as connected and authenticated.

You only authorize once. After that the connection is linked to your Walter workspace, and you can revoke access at any time from your Walter account.

No config files to edit, no key in an environment variable, and nothing sensitive in your shell history.

5. Verify the connection

Check the configuration from your terminal:

claude mcp list
claude mcp get walter-writes

Inside a session, /mcp shows connection status, and you should see Walter's three tools listed.

The real test is a functional one. Ask Claude:

Humanize this sentence with Walter and show the detection score before and after: "In today's rapidly evolving digital landscape, organizations must strategically leverage innovative technologies to optimize operational efficiency."

If both tools are working, you'll get the rewrite back with a preservation report, plus a detection score from 0 to 100 and a verdict of likely human, unclear, or likely AI. Ask Claude to explain the results and walter_detect also returns the high-risk spans with notes on why they were flagged.

If you get a rewrite with no scores, Claude is paraphrasing on its own and the Walter tools aren't being called, which means the server isn't connected or authenticated yet.

6. Install Walter Skills

Claude Code is one of the agents the skills registry supports directly, so installation is a single command:

npx skills add walterwritesai/walter-skills

That installs all twelve. To install just one:

npx skills add walterwritesai/walter-skills --skill walter-docs-writer

For Claude Code specifically, three are worth knowing first.

SK-12, Docs Writer. Built for help center articles and product documentation, with code blocks, commands, and technical terms passing through unchanged. This is the one to reach for in a repo, because a general humanizer that paraphrases a command breaks it.

SK-02, Agency QC Pipeline. Runs a full detect, humanize, flag, and report pass. Useful before a PR that touches content.

SK-09, Content Refresh. Updates older posts without discarding what's already ranking, which pairs naturally with Claude Code's ability to walk a folder of existing files.

If you'd rather browse before installing, waltermcp.com is a community-maintained guide with walkthroughs and one-click skill copying. It's community-run rather than official, so treat the GitHub repo as the source of truth for anything that needs to be current.

7. Workflows that only work in Claude Code

This is the part that justifies the terminal setup over the web connector. Because Claude Code operates on your actual files, a few workflows become single prompts.

Humanize a folder, not a paste. In a static site or blog repo:

Go through every markdown file in content/posts/ from the last month. Run Walter detection on each, humanize only the ones scoring above 40, keep each post's target keyword exactly as written, and don't touch front matter or code blocks.

The agent reads the files, sends them through Walter, and writes the changes back. You review the diff like any other change.

When several files go through walter_batch_humanize together, each is processed individually. If one fails, for example by exceeding your word limit, the rest still succeed and you get partial results back rather than losing the whole run. How many items a batch can hold, and your daily word volume, depend on your Walter plan.

QC before you open a PR. With the QC skill loaded:

Run the QC pipeline on every markdown file changed on this branch and give me a summary I can paste into the PR description.

This turns content review into a step in your normal git workflow rather than a separate process in a separate tool.

Fix documentation without breaking it. With Docs Writer loaded:

Rewrite the prose in docs/ so it reads naturally. Leave every code block, command, flag, and API path exactly as it is.

Protect terms across a whole repo. Keyword and brand preservation scale in a way manual editing doesn't:

Humanize the README and every file in guides/. The product name, CLI command names, and all version numbers must survive unchanged.

Keep it interactive. Walter's usage terms describe the MCP server as intended for interactive, user-to-assistant workflows, which is exactly what everything above is: you prompt, Claude acts, you review. If you want humanization running unattended, in CI or a scheduled job with nobody in the loop, that's what Walter's REST API is for, not the MCP server.

Scope what the agent touches. Worth saying plainly, since Claude Code can write to any file in scope: Walter rewrites prose. It does nothing useful to code logic, and you shouldn't point it at source files. Name the directories and file types explicitly in your prompt, and review the diff before committing. The approval step Claude Code shows for each tool call is there for a reason.

8. Troubleshooting

"MCP server walter-writes already exists in local config." You ran the add command twice at the same scope. Either it's already set up, or remove it first with claude mcp remove walter-writes and re-add.

Walter isn't showing up in a different project. It's at local scope. Re-add it with --scope user.

The URL gets treated as a command. You left off -t http. Remove and re-add with the flag.

Rewrites come back with no detection scores. The server isn't connected or isn't authenticated. Run /mcp, select walter-writes, and choose Authenticate if it's offered.

Skills installed but nothing different happens. Skills describe a workflow; they need the server to execute it. Check the connection first, since this is almost always a missing or unauthenticated server rather than a skills problem.

A teammate sees different behavior. Check for the same server name at multiple scopes, since local overrides project overrides user.

9. FAQs

How do I add Walter MCP to Claude Code?
Run claude mcp add walter-writes https://mcp-server.walterwrites.ai/mcp -t http, then launch Claude Code, run /mcp, select walter-writes, choose Authenticate, and sign in with your Walter account. Add --scope user to make it available across all your projects.

Do I need an API key?
No. Walter authenticates through OAuth. You sign in with your Walter account in the browser during the /mcp Authenticate step, so no key goes into the command or your environment. API keys are only needed if you use Walter's REST API directly.

Which scope should I use?
User scope for personal use across all your projects. Project scope for a shared team repo, which writes a .mcp.json you commit. The default local scope only works in the directory where you ran the command.

Can my team share one setup?
Yes, with project scope. The server definition is shared through the committed .mcp.json, while each person authenticates with their own Walter account.

How is this different from Walter in the Claude web app?
Same tools, different context. The web connector works on text you paste in. Claude Code works on files in your repo, so it can humanize a whole folder, run QC on a branch before a PR, or rewrite a docs directory while leaving code blocks intact.

Will it modify my code?
Only if you point it at code, which you shouldn't. Walter rewrites prose. Scope your prompts to specific directories and file types, and review the diff before committing.

Do I need Walter Skills too?
For repeatable workflows, yes. The server provides the tools and the skills define the process. Install with npx skills add walterwritesai/walter-skills.

Is waltermcp.com official?
No, it's a community-maintained guide. Useful as a secondary reference, but check the GitHub repo and Walter's own documentation for anything that needs to be current.

What tools does Walter add to Claude Code?
Three: walter_humanize for rewriting with keyword, entity, URL, and structure preservation; walter_detect for a 0 to 100 score, a verdict, and high-risk spans; and walter_batch_humanize for processing multiple texts in one run with partial results if any single item fails.

Can I run Walter MCP in CI or a scheduled job?
Walter describes the MCP server as intended for interactive, user-to-assistant workflows. For unattended automation, use Walter's REST API instead, documented at docs.walterwrites.ai.

Claude Humanizer Skill: Yes, It Already Exists, Here's How to Use It

Mohab Abdelkarim — Fri, 25 Sep 2026 20:36:07 +0000

Two skills, one shared knowledge base, MIT licensed. Plus the watermark side effect nobody in this category is discussing.

Search volume for "claude humanizer skill" spiked this year and most of the results treat it as an open question or a DIY project. It isn't either. A working, open-source implementation has been published, and you can read every instruction it gives Claude before you install it.

Yes, a Claude humanizer skill already exists
What it's actually doing under the hood
Why humanizers like this also strip the watermark
Watermark removal is not detector evasion
Where this leaves you

1. Yes, a Claude humanizer skill already exists

The repo is walterwritesai/no-slop-ai-humanizer-rewriter, MIT licensed, and it ships two skills rather than one.

Writer (writer/) is instructions for generating prose that avoids AI tells from the start. Use it when drafting articles, emails, or social posts where you'd rather not need a second-pass rewrite at all.

Humanizer (humanizer/) is instructions for taking existing AI output and rewriting it so it reads like a person wrote it.

Both draw from the same reference files, which is the design decision that matters most here. Same word lists, same structural patterns, same before-and-after examples. Whether you're preventing the problem or fixing it, the definition of the problem is identical.

The structure:

├── README.md
├── LICENSE
├── writer/
│   ├── SKILL.md
│   └── references/
│       ├── phrases.md
│       ├── structures.md
│       └── examples.md
└── humanizer/
    ├── SKILL.md
    └── references/
        ├── phrases.md
        ├── structures.md
        └── examples.md

Setup is manual, and worth being upfront about that. There's no install command. You clone or download the repo, open the SKILL.md for whichever skill you want, and paste its contents into your Claude project instructions along with the reference files. That's more friction than a package install, though it has a compensating benefit: you read exactly what you're loading before it runs, which is not the default experience with most agent tooling.

2. What it's actually doing under the hood

The skill works by naming specific patterns rather than issuing a general instruction to sound human. That distinction is the whole reason it produces different output from a "rewrite this to sound natural" prompt, which mostly gets you a thesaurus pass.

Three reference files carry the actual knowledge.

phrases.md catalogs words and phrases that appear in AI output at significantly higher rates than in human writing, grouped by function: verbs, adjectives, nouns, transitions, and full phrases. Each entry has human alternatives attached, so it's a substitution table rather than a blocklist.

structures.md is the more interesting file, and it's the one that separates this from vocabulary-level tools. It catalogs the sentence and paragraph shapes models default to: setup-payoff pairs, three-item list sentences, hedge chains, reframe constructions, summary closers, and identical paragraph opening patterns. Those are structural tells, and they survive any amount of synonym swapping.

examples.md holds before-and-after rewrites showing what each replacement looks like applied to real prose, which is what keeps the instructions from being interpreted loosely.

The word lists and patterns are derived from Walter Writes' research on common ChatGPT vocabulary, which itself aggregates observations from the writing community. The repo credits stop-slop as inspiration.

For comparison on how this category generally works: Mehul Gupta's publicly documented approach runs a three-pass system across roughly 29 categorized patterns with before-and-after examples for each. Different implementation, same underlying insight, which is that effective humanization is pattern-specific rather than a vibe you can prompt for.

The practical mechanism in all of these is a full rewrite rather than an edit. The skill isn't nudging individual words. It's regenerating prose against a set of constraints about what the output must not contain structurally. That distinction becomes load-bearing in the next section.

3. Why humanizers like this also strip the watermark

Any tool that fully rewrites text clears Anthropic's watermark as a side effect, because the watermark is a statistical pattern across a long sequence of token choices rather than a tag attached to the file. Replace the sequence and there's nothing left to detect. This applies to this repo, to Walter Writes as a maintained hosted implementation of the same mechanism, and to any other tool doing genuine rewriting.

The mechanism, briefly, since it explains the behavior. Claude's watermark is applied at generation time by seeding the sampler with a secret key plus a window of the preceding tokens rather than a general random number. At positions where several next-tokens are roughly equally good, the keyed value biases the choice. One biased choice proves nothing; hundreds across a passage produce a correlation that a verifier holding the key can detect. Nothing is inserted into the text, there are no special characters, and it survives copy-paste because the mark is the word sequence itself.

Two properties follow, and both are relevant to what a humanizer does to it.

The mark is distributed, not located. There is no token you could point at and call the watermarked one. It exists only as a property of the sequence.

Removal scales with how much of the sequence you replace. Anthropic's own documentation says light editing probably won't remove the watermark completely, while a complete rewrite in which every word is replaced will. That's the mechanical reason a full-rewrite humanizer has this effect while a grammar checker doesn't.

Worth stating plainly, because it's the honest framing: this is a byproduct, not a feature. Neither this repo nor any hosted humanizer is built to target the watermark, and describing any of them as a watermark remover overstates what they are. A rewrite clears it for the same reason that rewriting a paragraph clears any property that depended on the original wording.

Independent work supports the scale of the effect. Testing by ETH Zürich's SRI Lab found a baseline paraphraser scrubbed SynthID-Text watermarks from the large majority of passages, characterizing the scheme as harder to spoof but easier to scrub than earlier designs. Forging a mark without the key is very hard. Destroying one is not.

4. Watermark removal is not detector evasion

These are two separate outcomes with two separate mechanisms, and the distinction is the first thing a technical reader should get straight.

An AI detector reads the writing itself, inferring from stylistic patterns like word predictability and sentence-length variance. It holds no key and no privileged information. A watermark check looks for a specific key-derived statistical correlation and isn't inferring from style at all.

Which means a humanizer skill addresses them through different paths. It targets detectors directly, since detectors read phrasing and the skill rewrites phrasing. It affects the watermark only incidentally, as a consequence of replacing the token sequence.

Every tool in this category, including the four most commonly cited implementations, is built and marketed around the first case. None mentions the second.

One practical note on scope: because the watermark only attaches to tokens the model chose, a document's watermark density is proportional to how much Claude actually wrote versus lightly touched. Hand Claude a finished draft for grammar fixes and there may be very little to detect. Ask for 2,000 words from a prompt and the mark is dense throughout.

5. Where this leaves you

If you want a Claude humanizer skill, clone the repo, read the three reference files, and paste the SKILL.md you need into your project instructions. Twenty minutes, no dependencies, and you can audit every rule before it touches your writing.

If you want the same mechanism without the manual setup, hosted tools do the same category of rewrite with a UI attached.

And on the watermark, the accurate summary is narrower than the discussion around it suggests: a genuine rewrite clears it because the original sequence is gone, that's a consequence rather than a capability, and detection access is currently limited to organizations with specific legal obligations under EU law rather than being broadly available. Useful to understand. Not urgent to act on.

Is Claude Watermarking Code? What Developers Need to Know

Mohab Abdelkarim — Thu, 17 Sep 2026 15:43:56 +0000

Since August 2, 2026, Claude embeds a statistical watermark in its text output, and Anthropic's coverage list explicitly includes Claude Code. That fact generated two very different reactions in developer communities: a panic about Anthropic somehow claiming ownership of generated code, and a quieter, more legitimate question about provenance fingerprints sitting in a codebase.

The first concern is unfounded. The second is real but smaller than it sounds. Both are worth working through properly, because the mechanism has specific properties that make code a genuinely bad host for this kind of watermark.

Does Claude's watermark apply to code?
Does this mean Anthropic can prove I used Claude to write this function?
Will my formatter or linter break the watermark anyway?
What's the actual risk here?
If you want a clean pass on Claude-assisted comments or docs
This is not the same thing as the C2PA file signature
The practical takeaway

1. Does Claude's watermark apply to code?

Yes. Claude Code output falls under the same watermarking as everything else Claude generates, since it's applied at the model level rather than per-product. But code is a poor carrier for it, and the signal there is substantially weaker than in prose.

The reason is entropy. The watermark works by biasing the model's choice at points where multiple next-tokens are roughly equally good, then accumulating those biased choices into a statistical pattern. That mechanism needs choices to exist. Prose offers many near-equivalent phrasings at every step. Code does not: identifiers have to match their declarations, syntax is rigid, and swapping a token usually breaks something rather than producing an equally valid alternative.

There's public measurement supporting this, though with a caveat worth stating clearly. An open research repo measuring watermark strength across domains found that z-score and entropy move together almost exactly, with a z ratio of roughly 0.45x for code against prose at matched sample length, tracking an entropy ratio of 0.46x. In one run, 3 of 8 code samples fell to or below the detection threshold with no attack applied at all. The tightest sample, a bare algorithm at around 0.2 bits per token, scored 1.7 against a 2.33 threshold, which is a miss on clean, unmodified output.

The caveat: those measurements were run on open-weight models, not Claude. They demonstrate the mechanism's behavior, not Claude's specific numbers. Anthropic has not published a false-positive rate for code, and reasoning from the published mechanism is not the same as confirmed behavior.

One detail from that same research is worth flagging because it's counterintuitive. With extended thinking disabled, a model's pure code output scored z = 4.31 unattacked, barely above threshold. With thinking enabled, the same model in the same domain at the same length reached z = 25.53. The reasoning preamble is ordinary prose, and it carries the mark normally. The watermark isn't really in the code. It's in the text around the code.

That holds for everything Claude Code emits that isn't a diff: plan summaries, commit messages, PR descriptions, and chat explanations are all prose and should mark like any other prose.

2. Does this mean Anthropic can prove I used Claude to write this function?

No. The watermark has the same core limitation in code that it has in prose, and the low signal in code makes it worse rather than better.

Anthropic states directly that the watermark cannot distinguish a case where Claude wrote something from one where Claude heavily edited it. It marks involvement, not authorship. It also carries no identifying information: nothing in the watermark or its key can be traced back to a user, an organization, or a conversation.

Anthropic is equally explicit that the watermark speaks to neither ownership nor authorship, and doesn't change your rights under its terms. Whatever you generate with Claude is yours on exactly the same basis it was before August.

Add the entropy problem and the reliability question gets worse in both directions. A weak signal means more false negatives, because genuinely Claude-generated code can fall below threshold on its own. It also means any threshold tuned for prose is miscalibrated for code, which pushes toward false positives if someone applies a single confidence cutoff across domains without adjusting.

Anthropic's own announcement floated checking whether a PR was generated by Claude Code as a use case. That suggestion is doing more work than the mechanism supports. The PR description is prose and marks well. The diff is low-entropy code where there's little room to encode a signal. Screening contributions this way, before anyone publishes a false-positive rate on code specifically, would be building policy on the weakest application of the technology rather than the strongest.

3. Will my formatter or linter break the watermark anyway?

Probably, in many cases, though this is genuinely unresolved rather than confirmed. The reasoning is straightforward: the watermark lives in exact token sequences, and the entire purpose of a formatter is to rewrite token sequences to a canonical form.

What a normal dev workflow does to whatever signal survived generation:

Formatters rewrite whitespace, line breaks, quote style, and trailing commas. explainx.ai's analysis describes a single Prettier pass as close to an adversarial attack on a token-level watermark, which is a fair characterization given that the tool's job is normalizing exactly the variation the watermark depends on.

Linters and auto-fixers standardize naming conventions and quote characters, which touches the identifier tokens that carry what little entropy code offers.

Refactoring tools replace identifiers in bulk, which is the most destructive of the three for a pattern built on specific token choices in sequence.

Code review rewrites chunks of the diff outright, and those rewritten sections contribute nothing to detection afterward.

Stack those in the normal order, generate, format on save, lint in CI, address review comments, and there's little reason to expect a clean signal at the end. But nobody has published measurements on Claude output specifically through a real toolchain, so treat this as a well-reasoned expectation rather than a settled result. If it matters to a decision you're making, that gap is the thing to note, not paper over.

Worth noting the asymmetry this creates. Your commit messages, PR bodies, and README changes go through no such pipeline. They're prose, they don't get formatted, and they carry the mark fully.

4. What's the actual risk here?

The risk is a provenance fingerprint persisting in your codebase without any organizational policy for what it means. It is not Anthropic claiming your code, and it's worth dismissing that version directly.

The panic version says something like: Anthropic has marked my repo, they can identify me, they have a claim on my work. Every part of that is wrong. The watermark contains no identifying information, doesn't establish authorship, doesn't affect ownership, and the detection API is currently in private preview limited to organizations with legal obligations under EU law. Your employer cannot currently check your commits, and neither can anyone else outside that group.

The real version is more mundane and worth actually planning for. Detection access is expanding over time. At some point, a signal may be checkable across parts of a codebase, and organizations that have never articulated a position on AI-assisted code will be asked to have one reactively, under whatever circumstances prompted the question.

Concretely, the questions worth answering before someone else asks them:

Is AI-assisted code acceptable in this repo, and where? Most teams have an implicit answer and no written one. The implicit answer stops working the moment a specific case is disputed.

Does the answer change by context? Prototypes versus production, internal tools versus client deliverables, your own repos versus code contributed upstream. These plausibly have different answers, and writing them down is cheap.

What do your client contracts actually say? This is the one that bites agencies and contractors. If a contract has an AI clause, a provenance signal in delivered code becomes a contractual question rather than a technical one.

What's your position on contributions? If you maintain an open-source project, decide whether AI-assisted PRs are welcome and say so in CONTRIBUTING.md. Don't leave it to be litigated in a thread.

None of these are new questions. The watermark just removes the ability to keep deferring them.

5. If you want a clean pass on Claude-assisted comments or docs

Walter Writes handles the prose parts of a repo: READMEs, docstrings, code comments, and documentation. It rewrites text, which means the watermark doesn't survive as a byproduct of the rewrite, not because it targets the watermark.

Being precise about scope, since this matters for a developer audience: this applies to prose only. It does nothing to code logic, syntax, or structure, and you should not run it over source files expecting it to. The prose in a repo is where the watermark actually lives anyway, per section 1, so that's also where a rewrite has any effect.

The practical case for it is less about watermarks than about the same thing that motivates rewriting AI-drafted docs generally: generated documentation tends toward a recognizable register, and a rewrite that keeps your technical terms intact while varying the phrasing produces docs that read like your project rather than like any project. If your team has a documentation voice, that's worth preserving.

6. This is not the same thing as the C2PA file signature

Claude applies two different provenance mechanisms, and conflating them causes confusion. The text watermark is statistical and lives inside the word sequence. C2PA content credentials are cryptographic metadata attached to files, using the same open standard camera manufacturers use.

The survivability difference is the practical one. A text watermark survives copy-paste, because copying the text copies the pattern. C2PA metadata is attached rather than embedded, so re-saving, converting, or running a file through a pipeline that strips metadata removes it cleanly. Different mechanism, different failure mode, different implications for anything in your build process.

7. The practical takeaway

Use Claude for the draft, run a rewrite pass on the prose before it ships. That applies to documentation, READMEs, and comments, and it's a claim about text, not about code logic.

On the code itself, the honest summary is that this is a weaker signal than either the announcement or the reaction suggested. Code is low entropy, the mark barely attaches, and standard tooling degrades whatever did. The part of your repo that genuinely carries a watermark is the prose, and that's the part worth thinking about.

The useful move right now is not technical. It's writing down where your team stands on AI-assisted code before the question arrives with a specific case attached to it.

AI Humanizer API in 2026: A Developer Integration Guide

Mohab Abdelkarim — Tue, 08 Sep 2026 23:50:25 +0000

If your product generates text with a language model and ships it anywhere a detector might see it, raw model output is a liability. Humanizer APIs solve a narrow problem: take generated text, rewrite it so it reads like a person wrote it, and hand it back as JSON you can act on.

This guide covers integrating one end to end using Walter's Humanizer API, which is the most completely documented option in this category right now. The patterns transfer to any competitor with a REST surface.

What You're Actually Integrating
Getting a Key and Choosing Scopes
Your First Request
Reading the Response
Sync vs Async: Picking a Mode
The Combined Detect-and-Humanize Endpoint
A Production-Ready Wrapper
Credits, Pricing, and Cost Control
Failure Modes Worth Planning For
What the API Can't Do
FAQs

1. What You're Actually Integrating

A humanizer API takes text in, returns rewritten text out. Underneath, it restructures sentence rhythm and paragraph flow rather than swapping synonyms, which matters because detectors measure statistical properties like token predictability and sentence-length variance, not vocabulary.

Walter launched its unified API Platform in 2026, consolidating what were previously separate products behind one key and one credit balance. The available endpoints today:

/api/humanizer/ for rewriting AI text into natural output
/api/detector/ for sentence-level AI probability scoring
/api/detect-and-humanize/ for both in one call
Image detection, with voice detection, plagiarism, and grammar checking on the roadmap

Every endpoint shares the same auth, request shape, and response structure. Practically, that means adding a second endpoint later is a few lines rather than a second integration.

2. Getting a Key and Choosing Scopes

Sign in to the Developer Portal and create a key on the API Keys page. You select scopes at creation time: Humanizer, AI Detector, Image Detector, or any combination.

Two things to get right here.

Scope narrowly. If a service only humanizes, don't give its key detector scope. This is standard least-privilege practice and costs nothing to do upfront.

The full key is shown once. Copy it at creation and store it in your secrets manager immediately. There's no retrieval later.

Keys live server-side only. This is a backend integration, same reasoning as any other secret you wouldn't ship in a browser bundle.

3. Your First Request

The humanizer endpoint is a single POST:

curl -X POST https://developer-portal.walterwrites.ai/api/humanizer/ \
  -H "Content-Type: application/json" \
  -H "X-API-Key: YOUR_API_KEY" \
  -d '{
    "content": "Artificial intelligence has revolutionized numerous industries by automating complex tasks and enhancing decision-making processes."
  }'

That's the whole minimum request. Text in the content field, key in the X-API-Key header. No job setup, no queue configuration.

Note the auth scheme, because it's a common integration bug: this is a custom X-API-Key header, not Authorization: Bearer. If you're copying a wrapper from another API, that line needs changing.

4. Reading the Response

{
  "status": "success",
  "result": "AI has transformed many industries, making complex tasks automatic and improving how decisions are made.",
  "execution_time": 2.34,
  "word_count": 18,
  "credits_remaining": 1982,
  "user": {
    "id": 12345
  }
}

Four fields matter for building on this.

result is your rewritten text. status tells you whether the job completed. word_count is what you were billed for. credits_remaining is the field most integrations ignore and then regret ignoring.

Log credits_remaining on every call from day one. It's the cheapest possible quota monitoring, and it means you can alert on depletion before a pipeline starts failing rather than after. A simple threshold check costs you nothing:

if (data.credits_remaining < LOW_CREDIT_THRESHOLD) {
  logger.warn(`Walter credits low: ${data.credits_remaining} remaining`);
}

5. Sync vs Async: Picking a Mode

All service endpoints support both synchronous and asynchronous processing. Choosing correctly is mostly about where the call sits relative to a user.

Synchronous is the default. You send the request, the connection holds, the rewritten text comes back. Execution time in the example above was 2.34 seconds for 18 words. Fine for short text in a background job. Risky if a user is watching a spinner and your input is a 2,000-word article.

Async with webhooks is the right default for anything long-form or batch. Pass a callback_url and the API posts results when the job finishes:

curl -X POST https://developer-portal.walterwrites.ai/api/humanizer/ \
  -H "Content-Type: application/json" \
  -H "X-API-Key: YOUR_API_KEY" \
  -d '{
    "content": "Your long-form draft here...",
    "callback_url": "https://your-app.com/webhooks/humanizer"
  }'

Async with polling exists for environments that can't accept inbound webhooks, which covers a lot of internal tooling and local development. You get a job ID back and check it on an interval.

You can also combine webhook and polling on the same request, which is worth doing if webhook delivery reliability is a concern in your infrastructure. Belt and braces.

A practical rule: if the input is under roughly 300 words and the call is already inside a background worker, sync is simpler and there's no reason to add job-tracking complexity. Above that, or anywhere in a request path a user is waiting on, go async.

6. The Combined Detect-and-Humanize Endpoint

/api/detect-and-humanize/ is the endpoint most integrations should reach for, and it's underused because people build the two-step version first.

The naive pipeline is: score everything, then humanize everything above a threshold. That's two round trips, two sets of error handling, and you're burning credits humanizing text that was already fine. The combined endpoint collapses that into one call.

This matters for cost as much as for latency. If half your content doesn't need rewriting, humanizing all of it doubles your spend on the humanizer side for no benefit.

7. A Production-Ready Wrapper

Here's a Node wrapper with the things you'll otherwise add later after something breaks:

const WALTER_BASE = "https://developer-portal.walterwrites.ai/api";

async function humanize(content, { callbackUrl, timeoutMs = 30000 } = {}) {
  const controller = new AbortController();
  const timer = setTimeout(() => controller.abort(), timeoutMs);

  const body = { content };
  if (callbackUrl) body.callback_url = callbackUrl;

  try {
    const res = await fetch(`${WALTER_BASE}/humanizer/`, {
      method: "POST",
      headers: {
        "X-API-Key": process.env.WALTER_API_KEY,
        "Content-Type": "application/json",
      },
      body: JSON.stringify(body),
      signal: controller.signal,
    });

    if (res.status === 429) {
      const retryAfter = Number(res.headers.get("retry-after") || 5);
      throw Object.assign(new Error("rate_limited"), { retryAfter });
    }
    if (!res.ok) {
      throw new Error(`Humanizer returned ${res.status}`);
    }

    const data = await res.json();
    return {
      text: data.result,
      wordCount: data.word_count,
      creditsRemaining: data.credits_remaining,
      executionTime: data.execution_time,
    };
  } catch (err) {
    if (err.name === "AbortError") throw new Error("humanizer_timeout");
    throw err;
  } finally {
    clearTimeout(timer);
  }
}

And the Python equivalent, with exponential backoff on rate limits:

import os
import time
import requests

BASE = "https://developer-portal.walterwrites.ai/api"
HEADERS = {
    "X-API-Key": os.environ["WALTER_API_KEY"],
    "Content-Type": "application/json",
}

def humanize(content: str, callback_url: str | None = None,
             max_retries: int = 3) -> dict:
    payload = {"content": content}
    if callback_url:
        payload["callback_url"] = callback_url

    for attempt in range(max_retries):
        r = requests.post(f"{BASE}/humanizer/", headers=HEADERS,
                          json=payload, timeout=30)

        if r.status_code == 429:
            wait = int(r.headers.get("Retry-After", 2 ** attempt))
            time.sleep(wait)
            continue

        r.raise_for_status()
        data = r.json()
        return {
            "text": data["result"],
            "word_count": data["word_count"],
            "credits_remaining": data["credits_remaining"],
        }

    raise RuntimeError("humanizer: retries exhausted")

Both treat timeouts and rate limits as expected conditions rather than exceptions to handle someday. If this call sits in a publishing pipeline, a hung request must not be able to block the publish.

8. Credits, Pricing, and Cost Control

Billing is credit-based and refreshingly simple to reason about: 1 credit = 1 word for text endpoints. Image detection is priced by resolution instead.

Published tiers run from $49/month for 300,000 words up to $1,699/month for 25 million, with custom enterprise pricing above that. There's a free tier requiring no credit card, which is enough to build and test an integration before committing.

Three things that actually control cost in production:

Don't humanize what doesn't need it. Use the combined endpoint or a detection threshold. This is the single biggest lever.

Set a minimum length. Humanizing a 12-word string burns credits for negligible benefit. A floor of a couple hundred words is reasonable for most pipelines.

Cache aggressively. If the same input can be submitted twice, hash it and store the result. Re-humanizing identical text costs credits and, since these systems are largely deterministic, usually returns near-identical output anyway.

The shared credit balance across endpoints is genuinely useful here. A detect-then-humanize pipeline draws from one pool, so you're not forecasting two budgets separately.

9. Failure Modes Worth Planning For

Fail open, not closed. If humanization fails, your pipeline should log it and flag the item for review, not reject the content. An outage in a nice-to-have service should never become an outage in your core flow.

Webhook deliveries can be missed. If you're webhook-only, add a reconciliation job that polls for jobs stuck in a pending state past some threshold. Or just enable polling alongside webhooks on the same request.

Idempotency is your problem. Store a hash of the input alongside the job so a retry after a network blip doesn't submit and bill twice.

Output can shift meaning. This is the failure mode people forget because it doesn't throw an error. A rewrite can alter a technical claim, a figure, or a sentence where one word carries the argument. If your content has non-negotiable terms, check whether your tool supports phrase preservation and use it. If it doesn't, diff the output.

10. What the API Can't Do

Worth stating plainly, because the marketing in this category rarely does.

Walter publishes a 96.4% combined pass rate tested against GPTZero, Proofademic, Turnitin AI, Originality.ai, Copyleaks, and Sapling. That's a vendor-published number, and it's higher than most competitors publish, but 96.4% is not 100% and shouldn't be architected around as if it were.

The vendor's own documentation cites two papers worth reading before you build anything high-stakes on this. The RAID benchmark (arXiv 2405.07940) found humanization drops detector accuracy by 30 to 70 percentage points across multiple systems, which quantifies both how well this works and how much it varies by detector. Sadasivan et al. 2023 (arXiv 2303.11156) argued that any detector can theoretically be evaded through paraphrasing, which cuts both ways: it explains why humanizers work, and why detection-evasion is a moving target rather than a solved state.

Practically: humanizers work best on well-structured input, occasionally produce awkward phrasing that needs a human pass, and vary in effectiveness by which detector you're up against. Build a review step. Don't build a system whose correctness depends on a detection score staying below a threshold indefinitely.

11. FAQs

What authentication does the Walter Humanizer API use?
A custom X-API-Key header, not bearer tokens. Keys are created in the Developer Portal with selectable scopes, and the full key is displayed only once at creation.

Is the humanizer endpoint synchronous or asynchronous?
Both. Every service endpoint supports sync responses, async with webhook delivery via callback_url, async with polling, or webhook and polling combined on the same request.

How is usage billed?
Credit-based, at 1 credit per word for text endpoints. Image detection is priced by resolution. Every endpoint draws from a single shared monthly balance, so a detect-then-humanize pipeline doesn't require forecasting two budgets.

Can I detect and humanize in one request?
Yes, via /api/detect-and-humanize/. It's usually the better default than two separate calls, since it avoids spending humanizer credits on content that scored clean.

Is there a free tier for testing?
Yes. You can create an account, generate a key, and make your first calls with no credit card required, which is enough to build and validate an integration before choosing a paid tier.

What happens to my keywords and product names during humanization?
That depends on whether you use phrase preservation. Humanizers routinely paraphrase brand names, technical terms, and cited figures unless told not to. If exact terms matter in your output, verify preservation support before wiring this into anything automated.

Should the humanizer sit in my request path or a background job?
Background job, in almost every case. Sync execution took 2.34 seconds on an 18-word sample, and longer inputs scale from there. Anything user-facing should go async with a webhook.

DEV Community: Mohab Abdelkarim

Best Humanizer MCP Servers in 2026: Claude, ChatGPT, Cursor and Windsurf

Six servers, one question: which one lets your assistant actually rewrite and check AI text without leaving the chat or the editor?

Table of Contents

1. What Makes a Good Humanizer MCP Server

2. The Comparison at a Glance

3. Walter Writes AI MCP

4. Humanizer PRO MCP

5. Phrasly MCP

6. GPTHuman MCP Server

7. humanizer-mcp (Open Source)

8. text2go ai-humanizer-mcp-server

9. Setting Up Walter in Each Client

Claude (web and desktop)

Claude Code

ChatGPT

Cursor

Windsurf (now Devin Desktop)

Test the connection

10. Which One Should You Use?

11. Conclusion

12. FAQs

Best AI Humanizer in 2026: Ranked and Tested (Open Benchmark)

Same inputs, same detectors, every score public. Here's which AI humanizer actually held up.

Table of Contents

1. The Ranking

2. How the Benchmark Works

3. Every Score, Every Sample

4. Tool by Tool

1. Walter Writes AI: Best AI Humanizer in This Benchmark

2. Humanize AI: Strong on One Detector, Loses Content

3. Undetectable AI: Keeps Meaning, Stays Detectable

4. QuillBot AI Humanizer: Light Edits

Not ranked: WriteHuman

5. What the Benchmark Doesn't Tell You

6. Run the Benchmark Yourself

Mohabak / ai-humanizer-benchmark-2026

Open AI humanizer benchmark 2026: ranked and tested with Proofademic, ZeroGPT and Sapling. Raw scores and outputs included.

AI Humanizer Benchmark 2026

Results

7. Which AI Humanizer Should You Use?

8. Conclusion

9. FAQs

What is the best AI humanizer in 2026?

How was this AI humanizer benchmark tested?

Where can I see the raw benchmark data?

Did any humanizer pass every detector?

Which AI humanizer keeps the meaning best?

Does humanized text change the meaning?

Can I add my own tests to the benchmark?

Best AI Humanizer in 2026: A Developer's Guide to APIs, MCP and Integrations

Most "best AI humanizer" lists are written for people pasting text into a box. This one is for people wiring a humanizer into code, agents and content pipelines.

Table of Contents

1. What Makes an AI Humanizer "Best" for Developers

2. The Comparison at a Glance

3. Walter Writes AI: Best Overall for Developers

4. WriteHuman: Best for Multiple Rewrites per Call

5. Undetectable AI: Best for Readability Controls

6. Phrasly: Best for High-Volume Streaming

7. QuillBot: Fine for Writers, Not Built for Developers

8. Code: Humanizing Text With Walter's API

9. Code: Detect First, Humanize Only When Needed

10. Using a Humanizer Inside AI Agents With MCP

11. How to Choose

12. Production Tips That Apply to Every Humanizer

13. Conclusion

14. FAQs

What is the best AI humanizer in 2026?

Which AI humanizers have an API?

Is there an AI humanizer with an MCP server?

How much does an AI humanizer API cost?

Is there a free AI humanizer API?

What's the maximum length for one request?

Can a humanizer keep my SEO keywords?

How do I install Walter Skills?

Plagiarism Checker API: Adding Originality Checks to Your App

One POST request gets you a score, a verdict, the sources that matched, and the exact passages to highlight. Here's how to build it into a real product.

Table of Contents

1. What a Plagiarism Checker API Gives You

2. Getting an API Key

A note on `url` vs `httpUrl`