AI Humanizer API: The Developer Guide

The ToHuman AI Humanizer API is a REST endpoint that takes AI-generated text and rewrites it to sound naturally human. If you're building a content pipeline, a CMS integration, or an internal tool that produces AI-generated text, a web form isn't going to cut it — you need an AI humanizer API you can call directly from code.

This guide walks through everything you need to start using the AI humanizer API: getting your free API key, making your first request, handling the response, and scaling up to batch processing hundreds of documents concurrently.

Why an API Instead of a Web Tool

Most AI humanizers are web apps. You paste text into a box, click a button, copy the output. That workflow works for occasional use, but it breaks down quickly when you need to:

• Humanize content as part of an automated publishing pipeline
• Process batches of documents without manual intervention
• Integrate humanization into a CMS, WordPress plugin, or CI/CD workflow
• Build humanization into your own product as a feature

Several competitors have announced API access but haven't shipped it, or charge significant premiums for it — StealthGPT's API access starts at $99/month, positioned as an enterprise add-on. ToHuman was built API-first from day one, and the API is currently free during the launch period. If you're evaluating this for a team or content pipeline, see why B2B teams are buying AI humanizer APIs in 2026 — it covers vendor criteria, architecture patterns, and the business case.

Getting Started

1. Get your API key

Sign up for a free account at tohuman.io. Once you're logged in, your API key is available in the dashboard. It's a standard Bearer token — store it in an environment variable, not in your code.

2. Your first request

The API has a single endpoint for synchronous humanization:

POST https://tohuman.io/api/v1/humanizations/sync

Here's the simplest possible request with curl:

curl -X POST https://tohuman.io/api/v1/humanizations/sync \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "content": "Artificial intelligence has revolutionized numerous industries by enabling automation of complex tasks that previously required human intervention.",
    "intensity": "medium"
  }'

{
  "humanized_text": "AI has quietly reshaped how entire industries operate — taking over complex work that used to demand a human in the loop.",
  "intensity": "medium",
  "word_count": 28
}

Request Parameters

The request body accepts two fields:

• content (required) — The text to humanize. Plain text, any length.
• intensity (required) — How aggressively to rewrite. One of: minimal, subtle, medium, heavy.

Authentication uses a standard Authorization: Bearer <token> header.

Intensity Levels Explained

The intensity parameter controls how much the model changes the input. Here's what each level does in practice.

minimal — Light polish, structure mostly preserved

Adjusts word choice and smooths phrasing without restructuring sentences. Good for text that's already fairly natural but needs the AI signature softened.

Input: "The implementation of machine learning algorithms has enabled significant advancements in predictive analytics capabilities."

Output: "Machine learning has opened up a lot of ground in predictive analytics."

subtle — Sentence-level rewrites, meaning unchanged

Restructures individual sentences and varies rhythm. Still conservative — won't change your argument or reorder your content.

Input: "There are several key factors to consider when evaluating cloud infrastructure options for enterprise deployments."

Output: "Picking the right cloud infrastructure for an enterprise deployment comes down to a handful of things that matter more than the rest."

medium — The default for most use cases

Full sentence rewrites with natural variation in structure, length, and tone. Preserves meaning and information while addressing the patterns detectors flag. Works well for blog posts, articles, and marketing copy.

heavy — Thorough rewrite, aggressive humanization

The model takes more liberties — merging short sentences, breaking up long ones, adding light conversational texture. Use this for content that scores high on AI detectors or for output from models that write in a particularly recognizable style.

A note on heavy: it changes more, so verify the output preserves the specific claims or technical details in your original. It's excellent for general content; for anything with precise figures or specifications, review the result.

Python Example

import os
import requests

TOHUMAN_API_KEY = os.environ["TOHUMAN_API_KEY"]
API_URL = "https://tohuman.io/api/v1/humanizations/sync"

def humanize(text: str, intensity: str = "medium") -> str:
    response = requests.post(
        API_URL,
        headers={
            "Authorization": f"Bearer {TOHUMAN_API_KEY}",
            "Content-Type": "application/json",
        },
        json={"content": text, "intensity": intensity},
        timeout=30,
    )
    response.raise_for_status()
    return response.json()["humanized_text"]


# Basic usage
original = """
Large language models have demonstrated remarkable capabilities across
a wide range of natural language processing tasks, including text
generation, summarization, and question answering.
"""

result = humanize(original, intensity="medium")
print(result)

JavaScript / Node.js Example

