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

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. A dedicated humanizer API is narrower and more predictable.
• It is not magic. The best humanizer APIs bypass most detectors most of the time, but no provider hits 100%, and detectors update. Any content pipeline that treats a humanizer API's output as automatically safe without a review step will eventually publish something a detector still flags.

The category is small and mostly buyer-focused. We compared the six leading providers side-by-side in our best AI humanizer API in 2026 breakdown — free tiers, endpoint shape (sync vs async), rate limits, language coverage, and per-call payload limits. This guide is the how-to companion to that comparison: given you've picked a humanizer API, how do you actually wire it into your stack?

Glossary — six terms you'll see in every humanizer API doc

Why call a humanizer API instead of just prompting ChatGPT?

You can absolutely prompt a general LLM to "rewrite this text to sound less like AI." Sometimes it works. More often, three things go wrong.

Prompted rewrites drift. A general LLM optimizes for whatever you asked for in that specific prompt. Ask for "less AI-sounding" and it might soften the tone, drop hedges, or add casual filler — none of which necessarily changes the tokens that a classifier is scoring on. You've made the text sound different to a human reader without moving the detector needle.

Prompted rewrites are inconsistent. The same input, prompted the same way, at temperature 0.7, will produce different outputs on different days. In a pipeline that runs 50 humanization calls per day, inconsistency shows up as a distribution of quality where some outputs pass detection and some don't, with no obvious pattern.

Prompted rewrites route your content through third parties. Every OpenAI or Anthropic call sends the text to their servers under their retention policy. That's fine for public marketing copy, less fine for anything sensitive. Purpose-built humanizer APIs — ToHuman being one — run self-hosted models and don't route your text through OpenAI or Anthropic to do the rewrite.

A dedicated humanizer API is narrower and more predictable because the model has been fine-tuned on paired data of what detectors flag versus what they don't. In our comparison of the six leading humanizer APIs, all five providers with public APIs use dedicated models; none is a ChatGPT wrapper. That's the category convention, not an implementation detail.

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). For AI humanizer APIs, this guide uses ToHuman's endpoints as the reference — they follow the sync/async pattern and are free, so you can copy-paste the examples and run them 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
}

The humanized text is in output_content — that's the field to reference downstream. Four intensity values are accepted: minimal, subtle, medium, and heavy. medium is the default for raw model output. heavy is what you reach for on text that consistently fails GPTZero. subtle is for content a human has already edited. minimal smooths residual patterns without touching structure.

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 in this shape:

{
  "event": "humanization.completed",
  "humanization": {
    "id": 43,
    "status": "completed",
    "output_content": "The humanized text...",
    "processing_time": 3.87
  }
}

That's every field you actually need to build against. Full reference — including error codes, retry semantics, and rate-limit headers — lives in the ToHuman API docs and the deeper walkthrough in the API integration tutorial.

Integrating with n8n — the HTTP Request node pattern

n8n is the most common self-hosted automation platform in the developer community, with over 230,000 active users and 400+ native integrations. It doesn't have a dedicated ToHuman node, but it doesn't need one — the built-in HTTP Request node handles any REST endpoint.

The minimal setup is three nodes: a Manual Trigger (or Schedule Trigger for scheduled runs), a Set node to provide test text, and an HTTP Request node pointed at the humanizer.

Credentials setup. In n8n, go to Settings → Credentials → New Credential. Choose Header Auth, set the header name to Authorization, and the value to Bearer YOUR_API_KEY. Save it as "ToHuman API." Storing the key in n8n's credential system keeps it out of your workflow JSON and lets you rotate it in one place.

HTTP Request node configuration:

• Method: POST
• URL: https://tohuman.io/api/v1/humanizations/sync
• Authentication: Predefined Credential → Header Auth → "ToHuman API"
• Body Content Type: JSON
• Body (use JSON/RAW mode):

{
  "content": "{{ $('OpenAI').item.json.message.content }}",
  "intensity": "medium"
}

The {{ }} expression pulls the generated text from an upstream OpenAI node. In downstream nodes, reference the humanized result as {{ $('HTTP Request').item.json.output_content }}.

For content longer than ~2,000 words, swap the URL to the async endpoint (/api/v1/humanizations without the /sync suffix) and add a webhook_url field pointing to a Webhook trigger node in a receiving workflow. Full walkthrough with all three workflows — proof-of-concept, automated blog pipeline, async batch — in the n8n humanize AI text tutorial.

