API reference

Humanizer API

Rewrite text programmatically with the same engine as the editor. One endpoint, JSON in and JSON out.

Base URL https://noai.devprithwiraj.in/

API key auth Send your key in the X-API-Key header.

One endpoint POST /humanize returns the result instantly.

20,000 characters Maximum text length per request.

Authentication

Every request needs an API key. Create one on the Dashboard and send it in the X-API-Key header.

Header

X-API-Key: hmnz_your_api_key_here

Treat your key like a password. Keep it out of client-side code and version control. Keys are shown only once, so store them in a secrets manager or environment variable.

Plans & quota

The REST API is a paid service. Every account with a confirmed email address starts with 50 free requests to test your integration; after that you need an API plan or a top-up. Plans cover 30 days, or a year at the price of 10 months; buying again while a plan is active adds the new period and carries over unused requests. See Pricing for the price in your region.

Plan	Requests per 30 days	Requests per year
Free trial (once per account)	50	—
Starter	5,000	60,000
Pro	30,000	360,000
Business	150,000	1,800,000

Top-ups add requests that never expire. Each request uses your plan's requests first and top-up requests only after those run out (or once the plan ends), so a top-up also works on its own, without a plan.

Every successful response includes what's left, so you can warn users before it runs out. Only valid requests count: requests rejected with a 4xx error or failing on our side are not charged. We also email you when 80% is used.

Response headers

X-Quota-Limit: 30000
X-Quota-Remaining: 28451
X-Credits-Remaining: 2000

When the plan's requests and top-up requests are both used up, the API answers with 402 Payment Required and a link to the pricing page. The web editor is free and never uses API quota.

Endpoint

Rewrites the submitted text and returns the result with change statistics.

POSThttps://noai.devprithwiraj.in/humanize

Request

Headers

Header	Value
Content-Type	application/json	Required
X-API-Key	Your API key	Required

Body parameters

Parameter	Description
text string	The text to humanize. Up to 20,000 characters.	Required
tone string	"standard", "professional", "casual" or "academic". Casual uses contractions, shorter words and splits long sentences; professional and academic expand contractions, and academic keeps a formal vocabulary. Default: "standard".	Optional
deep_mode boolean	Chaos Mode: a deeper rewrite that swaps far more words and splits long compound sentences. Default: false.	Optional
deep_rewrite boolean	Deep Rewrite (beta): a paraphrasing model running on our server rewords whole sentences before the other layers run. A rewrite is used only if it keeps every name, number and date and still reads as the same sentence; otherwise that sentence keeps its wording. Slower (often 10 to 40 seconds, so allow a long client timeout), up to 2,500 characters, 10 requests a minute, and not available for batch requests. Not installed on this server at the moment, so requests with it return 400. Default: false.	Optional

Example body

JSON

{
  "text": "The quick brown fox jumps over the lazy dog.",
  "tone": "professional",
  "deep_mode": true
}

Response

A successful request returns 200 OK with this JSON body.

200 OK

{
  "original": "The quick brown fox jumps over the lazy dog.",
  "humanized": "The speedy brown fox jumps over the lazy dog.",
  "diff_html": "<span class=\"unchanged longest\">The</span> <span class=\"added\">speedy</span> ...",
  "longest_unchanged": "brown fox jumps over the lazy dog.",
  "structural_changes": "11.1%",
  "changed_words": 1,
  "new_words": 1,
  "moved_words": 0,
  "restructured_sentences": 0
}

Fields

Field	Description
original string	The text you sent.
humanized string	The rewritten text, with line breaks preserved.
diff_html string	HTML-escaped output in which each run of words is wrapped in a `span` of class `added` (new words), `moved` (original words in a new place, from a restructured sentence) or `unchanged`; the longest unchanged run also has class `longest`. Case and punctuation differences don't count as changes.
longest_unchanged string	The longest run of words left exactly as in the input, or "None".
structural_changes string	How different the word sequence is, as a percentage.
changed_words integer	Number of words that were rewritten.
new_words integer	Words in the output that aren't in the original.
moved_words integer	Original words that now sit in a different place.
restructured_sentences integer	Sentences of the output whose structure changed.

Batch requests

Rewrite up to 25 texts in one call. Each item uses one request from your quota, so a batch costs the same as sending the items one by one, with a single round trip. Items that fail on our side are not charged.

POSThttps://noai.devprithwiraj.in/humanize/batch