const API_KEY = process.env.TOHUMAN_API_KEY;
const API_URL = "https://tohuman.io/api/v1/humanizations/sync";

async function humanize(text, intensity = "medium") {
  const response = await fetch(API_URL, {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ content: text, intensity }),
  });

  if (!response.ok) {
    const error = await response.json().catch(() => ({}));
    throw new Error(`API error ${response.status}: ${error.message ?? "unknown"}`);
  }

  const data = await response.json();
  return data.humanized_text;
}

// Usage
const result = await humanize(
  "The utilization of advanced algorithms facilitates enhanced operational efficiency.",
  "heavy"
);
console.log(result);

Building a Batch Processing Pipeline

If you're processing a content library — say, a backlog of AI-drafted articles — you'll want to run requests concurrently rather than sequentially. Here's a Python example using asyncio and aiohttp that processes a list of documents in parallel:

import os
import asyncio
import aiohttp

TOHUMAN_API_KEY = os.environ["TOHUMAN_API_KEY"]
API_URL = "https://tohuman.io/api/v1/humanizations/sync"

async def humanize_one(session, text: str, intensity: str = "medium") -> str:
    async with session.post(
        API_URL,
        headers={"Authorization": f"Bearer {TOHUMAN_API_KEY}"},
        json={"content": text, "intensity": intensity},
    ) as response:
        response.raise_for_status()
        data = await response.json()
        return data["humanized_text"]

async def humanize_batch(documents: list[str], intensity: str = "medium") -> list[str]:
    async with aiohttp.ClientSession() as session:
        tasks = [humanize_one(session, doc, intensity) for doc in documents]
        return await asyncio.gather(*tasks)

# Usage
documents = [
    "Artificial intelligence enables organizations to automate repetitive tasks...",
    "The implementation of cloud computing solutions has transformed data storage...",
    "Machine learning models require substantial training data to achieve accuracy...",
]

results = asyncio.run(humanize_batch(documents, intensity="medium"))
for original, humanized in zip(documents, results):
    print(f"Original: {original[:60]}...")
    print(f"Humanized: {humanized[:60]}...")
    print()

Integration Patterns

WordPress: Humanize on publish

Use WordPress's wp_insert_post hook to intercept content before it's saved. Call the ToHuman API on the post content, then save the humanized version. A basic PHP snippet:

add_filter('wp_insert_post_data', function ($data, $postarr) {
    if ($data['post_status'] !== 'publish') return $data;
    if (empty($data['post_content'])) return $data;

    $response = wp_remote_post('https://tohuman.io/api/v1/humanizations/sync', [
        'headers' => [
            'Authorization' => 'Bearer ' . TOHUMAN_API_KEY,
            'Content-Type'  => 'application/json',
        ],
        'body'    => wp_json_encode([
            'content'   => wp_strip_all_tags($data['post_content']),
            'intensity' => 'medium',
        ]),
        'timeout' => 30,
    ]);

    if (!is_wp_error($response)) {
        $body = json_decode(wp_remote_retrieve_body($response), true);
        if (!empty($body['humanized_text'])) {
            $data['post_content'] = $body['humanized_text'];
        }
    }

    return $data;
}, 10, 2);

CMS webhook: Humanize on content creation events

If your CMS (Contentful, Sanity, Strapi, etc.) supports webhooks, set up a listener that fires on content creation. The listener calls the ToHuman API and writes the humanized version back to the CMS via its management API. This keeps humanization out of your application code and runs it as an infrastructure concern.

CI/CD: Gate on AI detection score

For teams running AI detection checks as part of a content review pipeline, you can insert a humanization step before the detection check. If a document's AI score exceeds a threshold, the pipeline calls the ToHuman API at the appropriate intensity level and re-checks. Automates the feedback loop entirely.

Error Handling

The API returns standard HTTP status codes:

• 200 — Success. The humanized_text field contains the result.
• 401 — Invalid or missing API key. Check your Authorization header.
• 422 — Request validation failed. Usually means content is empty or intensity isn't one of the accepted values.
• 500 — Server error. Retry with exponential backoff.

For production integrations, implement retry logic on 5xx errors. A simple strategy: retry up to three times with 1s, 2s, and 4s delays. Don't retry 4xx errors — those are problems with the request itself.

import time
import requests