Integrating with Zapier — Webhooks by Zapier

Zapier doesn't require self-hosting and works well for non-developer teams. The equivalent to n8n's HTTP Request node is the Webhooks by Zapier built-in action.

Zap configuration:

1. Add a trigger — RSS, Google Sheets, Airtable, or an AI generation step (OpenAI, Anthropic).
2. Add a Webhooks by Zapier → POST action.
3. Set URL to https://tohuman.io/api/v1/humanizations/sync.
4. Set Payload Type to json.
5. Add header: Authorization = Bearer YOUR_API_KEY.
6. In the Data section, add two fields:
   • content — mapped to the AI-generated text field from the previous step
   • intensity — medium (or heavy, subtle, minimal)

Downstream steps reference the response with the output_content field mapping in the field picker.

If you're routing different content types through different intensity levels (blog posts on medium, email copy on subtle, sales pages on heavy), add a Paths by Zapier step before the Webhooks action and configure a separate Webhooks call per branch. The full pattern — including the CMS-publish step for automated blog pipelines — is covered in the Zapier humanize AI text tutorial.

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

The Model Context Protocol lets an AI agent (Claude Desktop, Cursor, a custom agent) call external tools directly. Wiring a humanizer API into MCP means an agent can rewrite AI-generated text as part of its own reasoning loop — no separate pipeline step, no human copy-paste.

