# AI Humanizer — Humanize AI Text (`khadinakbar/ai-text-humanizer`) Actor

Humanize AI Text into clear, natural, SEO-friendly and undetectable content.

- **URL**: https://apify.com/khadinakbar/ai-text-humanizer.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** AI, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $700.00 / 1,000 humanized text (long text or seo)s

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### AI Text Humanizer — Write Naturally

Give stiff or repetitive drafts a more natural flow. Paste your text, choose how you want to rewrite it, and check the price before you start. You can work on one paragraph or a batch of drafts, then download the results for a final read-through.

Use it for emails, articles, product copy and other writing you are authorized to edit, including drafts from ChatGPT or Claude. The rewrite comes with a comparison of numbers, length and wording to help you decide what needs another look. Read the result in context before sharing it.

### Find the right fit

| Mode | What it is for | API value |
| --- | --- | --- |
| **Humanizer v4** | Recommended for natural phrasing and varied sentences, with output length close to the original draft. | `premium` |
| **Meaning Preserver** | Prioritizes the original meaning and a similar length. Suited to technical writing, facts and figures. | `precision` |
| **Humanizer v3** | Rewrite in a creative, journalistic or professional voice. Choose the style that fits your draft. | `balanced` |
| **Undetectable Pro** | Rewrites AI-generated drafts with AI detection checks in mind. | `deep` |
| **SEO Model** | Rework blog posts and website copy with keyword-aware, conversational phrasing. | `seo` |

Humanizer v3 offers four style settings: default, creative, journalistic and professional. The other modes use their default style. Leave language set to auto to keep the draft's language, or enter an output language such as English.

All five modes accept up to 12,000 characters per text. Longer drafts can be split into separate texts.

### Pricing, before you begin

Pay per event, with platform usage included. The live Pricing tab is the source of truth for current prices. Each run has a **$0.0025 start fee**, plus a charge for each successfully saved, distinct rewrite.

| Rewrite | Per result |
| --- | ---: |
| Humanizer v4, Meaning Preserver, Humanizer v3 or Undetectable Pro: up to 20 words | $0.10 |
| The same four modes: 21–100 words | $0.16 |
| The same four modes: over 100 words | $0.70 |
| SEO Model, at any length | $0.70 |

Words are counted by whitespace in the trimmed draft. Submit up to 20 texts per run. Repeated drafts, after trimming surrounding whitespace, share one result and one result charge. The current Pricing tab shows the effective prices; account subscription fees and taxes follow your Apify terms.

One non-SEO rewrite of up to 20 words costs **$0.1025 including startup**. A batch of 20 distinct drafts of up to 20 words each costs **$2.0025**. A 21–100-word non-SEO rewrite costs $0.1625 including startup.

To check the price first, select **Preview price** under **Action** (`operation: "quote"`). The preview shows distinct-text counts, per-item event names and prices, duplicate input positions and the complete rewrite total. A preview costs the $0.0025 start fee and sends no text to the rewriting service. A later rewrite is a separate run with its own start fee. Previewing and rewriting one non-SEO draft of up to 20 words therefore costs $0.105 in total.

### Quick start: humanize your text

```json
{
  "text": "Our team makes practical tools for busy people. We listen to customer feedback and test each change carefully.",
  "operation": "quote",
  "mode": "balanced",
  "style": "professional",
  "language": "auto",
  "additionalTexts": [],
  "includeOriginal": true
}
```

Check `OUTPUT.quote.totalChargeUsd`, then choose **Humanize text** under **Action** (`operation: "humanize"`) to rewrite the same drafts. Add up to 19 more strings in **Additional texts** (`additionalTexts`). They use the same mode, style and language. Turn on **Include original text** (`includeOriginal`) to keep each original beside its rewrite for comparison.

### Workflow: from draft to finished copy

For example, a content team can collect several introductions, preview the batch price in Humanizer v3, then rewrite with a professional style. The returned input positions keep each result connected to its draft, even when the batch contains duplicates. An editor can review flagged results before exporting the approved copy.

### Output: what comes back

Each distinct rewrite is saved as a Dataset row. The original input positions stay attached, so the results are easy to match to your drafts.

| Field | What it tells you |
| --- | --- |
| `humanizedText` | Your rewritten text |
| `inputIndexes` | Which submitted drafts share this result |
| `originalText` | Your original, when requested |
| `mode`, `style`, `format` | The selected settings; format is plain text |
| `inputWordCount`, `outputWordCount` | Length before and after rewriting |
| `readabilityScore` | A readability value when available, otherwise null |
| `preservation` | Length ratio and digit-based figures kept, lost or added |
| `needsReview`, `reviewReasons` | Checks for changed figures, large length changes or unchanged output |
| `billing` | The result event, USD price and input word count; startup is separate |
| `id`, `processedAt`, `model` | Result ID, processing time and model code |

An example saved result:

```json
{
  "billing": {
    "event": "tiny-text-humanized",
    "priceUsd": 0.1,
    "wordCount": 8
  },
  "needsReview": true,
  "reviewReasons": [
    "LENGTH_CHANGED"
  ],
  "id": "18b2eeb85404b746f1b6774c69964700faaa0c747eab51a5d79da158a0451adc",
  "inputIndexes": [
    0
  ],
  "model": "ft_clean-v3",
  "mode": "precision",
  "format": "text",
  "style": "default",
  "preservation": {
    "wordCountRatio": 1.375,
    "figuresKept": [],
    "figuresLost": [],
    "figuresAdded": [],
    "unchanged": false
  },
  "humanizedText": "The library offers workshops where neighbors can learn new skills together.",
  "inputWordCount": 8,
  "outputWordCount": 11,
  "readabilityScore": 57.23363636363638,
  "processedAt": "2026-10-15T08:05:05.641Z",
  "originalText": "The library helps neighbors learn useful skills together."
}
```