def humanize_with_retry(text: str, intensity: str = "medium", max_retries: int = 3) -> str:
    for attempt in range(max_retries):
        try:
            response = requests.post(
                "https://tohuman.io/api/v1/humanizations/sync",
                headers={
                    "Authorization": f"Bearer {os.environ['TOHUMAN_API_KEY']}",
                    "Content-Type": "application/json",
                },
                json={"content": text, "intensity": intensity},
                timeout=30,
            )
            if response.status_code < 500:
                response.raise_for_status()
                return response.json()["humanized_text"]
            # 5xx: retry
            if attempt < max_retries - 1:
                time.sleep(2 ** attempt)
        except requests.exceptions.Timeout:
            if attempt < max_retries - 1:
                time.sleep(2 ** attempt)
    raise RuntimeError("ToHuman API failed after max retries")

Performance Tips

Batch concurrently, not sequentially. Each API call is independent. If you have 50 documents, run them concurrently — don't wait for each one to finish before starting the next. The async batch example above shows the pattern in Python. In Node.js, use Promise.all.

Chunk long documents. Very long pieces of content can be split into sections (by heading, paragraph, or a fixed character count), processed in parallel, then reassembled. This also gives you finer control — you can use different intensity levels for the introduction versus the body, for instance.

Cache results where appropriate. If you're processing the same AI-generated template repeatedly, cache the humanized version. The model is deterministic at the same intensity level, but not perfectly so — repeated calls on identical input will produce similar but not always identical output. Cache by input hash if consistency matters.

Set appropriate timeouts. The API processes synchronously on dedicated RunPod compute. Longer documents take longer. Set a timeout of at least 30 seconds for documents over 1,000 words, and consider 60 seconds for very long content.

If you're running a no-code automation stack, see the n8n integration tutorial — it covers how to use the HTTP Request node to connect ToHuman to any n8n workflow, including a full blog publishing pipeline.

API vs. Web Tool: The Honest Comparison

If you occasionally humanize a blog post, the web app at tohuman.io is the right tool. The API is for use cases where manual steps are a bottleneck.

Most competitors don't offer an API at all — Humanize AI Pro, QuillBot, and Phrasly are all web-only. StealthGPT offers API access but reserves it for their highest-tier plan. Undetectable.ai has limited API access that isn't well-documented and has reliability complaints on forums. If you're comparing humanizer tools before committing to an API integration, see the best Undetectable AI alternatives guide.

ToHuman built the API first. The web app is built on top of the same endpoint you're calling here. That means the API is a first-class product, not an enterprise upsell.

The full API reference is at tohuman.io/docs — it covers authentication, all endpoints, error codes, and rate limits.

Frequently Asked Questions

What is the ToHuman AI Humanizer API?

The ToHuman AI Humanizer API is a REST endpoint that takes AI-generated text and rewrites it to sound naturally human. You POST content and an intensity level to https://tohuman.io/api/v1/humanizations/sync with a Bearer token, and the API returns the humanized text synchronously. It's powered by a self-hosted fine-tuned Mistral 7B model — no OpenAI, no third-party AI providers, and nothing is stored after the response is returned.

How do I use the AI humanizer API?

Three steps: (1) sign up for a free ToHuman account and copy your API key from the dashboard, (2) issue an HTTP POST to https://tohuman.io/api/v1/humanizations/sync with an Authorization: Bearer header and a JSON body containing content and intensity, (3) parse the humanized_text field from the response. Copy-paste code blocks for cURL, Python, Node.js, Ruby, and PHP are above in this guide.

What are the AI humanizer API rate limits?

During ToHuman's launch period, the AI humanizer API is free with no rate limits. Requests are processed synchronously on dedicated GPU compute with average latency of 3 to 5 seconds. Concurrent requests are not throttled — run as many in parallel as your client can issue. For production use at high sustained throughput, contact support for dedicated capacity.

Is the AI humanizer API free to use?

Yes, during ToHuman's launch period. Sign up to get a key — no credit card required.

Which intensity level should I use?

It depends on how AI-patterned the input is. For lightly assisted drafts, minimal or subtle is usually enough. For outputs from ChatGPT or similar models, medium or heavy will produce more consistently human-sounding results. When in doubt, start at medium.

Can I process multiple documents in batch?

Yes. The API is a standard HTTP endpoint, so you can issue requests concurrently using asyncio in Python, Promise.all in Node.js, or a parallel job queue in any language. See the batch processing example above.

Does ToHuman store the text I send through the API?

No. Text is processed by ToHuman's own fine-tuned Mistral 7B model running on dedicated cloud compute. Nothing is stored after the response is returned, and no external AI APIs are used in processing.