If your content pipeline produces AI-generated drafts and something downstream — a detector, a reviewer, a publishing checklist — keeps flagging them as AI, the fix usually isn't another manual copy-paste step. It's a single HTTP call. This is the integration pattern for wiring an AI humanizer API into n8n, Zapier, and an MCP-capable agent, with the exact request shapes so you can copy-paste and run them.
Originally published on the ToHuman blog — cross-posting here because the n8n/Zapier/MCP integration patterns below are exactly the kind of thing this community builds with daily.
An AI humanizer API is a REST endpoint that takes AI-generated text, runs it through a model fine-tuned to remove the patterns detectors flag, and returns a version that reads like it was written by a person. This post walks the integration pattern using the free ToHuman API as the reference endpoint: a single POST /api/v1/humanizations/sync
call for anything under ~2,000 words, an async endpoint with webhook callbacks for longer content, and the exact node/action configuration for n8n, Zapier, and an MCP tool.
An AI humanizer API is an HTTP endpoint that accepts AI-generated text as input and returns a rewritten version designed to bypass AI-detection tools like GPTZero, Turnitin AI, Originality.ai, and Copyleaks. Under the hood it runs a purpose-built model — usually a fine-tuned open-weight LLM such as Mistral 7B or Llama — trained on paired data of AI-written and human-written text. The endpoint's job is one thing: change surface patterns (sentence rhythm, connective tissue, punctuation, entropy signatures) enough that the detector's classifier drops below its "AI-written" threshold, while preserving meaning.
Two things it is not:
Every humanizer API in the category follows one of two request shapes: sync (send text, wait, get result) or async (send text, get job ID, receive result later). This guide uses ToHuman's endpoints as the reference — they're free, so you can copy-paste and run the examples without paying anything.
Sync request (default — anything under ~2,000 words):
POST https://tohuman.io/api/v1/humanizations/sync
Authorization: Bearer YOUR_API_KEY
Content-Type: application/json
{
"content": "Your AI-generated text goes here.",
"intensity": "medium"
}
Response:
{
"id": 42,
"document_id": 15,
"status": "completed",
"intensity": "medium",
"output_content": "The rewritten version...",
"processing_time": 1.42
}
Four intensity values: minimal
, subtle
, medium
, heavy
. medium
is the default for raw model output; heavy
is for text that consistently fails GPTZero.
Async request (content over ~2,000 words, or batches):
POST https://tohuman.io/api/v1/humanizations
Authorization: Bearer YOUR_API_KEY
Content-Type: application/json
{
"content": "Long article text...",
"intensity": "heavy",
"webhook_url": "https://your-app.com/webhooks/humanize"
}
The response returns a job ID. When the humanization finishes, ToHuman POSTs the result back to your webhook_url
:
{
"event": "humanization.completed",
"humanization": {
"id": 43,
"status": "completed",
"output_content": "The humanized text...",
"processing_time": 3.87
}
}
n8n doesn't have a dedicated ToHuman node, but it doesn't need one — the built-in HTTP Request node handles any REST endpoint.
Minimal setup: a Manual Trigger (or Schedule Trigger), a Set node with test text, and an HTTP Request node pointed at the humanizer.
Credentials: Settings → Credentials → New Credential → Header Auth, header name Authorization
, value Bearer YOUR_API_KEY
.
HTTP Request node config:
POST
https://tohuman.io/api/v1/humanizations/sync
{
"content": "{{ $('OpenAI').item.json.message.content }}",
"intensity": "medium"
}
For content over ~2,000 words, swap to the async endpoint and add a webhook_url
pointing at a Webhook trigger node. Full walkthrough (proof-of-concept, automated blog pipeline, async batch): n8n humanize AI text tutorial.
Zap configuration:
https://tohuman.io/api/v1/humanizations/sync
json
Authorization
= Bearer YOUR_API_KEY
content
(mapped from the previous step), intensity
(medium
/heavy
/subtle
/minimal
)Full pattern including CMS-publish step: Zapier humanize AI text tutorial.
The Model Context Protocol lets an agent call external tools directly during its own reasoning loop — no separate pipeline step.
from mcp.server.fastmcp import FastMCP
import httpx
import os
mcp = FastMCP("tohuman")
API_KEY = os.environ["TOHUMAN_API_KEY"]
API_URL = "https://tohuman.io/api/v1/humanizations/sync"
@mcp.tool()
async def humanize_text(content: str, intensity: str = "medium") -> str:
"""Rewrite AI-generated text to bypass AI detection."""
async with httpx.AsyncClient() as client:
resp = await client.post(
API_URL,
headers={"Authorization": f"Bearer {API_KEY}"},
json={"content": content, "intensity": intensity},
timeout=30.0,
)
resp.raise_for_status()
return resp.json()["humanized_text"]
if __name__ == "__main__":
mcp.run()
Register the server with Claude Desktop (or your MCP client) pointing at python server.py
, TOHUMAN_API_KEY
in the environment. Full walkthrough (config JSON, streaming, metadata variant): MCP server humanize AI text tutorial.
Full six-provider breakdown: ToHuman AI humanizer API comparison.
Authorization
header, usually a missing "Bearer" or stale rotated key.intensity
value or empty content
.heavy
intensity; heavy list/table/code formatting resists most humanizers.Full guide with FAQ schema and sources: tohuman.io/blog/humanize-ai-text-api-automation-guide-2026