The pattern is a Python MCP server that exposes one tool, humanize_text, which POSTs to the humanizer API:

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

    Args:
        content: The AI-generated text to humanize.
        intensity: One of 'minimal', 'subtle', 'medium', 'heavy'.
    Returns:
        The humanized text.
    """
    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()["output_content"]

if __name__ == "__main__":
    mcp.run()

Register the server with Claude Desktop (or your MCP-capable client) by pointing its config file at python server.py and setting TOHUMAN_API_KEY in the environment. From then on, the agent can call humanize_text on its own outputs before returning them to you — no pipeline glue, no external orchestration.

The full walkthrough — including the Claude Desktop config JSON, streaming responses, and a version of the tool that returns metadata alongside the humanized text — is in the MCP server humanize AI text tutorial.

Which pattern do you want — sync, async, or MCP?

Three questions to decide.

1. Is the humanization step in a user-facing request path? If a user clicks a button and waits for the humanized output, use sync. Anything else adds latency the user notices. n8n's HTTP Request node with the /sync endpoint is the shortest path.

2. Is the content routinely over ~2,000 words? If yes, use async with webhooks. The sync endpoint will 422 or truncate on very long inputs, and even if it doesn't, holding an HTTP connection open for 30+ seconds while a long document processes is a fragile pattern. Async + webhook lets the humanizer take its time and calls you back when done.

3. Is the caller an AI agent making its own decisions? If yes, expose the humanizer as an MCP tool. Then the agent chooses when to humanize (usually right before writing to a file, sending an email, or posting to a CMS) without you hard-coding that step into a pipeline. This is the pattern most Claude Desktop users end up on once they've tried the other two.

Free tier vs paid — what "free API" actually means in this category

"Free" varies wildly across the six providers on the market. The gap matters because the humanization category is one where you cannot evaluate quality without running your own content through the API. 250 words — the industry-standard trial size — is enough to confirm the endpoint responds and nowhere close to enough to evaluate output.

• ToHuman: free forever, no monthly word quota, no credit card. Rate-limited on a soft ~30 requests/second ceiling; sustained higher traffic should coordinate with the team.
• Undetectable.ai: 250-word trial, then $9.99/mo for 10,000 words.
• WriteHuman: no free tier at all. Cheapest paid entry is $29/mo for 125,000 words.
• Humbot: 250-word trial, then $30/mo for 50,000 words. Best pick for non-English content — 50+ languages.
• StealthGPT: no upfront commit, but billing kicks in on first request at $0.20 per 1,000 charged words. Highest published throughput ceiling (3,500 requests/minute).
• Walter Writes: no public API as of publish date — early-access waitlist only.

If your goal is to test integration end-to-end without a purchase decision, ToHuman is the practical starting point because it's the only one where you can run production traffic on the free tier while you evaluate. When you're ready to compare bypass rates against your own detector, our six-provider API comparison is the buy-time-decision doc.

Common failure modes when integrating

Five things go wrong in first-time integrations. All five are easy to fix if you know what you're looking for.

401 Unauthorized. The Authorization header is malformed. Most common cause: the word "Bearer" is missing, or there's no space between "Bearer" and the token. Second most common cause: the key was regenerated in the dashboard and the workflow is still using the old one.

422 Unprocessable Entity. The body is malformed. Check that intensity is spelled correctly and is one of the four valid values (minimal, subtle, medium, heavy) — a typo like moderate or strong will 422. Also check that content is a non-empty string.

Truncated humanization on long input. The sync endpoint has a soft ceiling around 2,000 words. Above that, either chunk on paragraph boundaries and reassemble, or switch to the async endpoint. Chunking is fine for editorial pipelines; async is cleaner for anything running in a job queue.

Output still fails the detector. Try heavy intensity. If that still doesn't clear it, the input has structural features (heavy list formatting, tables, code blocks) that most humanizers can't rewrite because rewriting them would change the semantics. Convert lists to paragraphs before humanizing, then reformat after.

Detector updates break the pipeline. Detectors update. What passed GPTZero last month may not pass this month. Any pipeline that assumes a single humanization pass will pass all detectors indefinitely is set up to be surprised. The right pattern is a periodic re-check on your own content and a fallback path — usually a human-review queue — for anything that fails.

Frequently Asked Questions

What is an AI humanizer API?

An AI humanizer API is a REST endpoint that accepts AI-generated text and returns a rewritten version designed to bypass AI-detection tools like GPTZero, Turnitin AI, and Originality.ai. It typically runs a model fine-tuned specifically on paired AI-vs-human text, rather than a general-purpose LLM like ChatGPT.

Is there a free AI humanizer API?

Yes. As of July 2026, ToHuman offers a free-forever tier with no monthly word quota and no credit card required. Other providers offer trial allowances (250 words on Undetectable.ai and Humbot), pay-as-you-go from the first request (StealthGPT at $0.20 per 1,000 words), or no free tier at all (WriteHuman, minimum $29/mo).

Can I use an AI humanizer API with n8n?

Yes. Use the built-in HTTP Request node — no custom integration needed. Configure a POST request to the humanizer's endpoint (for example, https://tohuman.io/api/v1/humanizations/sync), add your API key as a Header Auth credential, and send a JSON body with content and intensity fields. See the full walkthrough in our n8n humanize AI text tutorial.

Can I use an AI humanizer API with Zapier?

Yes, via the Webhooks by Zapier action. Set the URL to the humanizer's sync endpoint, add an Authorization header, and pass the AI-generated text and intensity in the Data section. Detailed instructions with three sample Zaps are in our Zapier humanize AI text tutorial.

How do I expose a humanizer API as an MCP tool for Claude Desktop or Cursor?

Build a small Python MCP server using FastMCP that exposes a humanize_text tool. The tool makes a POST request to the humanizer API and returns the humanized text. Register the server in your MCP-capable client's config and the agent can call the tool during its reasoning loop. Full example in our MCP server humanize AI text tutorial.

How does an AI humanizer API differ from prompting ChatGPT to rewrite text?

Purpose-built humanizer APIs run models fine-tuned specifically on the patterns AI detectors flag. General-purpose LLMs like ChatGPT and Claude can be prompted to rewrite text but were not trained against detector signals, so results are inconsistent from call to call and often don't move the detector needle even when the output reads differently to a human. Dedicated humanizer APIs also typically don't route your text through OpenAI or Anthropic, which matters for sensitive content.

What's the difference between the sync and async humanizer API endpoints?

Sync endpoints (e.g. /api/v1/humanizations/sync) block until the humanization is complete and return the result in the same HTTP response — typically within 3–15 seconds. Async endpoints accept a webhook_url and return a job ID immediately; when processing finishes, the API POSTs the result back to your webhook. Use sync for user-facing requests under ~2,000 words; use async for batch jobs, long documents, or fire-and-forget pipelines.

Related Reading

• The best AI humanizer API in 2026 — six providers compared — free tiers, endpoint shape, rate limits, and language coverage across the category.
• n8n humanize AI text tutorial — three complete n8n workflows, from proof-of-concept to async batch.
• Zapier humanize AI text tutorial — the Webhooks-by-Zapier pattern plus a CMS-publish pipeline.
• MCP server humanize AI text tutorial — the full MCP server, Claude Desktop config, and metadata-returning tool variant.
• Why B2B content teams are buying AI humanizer APIs in 2026 — the buyer-side view of the same category.