Send items: a list of strings, or of objects with text and optional tone, deep_mode and id (echoed back, up to 100 characters). Top-level tone and deep_mode set the defaults. Batch requests need an API key.

Request body

{
  "tone": "professional",
  "items": [
    "First paragraph to rewrite.",
    {"id": "faq-2", "text": "Second paragraph.", "tone": "casual"}
  ]
}

Results come back in the same order. Each has the item's index (and id if you sent one), plus either the rewrite (humanized, longest_unchanged, structural_changes, changed_words, new_words, moved_words, restructured_sentences) or an error. The diff HTML is left out to keep responses small.

200 OK

{
  "count": 2,
  "succeeded": 2,
  "processing_ms": 412.5,
  "results": [
    {"index": 0, "humanized": "…", "longest_unchanged": "…", "structural_changes": "71%", "changed_words": 3},
    {"index": 1, "id": "faq-2", "humanized": "…", "longest_unchanged": "None", "structural_changes": "100%", "changed_words": 2}
  ]
}

A batch is checked as a whole before anything is charged: if any item is invalid, the response is a 400 naming the item (for example Item 3: text too long) and nothing is used. Limits: 25 items and 50,000 characters per batch, each item up to 20,000 characters. Each item counts toward the per-key rate limit. Deep Rewrite is too slow for batches, so deep_rewrite is refused here; send those texts to /humanize one at a time.

Errors

Errors return a JSON body with a single error message.

Status	Meaning	Example message
400	Missing or invalid parameters	No text provided · Text too long (max 20000 characters) · Invalid tone · Deep Rewrite handles up to 2,500 characters at a time
401	Missing, wrong or revoked API key	Invalid or inactive API key
402	No API plan or top-up requests left: none bought, the plan expired, or everything is used	Your API plan has used all its requests. Buy a top-up or upgrade at …/pricing
403	The account's email address hasn't been confirmed yet	Verify your email address first. …
413	Request body over 1 MB	Request too large (max 1 MB).
429	Rate limit reached; wait for the number of seconds in the `Retry-After` header	Too many requests. Please try again in 20 seconds.
500	Unexpected server error	Processing failed.
503	Deep Rewrite is busy with other texts (not charged); retry after the `Retry-After` seconds or send it without `deep_rewrite`	Deep Rewrite is busy with other texts. …

400 Bad Request

{
  "error": "Text too long (max 20000 characters)"
}

Limits

Maximum text length	20,000 characters
Maximum request size	1 MB
Monthly requests	Set by your plan
Rate limit	30 requests per minute per API key
Deep Rewrite	2,500 characters, 10 requests per minute per API key

Every request is logged against its key and shows up in your dashboard.

Code examples

Replace hmnz_your_api_key_here with a key from your dashboard.

curl -X POST https://noai.devprithwiraj.in/humanize \
  -H "Content-Type: application/json" \
  -H "X-API-Key: hmnz_your_api_key_here" \
  -d '{
    "text": "Your AI-generated text here",
    "tone": "professional",
    "deep_mode": true
  }'

import requests

url = "https://noai.devprithwiraj.in/humanize"
headers = {
    "Content-Type": "application/json",
    "X-API-Key": "hmnz_your_api_key_here"
}
payload = {
    "text": "Your AI-generated text here",
    "tone": "professional",
    "deep_mode": True
}

response = requests.post(url, json=payload, headers=headers)
data = response.json()

print(f"Humanized: {data['humanized']}")
print(f"Changed words: {data['changed_words']}")

const response = await fetch('https://noai.devprithwiraj.in/humanize', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-API-Key': 'hmnz_your_api_key_here'
  },
  body: JSON.stringify({
    text: 'Your AI-generated text here',
    tone: 'professional',
    deep_mode: true
  })
});

const data = await response.json();
console.log('Humanized:', data.humanized);
console.log('Changed words:', data.changed_words);

<?php
$url = 'https://noai.devprithwiraj.in/humanize';
$data = array(
    'text' => 'Your AI-generated text here',
    'tone' => 'professional',
    'deep_mode' => true
);

$options = array(
    'http' => array(
        'header'  => "Content-type: application/json\r\n" .
                     "X-API-Key: hmnz_your_api_key_here\r\n",
        'method'  => 'POST',
        'content' => json_encode($data)
    )
);

$context  = stream_context_create($options);
$result = file_get_contents($url, false, $context);
$response = json_decode($result);

echo "Humanized: " . $response->humanized . "\n";
echo "Changed words: " . $response->changed_words . "\n";
?>