How to Humanize AI Text with an API: n8n, Zapier & MCP Integration Guide

#webdev #ai #automation #api

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.

TL;DR

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.

What is an AI humanizer API?

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:

It is not a general-purpose LLM. ChatGPT and Claude can be prompted to "rewrite this to sound more human," but they weren't trained against detector signals, so results are inconsistent from call to call.
It is not magic. The best humanizer APIs bypass most detectors most of the time, but no provider hits 100%, and detectors update.

The canonical REST pattern — one endpoint, one JSON body

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

Integrating with n8n — the HTTP Request node pattern

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:

Method: POST
URL: https://tohuman.io/api/v1/humanizations/sync
Authentication: Predefined Credential → Header Auth
Body Content Type: JSON

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

Integrating with Zapier — Webhooks by Zapier

Zap configuration:

Add a trigger — RSS, Google Sheets, Airtable, or an AI generation step.
Add a Webhooks by Zapier → POST action.
URL: https://tohuman.io/api/v1/humanizations/sync
Payload Type: json
Header: Authorization = Bearer YOUR_API_KEY
Data fields: content (mapped from the previous step), intensity (medium/heavy/subtle/minimal)

Full pattern including CMS-publish step: Zapier humanize AI text tutorial.

Integrating as an MCP tool — Claude Desktop, Cursor, custom agents

The Model Context Protocol lets an agent call external tools directly during its own reasoning loop — no separate pipeline step.

# server.py
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.

Which pattern — sync, async, or MCP?

User-facing request path? → sync.
Content routinely over ~2,000 words? → async + webhooks.
Caller is an agent making its own decisions? → expose as an MCP tool.

Free tier vs paid

ToHuman: free forever, no monthly word quota, no card. Soft ~30 req/sec rate limit.
Undetectable.ai: 250-word trial, then $9.99/mo for 10,000 words.
WriteHuman: no free tier. Cheapest paid: $29/mo for 125,000 words.
Humbot: 250-word trial, then $30/mo for 50,000 words. Best for non-English (50+ languages).
StealthGPT: pay-as-you-go from first request, $0.20/1,000 words. Highest published throughput (3,500 req/min).
Walter Writes: no public API — waitlist only.

Full six-provider breakdown: ToHuman AI humanizer API comparison.

Common failure modes

401 Unauthorized — malformed Authorization header, usually a missing "Bearer" or stale rotated key.
422 Unprocessable Entity — bad intensity value or empty content.
Truncated output on long input — sync endpoint has a soft ~2,000-word ceiling; chunk or switch to async.
Still fails the detector — try heavy intensity; heavy list/table/code formatting resists most humanizers.
Detector updates break the pipeline — build in periodic re-checks + a human-review fallback.