POST /v1/humanize
One request, one clear response: text in, humanized version and AI scores out. The same Humanizer as in the browser—now in your code.
The language is automatically detected and retained: English and over 40 others. Billing is based on the exact number of measured input words.
Create API keyView documentation
Register for free · Billed by input words · No minimum term
curl https://api.studytexter.com/v1/humanize \
-H "Authorization: Bearer $STUDYTEXTER_API_KEY" \
-H "Content-Type: application/json" \
-d '{"text": "Digitalization presents companies with..."}'{
"humanized_text": "Due to digitalization, companies are facing very...",
"ai_detection": {
"original": { "ai_percent": 81.58, "human_mixed_percent": 18.42 },
"humanized": { "ai_percent": 3.83, "human_mixed_percent": 96.17 }
}
}
AI scores with every call – detectors featured in, among others:
Basics
The Humanizer API is a REST interface that programmatically revises texts from ChatGPT, Claude, Gemini, or DeepSeek to make them sound more natural. Humanizing text via an API means you send a POST request with your text to /v1/humanize and get back the humanized version, along with AI detection scores for both versions as a metric. It's powered by the same language detection, word measurement, and processing as the AI Humanizer in the browser—there is no stripped-down version for developers.
Integration
No SDK, no onboarding call, no language parameter. The REST API only needs a key, an endpoint, and one required field in the body.
Create key
Register, go to the keys page in the app, create a key. The full secret is displayed exactly once.
Send text
POST to /v1/humanize with Authorization: Bearer and a JSON body that only contains text. You don't send a language parameter—it's detected automatically.
Process response
The response contains humanized_text and the AI scores for the original and the result. In case of an error, error.retryable determines whether a second attempt is allowed.
curl --request POST 'https://api.studytexter.com/v1/humanize' \
--header "Authorization: Bearer $STUDYTEXTER_API_KEY" \
--header 'Content-Type: application/json' \
--data '{"text":"Digitalization presents companies with diverse challenges because existing processes must be reviewed and reconfigured. A responsible use of AI continues to require careful source work and independent judgment."}'The full example text, the OpenAPI file, and the Markdown version for agents are available in the documentation.
Agents
An agent that generates text needs the Humanizer as a tool—not as a website. Three things are crucial when no one is supervising.
Register as a tool
One endpoint, one required field, no switches. The tool definition fits in a few lines and can be stored in LangChain, the Anthropic SDK, n8n, or a custom loop.
In multi-step workflows
The agent generates text with a model, sends it through /v1/humanize, and passes the result on. The language remains that of the draft, without the workflow needing to know it.
Retry without double billing
Every error indicates via error.retryable whether a new attempt is safe. If the connection drops without a response, an Idempotency-Key deduplicates the request: the same key with the same text returns the stored response instead of a second charge.
{
"name": "humanize_text",
"description": "Revises an AI draft to make it sound more natural. The language is detected and retained. Numbers, names, sources, and technical terms are preserved.",
"input_schema": {
"type": "object",
"properties": {
"text": {
"type": "string",
"description": "The text to be revised. 100 to 30,000 characters, maximum 3,000 words."
}
},
"required": ["text"]
}
}That's all an agent needs. There are no language, tone, or strength fields it could set incorrectly—and thus no degree of freedom where a run could silently fail. The full description is also available as OpenAPI 3.1 and llms.txt; both can be provided directly to a model.
Use cases
Wherever a model writes the draft, but a human is still listed as the sender.
Writing tools
Your editor generates a draft via an LLM and sends it through the API before output. Your users see the result, not the intermediate step.
Content pipelines
Editorial and publishing workflows chain the call after generation. Throughput comes from 60 parallel jobs, not from longer individual texts.
Agent frameworks
LangChain, CrewAI, the Anthropic SDK, or a custom loop: The endpoint is one tool among others and requires no special treatment.
SEO and marketing
Blog posts, product descriptions, newsletters. What a model has drafted goes out as continuous text without anyone having to smooth it out by hand.
Academic platforms
Learning environments and writing tools whose users work with sources. Citations, page numbers, and technical terms are preserved word for word—exactly the point where most humanizers fail.
White-label and SaaS
Humanizing as a native feature in your product, under your brand. Billing is handled through your StudyTexter account; your users see none of it.
Differences
Not because it's faster than others, but because it has fewer places where things can silently break.
Language is detected, not set
You don't send a `language` field. The dominant language of the input text is detected and retained in the response—over 40 languages. An incorrectly set parameter can't break anything.
AI scores for both versions
The response contains detector probabilities for the original text and for the result. You can display or log what has changed in your product—without a second tool.
Sources are preserved word for word
Quotes, page numbers, author names, and years are not rephrased. This is the reason why the API is usable in academic products at all.
Billed by input words
The text you send is counted—with ICU segmentation on an NFC-normalized copy. The length of the response does not change the price.
The same engine as in the browser
573.7 million humanized words and over 63,573 users run through the same processing. You can cross-check what the API delivers in the interface.
Model updates included
Improvements to the processing reach the API at the same time as the web interface. Your integration requires no changes for this.
Pricing
The API doesn't have its own plans. It deducts from the same credit balance as the tool in the browser—subscription or one-time purchase, both apply to both methods.
GPTZero classifies our texts as more human than real student texts (avg. 84% vs. 80%).
Over 573.7M words humanizedStudent
€14.99per month
€5.00 / 10,000 wordsThe guarantee applies to the GPTZero AI scanner: If your humanized text is detected as AI there, we will refund the words used. A short message to support is all it takes.
Start subscriptionOr make a one-time purchase
Starter
€9.99one-time
€12.49 / 10,000 wordsStandard
€34.99one-time
€8.75 / 10,000 wordsPower
€69.99one-time
€7.78 / 10,000 wordsThe public API exclusively uses paid words: the subscription quota and purchased packages. The free monthly quota only applies to the web interface.
Enterprise from 150,000 words/month
Custom pricing for agencies, ghostwriters, and tool integrations. Briefly answer four points—we'll get back to you within 24 hours.
Secure payment via Stripe · Cancel anytime, no minimum term
Response
One field with the result, one object with the metrics. No more structure is needed.
{
"humanized_text": "…",
"ai_detection": {
"original": {
"human_mixed_percent": 18.42,
"human_percent": 8.29,
"mixed_percent": 10.13,
"ai_percent": 81.58
},
"humanized": {
"human_mixed_percent": 96.17,
"human_percent": 83.04,
"mixed_percent": 13.13,
"ai_percent": 3.83
}
}
}humanized_text
The revised version in the language of the input text. Structure and length remain close to the original.
ai_detection.original
The probabilities for the text you sent: `ai_percent`, `human_percent`, `mixed_percent`, and `human_mixed_percent`.
ai_detection.humanized
The same four values for the result. The comparison of both objects is the before/after check from the web interface.
X-Request-ID
A header to log. This allows support to identify a single run without you having to send your text again.
AI scores are class probabilities, not proportions of sentences—and not proof. Detectors also misclassify human-written texts. Individual values can be null if no measurement is available; your integration should be prepared for this.
What's preserved
Sentence structure, transitions, and word choice are changed. The content your product is responsible for is preserved.
Meaning
Statements remain statements. Nothing is added that wasn't in the input text.
Numbers and identifiers
File numbers, DOIs, ISBNs, item numbers: character strings are carried over, not reset.
Names and proper nouns
People, institutions, products, and places retain their spelling.
Numbers, dates, and units
Measurements remain unrounded, unconverted, and in their place.
Technical terms and abbreviations
Terminology is not replaced with an everyday word just because it sounds more common.
Register and form of address
Formal or informal, factual or narrative: The language level of the input text is preserved.
Billing
The API does not have its own plans. It deducts from the same credit balance that the tool in the browser uses.
Billing is based on input words
Exactly the text you send is counted. The length of the response does not affect the price.
The API runs on paid words
The free monthly quota applies to the web interface. The public API exclusively uses paid credits.
Rejected doesn't mean billed
Requests that fail due to a limit are not queued and not charged. For retryable errors, the reservation is released.
No separate contract
Credits and subscriptions run through your existing account and can be canceled there. There are no extra charges for the API.
curl 'https://api.studytexter.com/v1/balance' \
--header "Authorization: Bearer $STUDYTEXTER_API_KEY"
{
"balance": {
"subscription": null,
"subscription_words_remaining": 0,
"purchased_words_remaining": 12000,
"total_api_words_available": 12000
}
}Security
Four points that should be clarified before integration.
The key stays server-side
`stx_live_…` belongs in a secret manager—not in browser bundles, mobile apps, URLs, prompts, or logs. Redact the Authorization header before logging requests.
Visible once, revocable anytime
The full secret is displayed exactly once upon creation. Creating, listing, and revoking keys is done exclusively through the logged-in keys page.
One key, many jobs
The same key authenticates any number of jobs, sequentially or in parallel. The Idempotency-Key is something different: a job identifier, not a secret.
No training on your texts
Your texts are processed for the job. We do not use them for training AI models.
Questions
A REST interface that lets you programmatically revise AI texts to make them sound more natural. A POST to /v1/humanize with your text returns the humanized version and AI detection scores for both versions. It's powered by the same processing as the AI Humanizer in the browser.
In terms of content, yes. The AI Humanizer API is backed by the same language detection, word measurement, and processing as the AI Humanizer in the web interface. The only differences are the access method—Bearer token instead of login—and the credits: The public API exclusively uses paid words.
As a tool. You define a tool with a single required field—the text—and the agent calls it when an output needs to be revised. This works equally well in LangChain, CrewAI, the Anthropic SDK, or a custom loop. For models, the descriptions are also available as OpenAPI 3.1, Markdown, and llms.txt.
Register for free or log in, open the keys page in the app, and create a key. You will see the full secret exactly once—copy it to your secret manager immediately. You can revoke it there at any time.
Via a Bearer token in the Authorization header: `Authorization: Bearer stx_live_…`. The same key is valid for /v1/humanize and /v1/balance and can authenticate many jobs sequentially or in parallel. It belongs exclusively in server-side code.
With text from all common models—ChatGPT, Claude, Gemini, DeepSeek, Llama, Mistral, and others. The API receives text, not a model name: what matters are the patterns in the draft, not its origin.
We don't promise that. The API delivers a more natural phrasing and the measured AI scores for the original and the result. These scores are a detector's class probabilities—not proof and not a guarantee. Detectors change their models, arrive at different assessments depending on the provider, and also misclassify purely human-written texts. What you get is a verifiable before/after comparison that you can display or log in your product.
No, and you can't. The dominant language of the input text is detected and retained in the response—German and over 40 others. The API does not accept a `language` field.
Yes. Billing is based on the exact measured input words, regardless of how long the response is. The public API exclusively uses paid words; the free monthly quota applies to the web interface. You can query the current balance with GET /v1/balance.
Yes, per user: 60 new jobs per 60 seconds, 60 concurrently in processing, and 30 balance queries per minute. Requests above that are rejected with a 429, not queued, and not billed. Where available, `Retry-After` specifies the waiting time.
For an error with `error.retryable=true`, the reservation has been released—a new attempt is safe. If the connection drops completely without a response, you don't know the result: for this case, there is the optional Idempotency-Key. With the same key and the same text, you get the stored response back instead of a second charge.
Usage runs through your StudyTexter account and is billed through it, even if your own users trigger the call. The contractual terms that apply are stated in our T&Cs; for larger volumes or questions about usage, please contact us beforehand.
Create a key and send your first request
POST /v1/humanize · Billed by input words · No minimum term