These checks are a starting point for review. Compare names, quotations, figures and meaning with your draft, even when a result has no flags. If you also need a separate classification score, the [AI Content Detector](https://apify.com/khadinakbar/ai-content-detector) offers that workflow with its own charges.

### For API and AI agent workflows

The API mode values in the table remain stable. Display names help people choose; use `premium`, `precision`, `balanced`, `deep` and `seo`.

```bash
curl -X POST 'https://api.apify.com/v2/acts/khadinakbar~ai-text-humanizer/runs?maxTotalChargeUsd=0.01' \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"text":"The library helps neighbors learn useful skills together.","operation":"quote","mode":"premium"}'
```

Poll the returned run ID until it finishes, then read `OUTPUT` using its `defaultKeyValueStoreId`. For the example rewrite, use `operation: "humanize"` with an allowance of at least $0.1025. Read the saved rows through `defaultDatasetId` with the [Apify Dataset API](https://docs.apify.com/api/v2/dataset-items-get).

> Agent workflow: Preview the authorized drafts with operation quote. Inspect the total price and confirm the spending allowance. Rewrite the same inputs, read OUTPUT and RUN_SUMMARY, and return the saved Dataset rows with their input positions and billing details. Send flagged results for review and explain a partial outcome before submitting remaining work.

Hosted MCP setup and public discovery are assessed separately from the regular Actor API.

### Best results and recovery

Start with coherent plain-text paragraphs. Extract the prose from formatted documents before submitting it. Keep unrelated drafts separate so each rewrite has enough context.

The Actor checks the spending allowance before each request and processes texts one at a time. Each provider request has a 90-second deadline and is never retried automatically. If a response is incomplete or a request fails, the start fee still applies; a successfully saved rewrite receives its result charge. Completed results stay available when a batch stops early.

`OUTPUT` and `RUN_SUMMARY` explain the outcome: COMPLETE, PARTIAL, INVALID_INPUT, UPSTREAM_FAILED or CONFIG_ERROR. A saved checkpoint protects completed work. An uncertain write or charge needs reconciliation before replay. For help, share the safe error code and run ID with support, keeping confidential prose in authorized storage.

### Your text and privacy

Rewriting sends your draft to an external processing service through an encrypted, owner-managed credential. Price previews calculate locally. Apify retains submitted INPUT and generated output according to the account's storage settings. Results stay scoped to their run; there is no shared content cache or external telemetry.

Use text you are authorized to process, follow applicable laws and terms, and check attribution and disclosure requirements before publication.

### Builder's note

My goal was to make a rewrite easy to review and easy to budget for. I added price previews, grouped duplicate drafts and put the result charge beside each rewrite so people and automated workflows can see what happened. The review flags help you choose what deserves another read.

# Changelog

This Actor's version history is a separate document: https://apify.com/khadinakbar/ai-text-humanizer/changelog.md

# Actor input Schema

## `text` (type: `string`):

All modes accept up to 12,000 characters. Non-SEO modes cost $0.10 up to 20 words, $0.16 for 21–100 words, or $0.70 above 100 words. SEO costs $0.70 at any length. Every run starts at $0.0025; usage included.

## `operation` (type: `string`):

Choose Humanize text to save rewritten texts, or Preview price to see the estimated total in OUTPUT.quote. A preview sends no text to the processing service and costs only the $0.0025 run-start fee.

## `mode` (type: `string`):

Humanizer v4 is recommended for natural phrasing. Meaning Preserver focuses on meaning and length. Humanizer v3 offers creative, journalistic and professional styles. Undetectable Pro rewrites with AI detection checks in mind, without a guaranteed detector outcome. SEO Model is for blogs and web content.

## `style` (type: `string`):

Choose Natural (default) for any mode. Creative, Journalistic and Professional are available with Humanizer v3.

## `language` (type: `string`):

Use auto to detect the input language. You may provide an output language name such as English. Review translated or rewritten facts before using them. This does not guarantee identical wording or a detector outcome.

## `additionalTexts` (type: `array`):

Add up to 19 more documents using the same mode, style, language and format. Each document has the same character limit. Duplicate trimmed documents share one result and one result charge. Input indexes identify the original positions.

## `includeOriginal` (type: `boolean`):

Include your original draft next to each rewrite so you can compare them. Apify retains submitted input either way. Rewriting sends your text to an external processing service.

## Actor input object example

```json
{
  "text": "Our small team builds practical tools for busy people. We test each change carefully and listen to customer feedback before deciding what to improve next.",
  "operation": "quote",
  "mode": "precision",
  "style": "default",
  "language": "English",
  "additionalTexts": [
    "A second paragraph to rewrite in natural language."
  ],
  "includeOriginal": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

Successful rewritten texts and readability data.

## `OUTPUT` (type: `string`):

Read outcome, result counts, named charge events and quote when operation is quote. Quote totals include result prices for a future rewrite; the quote itself costs only the run-start fee.

## `RUN_SUMMARY` (type: `string`):

Safe diagnostic details, provider attempts and estimated provider costs.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "text": "Our small team builds practical tools for busy people. We test each change carefully and listen to customer feedback before deciding what to improve next."
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/ai-text-humanizer").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "text": "Our small team builds practical tools for busy people. We test each change carefully and listen to customer feedback before deciding what to improve next." }

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/ai-text-humanizer").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "text": "Our small team builds practical tools for busy people. We test each change carefully and listen to customer feedback before deciding what to improve next."
}' |
apify call khadinakbar/ai-text-humanizer --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,khadinakbar/ai-text-humanizer"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/8dQ5cUXeUlchC5Dky/builds/jU7b18dgHIPhqxtE5/openapi.json