Human Translation & Proofreading API

Put a human in your AI translation loop.

Q: What is the Human Translation API?

It is an API for ordering professional human translation, proofreading, and AI-translation verification programmatically — powered by Nitro, Alconost’s self-service human translation platform. Your app, CMS, or AI agent sends text and receives human-checked output, with no project managers or email threads in the loop.

Your agents translate fast. This API lets them call a real linguist to verify, proofread, or translate from scratch — programmatically, on demand. The trust layer for the agentic world, from Alconost’s Nitro platform.

Get an API key Read the cookbook

80+ languages, 170+ pairs
Pay-as-you-go, no minimum
From $0.06/word

Why a human layer

MT is fast. Humans are right when it counts.

Ship the 95% of strings that machine translation handles well. Route the 5% where being wrong is expensive — a human check, called from code.

Catch hallucinations

LLMs invent plausible-but-wrong translations. A human verifier flags what your agent can’t see it got wrong.

High-stakes strings

Legal, medical, payment, and safety copy where a mistranslation has real consequences. Gate it through a human.

Tone & brand

Native linguists keep register, idiom, and brand voice intact — the nuance MT flattens.

Three calls, one API

Pick the human service your workflow needs

For agents

AI translation + human proofreading

from $0.06 / word

Your agent (or our MT) drafts it; a human linguist proofreads and corrects. The fastest way to make AI translation shippable.

Human translation

from $0.10 / word

A native professional translates from scratch. For new, high-value, or sensitive content where you want it right the first time.

Human proofreading

from $0.05 / word

Already have a translation? A linguist checks grammar, accuracy, and consistency — a clean QA pass on existing text.

Cookbook

Order a human check in three steps

Base URL https://api.nitrotranslate.com/v1 · HTTP Basic auth with your API key as the username and a blank password. Orders are asynchronous: create, then poll for the result. Full schema in the API reference.

Register & get your API key

Create a Nitro account, then generate a key on the Settings page. Top up your balance — it is pay-as-you-go, so there is nothing to commit to upfront.

Generate an API key →

Create an order

POST /translate with the source language, one or more targets, and your text (or a JSON/HTML/XML resource). You get back one order per target language, each with an id and price.

cURL

curl -X POST https://api.nitrotranslate.com/v1/translate \
  -u APIKEY: \
  -H "Content-Type: application/json" \
  -d '{
    "source_language": "en",
    "target_languages": ["de", "ja"],
    "resource": {
      "type": "text/plain",
      "data": "Your order has shipped and will arrive within 3 business days."
    },
    "context": { "tone": "FORMAL", "category": "GENERAL" },
    "comment": { "text": "UI string for a transactional email. Keep it concise." }
  }'

Python

import requests

# Basic auth: your API key as the username, blank password.
auth = ("APIKEY", "")

payload = {
    "source_language": "en",
    "target_languages": ["de", "ja"],
    "resource": {
        "type": "text/plain",
        "data": "Your order has shipped and will arrive within 3 business days.",
    },
    "context": {"tone": "FORMAL", "category": "GENERAL"},
    "comment": {"text": "UI string for a transactional email. Keep it concise."},
}

r = requests.post("https://api.nitrotranslate.com/v1/translate", json=payload, auth=auth)
orders = r.json()          # one order per target language, each with an id + price
order_id = orders[0]["id"]

Poll for the human-checked result

GET /orders/{id} until status is DONE, then read target_text. That string has been through a real linguist — ready to ship.

Python

import time, requests

auth = ("APIKEY", "")

while True:
    r = requests.get(f"https://api.nitrotranslate.com/v1/orders/{order_id}", auth=auth)
    order = r.json()
    if order["status"] == "DONE":
        print(order["target_text"])   # human-checked translation, ready to ship
        break
    time.sleep(60)                     # human turnaround is minutes-to-hours; poll politely

Price before you order (optional)

POST /calculate with the same resource shape returns word count and price without creating an order — handy for showing cost in your UI or gating spend in an agent.

cURL

curl -X POST https://api.nitrotranslate.com/v1/calculate \
  -u APIKEY: \
  -H "Content-Type: application/json" \
  -d '{
    "source_language": "en",
    "target_languages": ["de"],
    "resource": { "type": "text/plain", "data": "Text to price before ordering." }
  }'

Replace APIKEY with your key. Full endpoint reference, formats, and webhooks: developer.nitrotranslate.com.

For the agentic world

Where teams wire in a human call

Verify LLM output before publish

An agent translates a release; the high-risk segments go through human proofreading before they reach users.

Human-gate risky strings in CI

Block a localization build on a human pass for legal, payment, and safety strings — automatically.

On-demand translation fallback

When confidence is low or a language is unsupported by your MT, fall back to a human translation order from code.

Continuous content & support

New help-center articles, product copy, and UI strings get a human check as they ship, without a manual handoff.

Built for integration

Send files, not just sentences

The API takes structured resources, so you can pass your localization files straight through and get human-checked output back in the same shape.

Plain text JSON HTML XML iOS Strings 80+ languages 170+ pairs Python / JS / Node / Java / PHP

Get an API key Read the docs

What is the Human Translation API?

It is an API for ordering professional human translation, proofreading, and AI-translation verification programmatically — powered by Nitro, Alconost’s self-service human translation platform. Your app, CMS, or AI agent sends text and receives human-checked output, with no project managers or email threads in the loop.

How is this different from a machine translation API?

Machine/LLM translation APIs return an instant machine guess. This API puts a real human in the loop — to translate from scratch, or to proofread and verify what your AI produced. It is the trust layer you add on top of MT/LLM output when accuracy actually matters (legal, medical, marketing, shipping UI).

Why would an AI agent need this?

Agents translate fast but can hallucinate, miss tone, or mistranslate high-stakes strings. With this API an agent can gate the risky 5% through a human check before publishing — ship the rest from MT, and call a human only where the cost of being wrong is high.

How does authentication work?

HTTP Basic auth: your API key is the username with a blank password (-u APIKEY:). Generate the key in your Nitro account settings. See the API reference for the full schema.

What languages and formats are supported?

80+ languages and 170+ language pairs. The API accepts plain text plus structured formats including JSON, HTML, XML, and iOS Strings — so you can send resource files directly, not just sentences.

How does pricing work?

Pay-as-you-go, no monthly fee and no minimum order. Human proofreading from $0.05/word, AI translation + human proofreading from $0.06/word, and human translation from $0.10/word. Use the /calculate endpoint to price any payload before you order.

How fast is turnaround?

Because real linguists do the work, turnaround is typically minutes to a few hours depending on volume and language — not seconds like MT. Orders are asynchronous: create an order, then poll /orders/{id} (or wait for it to reach DONE) and retrieve the result.