Send product text, files, or complete localization orders. Localize.io
combines each string with the glossary terms, translation memory, style rules and
screen context that actually apply to it, then returns checked work with a record
of how it was made. Connect over the API, or let your AI agents do it over MCP.
Context is most of the brief.Send it with every string.
The source says what the words are. The context says what they have to do. A
string sent without it is translated blind, and it comes back fluent anyway, so
nothing tells you what was missed.
Say, for every string
Where: the page or screen, or that it is shared.
Where on it: hero, FAQ, footer, a pricing card.
What it is: a heading, a button, an error, alt text.
What it does: “opens the terms of service”.
How much space, for short interface text.
Gather it while you extract
The component says what the string is and does.
The strings next to it say where on the page.
The file and key say where in the product. Put that into words; a path is
not context.
A screenshot shows the space and the neighbours. Attach it.
No screen? Say what the reader is doing
Email: who gets it, and what just happened.
Error: what the user did, and what they can do next.
Alt text: the image, not the link.
Plural: which form, and what is being counted.
The test: could someone who has never seen your product find this text
on the screen from your context alone? “Checkout, empty basket. Heading above the
Continue shopping button” passes. “Footer link” and COMMON → MENU → TITLE
do not.
Examples
Same string, different right answer.
Each example changes one thing and keeps everything else the same: the same source,
the same instructions, the same language. On the left is the translation without that
context, on the right the translation with it. All are real results, English to
Lithuanian.
Example 1 · Screenshot
A string doesn't explain itself.The screen does.
“Current” can mean the present time, a status, or electricity. Next to
“2.4 A” on a charging screen, it means electrical current. The only thing that changed
between the two runs is the screenshot.
Source · EnglishCurrent
Without a screenshot
Dabartinispresent, current
no screen
The translator sees one word and nothing else.
With a screenshot
Srovėelectrical current
What the translator was told about the screen
Device diagnostics, power-input screen
“Current” is the label beside “2.4 A”
A short technical label; units follow it
See what the translator saw
Screen
Described once, when uploaded. The description (purpose, register, visible elements, where this string sits and how much room it has) travels with the string.
Translator
Worked from that description, not from the image itself.
Checks
Passed
Observed cost
$0.0019 without the screen, $0.0061 with it
Example 2 · Glossary
Your product vocabulary stays yours.
Without your terminology, “Flow” is an ordinary noun and gets translated
like one. With a single approved glossary entry, the feature keeps its name.
Source · EnglishCreate a new Flow
Without a glossary
Sukurti naują srautą
“Flow” reads as the common noun: srautas, a stream.
With a glossary
Sukurti naują „Flow“
Glossary entry
Flow → Flow
The product feature used to build an automated workflow.
Product feature name: keep spelling and capitals, do not translate.
See what the translator saw
Terms available
1
Terms selected
1 for this string. Only the terms that apply to a string travel with it, not the whole glossary.
Observed cost
$0.0019 without, $0.0029 with
Example 3 · Translation memory
Memory informs the translation.It doesn't switch off judgment.
An exact match from your translation memory is strong evidence, not
untouchable output. Your preferred wording is kept even where a fresh translation would
say it differently, and a stored mistake is corrected rather than repeated.
Kept · EnglishSave changes
Without memory
Išsaugoti pakeitimusnew
With memory
Memory saysIšsaugokite pakeitimus
Išsaugokite pakeitimusas_is
Corrected · EnglishDelete account
Without memory
Ištrinti paskyrąnew
With memory
Memory saysIštrinti paskyyrą (contains a typo)
Ištrinti paskyrąfixed
new translated without a memory entryas_is remembered translation kept, after review, and not charged the per-character ratefixed remembered translation corrected
Keeping your translation memory
Keep every translation as three things together: the source text, the
target text, and its context.
Source: the original string, exactly as it appears in your product.
Target: the approved translation, under the language code you order with.
Context: where the string appears and what it does, for example “Checkout
page, button that confirms payment”. Without it, the same word in a menu and in a
heading looks identical.
The memory is yours. When a translation is approved or corrected, add it to your
memory, and upload the memory again before your next order.
See what the translator saw
Memory matches
2 exact, 0 near, 0 strings without memory
Decisions
Both made by the translator with the memory in front of it. as_is means reviewed and kept, not skipped.
The memory holds an informal sentence (“tu gali”, you can). The style guide
asks for formal address. The meaning stays the same; how the product speaks to its user
changes. Lithuanian usually drops the pronoun, so the formal plural verb “galite” is the
whole change.
Source · EnglishHere you can change your password.
Memory only
Memory saysČia tu gali pakeisti savo slaptažodį.
Čia tu gali pakeisti savo slaptažodį.as_is
No style guide, so as far as the translator knows the remembered sentence is fine.
Memory and style guide
Memory saysČia tu gali pakeisti savo slaptažodį.
Čia galite pakeisti savo slaptažodį.fixed
Style guide, Lithuanian
Address the user formally: jūs, jūsų, plural verb forms.
No informal tu, tavo, tave.
Correct informal wording found in memory.
See what the translator saw
Memory
1 exact match in both runs
Style guide
Absent in the first run, applied in the second
Observed cost
$0.0034 memory only, $0.0039 with the style guide
Step 1 · Configuration
One configuration is the routing map.
Routing decides which model does each piece of work. You set it once, by language,
content type, project and pass, and every order follows it. Nothing is guessed: an
order the configuration doesn't cover is refused when it arrives, and the refusal says
which setting would have answered it.
Configuration · Routing
The same language,routed three ways.
Short interface strings go to a fast model, marketing copy to a stronger
one, and a person you name reviews the translation.
ja · ui→gpt-6-lunafast · languages.ja
ja · marketing→gpt-6.1-solstronger · content_types.marketing.languages.ja
ja · marketing · review→Aiko Satoa person · "linguist": "ln_…"
How a job moves through your configuration: one way in, then a model or a person
How a job moves through the service. Every job takes the same way
in: it arrives as strings, or for a review as strings with their translations; intake identifies
the project, the language pair and the content type, and refuses anything the configuration doesn't cover;
the order says which job it is, a translation or a review, and the configuration picks the model, or the
linguist; a model reads every string against your glossary, translation memory and screenshots and chooses
what applies to each, with your style guide for the whole job, and a review also has its translation
checked first and its strings grouped into the sections of their page. Then it branches. A translation job:
each string is translated; the result is checked twice, by counting and by a model judging terminology;
strings that fail go back to be retranslated, up to three attempts, and a string that still fails comes back
flagged while the rest is delivered; the same structure comes back with a record of how it was made. A review
job: a linguist reads each string with the same evidence and seals it; the same checks run on their work,
and issues go back to them one at a time; the strings come back sealed. A translation, all or some of it,
can be ordered again as a review.
1 · Arrives
Your order
strings; a review, strings with their translations
app.json
2 · Intake
Projectmobile-app
Language pairen → lt
Content typemarketing
not configured → refused
3 · Route
The configuration picks the model, or the linguist
the order says which job it is; most specific setting wins
gpt-6.1-solln_79fdf83b
4 · Context
Glossarythe terms it is about
Screenshotsthe screen it is on
Style guideyour voice, whole
Memorynearest in meaning, scored
a review also has its translation checked first, and its strings grouped into page sections
5 · Translate
Translation jobTranslated with that evidence
and says what it did with your memory: new, as_is or fixed
↺ failed strings come back here, with the findings
6 · Check
Counted · no modelStructure
every string back · placeholders and tags · length limits · line breaks
Judged · a modelTerminology
required terms used, ruled-out terms absent
✗ fails → retranslated, up to 3 attempts, each one loggedstill failing → flagged, with what happened
7 · Returned
The same structure back
with the record: model, context used, checks and attempts, cost
app.lt.json↺ all or some of it can be ordered again, as a review
5 · Review
Review jobA linguist reads and seals
the same evidence; drafts are never sealed, every string is
↺ strings with an issue come back here, unsealed
6 · Check
The same checks
structure and terminology, on submit; a terminology finding can be kept, with a reason
✗ issues go back to the linguist, one at a time
7 · Returned
Sealed strings back
each with what you sent, the verdict, the note and the seal
Configuration · Account and project
Set once for the account,overridden per project.
Account-wide · config.json
Set once, for every project
Your languages and language pairs, your content types, your own locale codes, and
the models used by default. A new project starts with all of it.
→
Per project · projects/<name>/config.json
Overrides only what it names
A project changes what it needs (a stronger model for marketing copy, a review pass)
and inherits the rest. A project that lists its own languages or content types is
limited to those.
Glossaries, translation memory and style guides sit at the same two
levels. Material in the account applies to every project; a project's own material
is added to it, and wins where the two disagree.
Configuration · Settings
What each setting decides
Setting
What it decides
For example
languages
The target languages you can order. from makes one a pair: Polish from German is different work from Polish from English, and is ordered separately.
"pl-PL": { "from": "de" }
aliases
Your platform's own codes for a declared language. You get your code back in the result.
"de_DE": "de-DE"
content_types
The content types an order can name. Each can be routed differently, and every order says which one it is.
"ui", "marketing"
model
Which model translates. It can be set for everything, for one language, for one content type, or for one content type into one language.
"openai/gpt-6.1-sol"
annotator
Which model reads your screenshots and writes the description that travels with the strings on them.
"google/gemini-3.5-flash-lite"
selector
Which model reads each string, before it is translated, and chooses which of your glossary terms, remembered translations and screenshots apply to it.
"google/gemini-3.5-flash-lite"
embedder
Which model your translation memory is searched with, by meaning, so earlier translations worded differently are still found.
"openai/text-embedding-3-small"
qa
Which model checks that your terminology was used. Never the model that translated: a model marking its own work agrees with it.
"google/gemini-3.5-flash-lite"
defaults
The models and provider used where nothing more specific says otherwise.
"defaults": { "model": … }
One order · "models"
Choose the models for one order
An order can name its own model for translation, for reading its screenshots, for
choosing what each string is shown, and for the terminology check, from the models
offered for each (GET /v1/models). Anything else is refused
when the order arrives.
Your files · PUT /v1/config
Change the configuration yourself
Read it, change it, send it back: checked before it replaces anything, never
overwriting a change you haven't seen, and every earlier version kept to restore. It
needs a key you have allowed to change configuration.
Configuration · Which setting wins
The most specific setting wins
Each of model,
annotator,
selector, embedder and qa is taken from
the first place that sets it, reading down. Anything a level doesn't mention is
inherited from the one below. An order can name its own models above all of these.
Project this content type, into this language
Project this content type
Project this language
Project the project, then its defaults
Account this content type, into this language
Account this content type
Account this language
Account the account, then its defaults
Route an order
Uses the two files above.
Configuration · Naming a reviewer
A review is its own job, and names who does it
Translation and review are separate jobs: order either one alone, or both.
A review takes the strings, the translation of each, from us or from anywhere, and the
linguist, by id: named on the order, or once in your configuration for a language. It
can take every string of a translation or only some of them, and a translation job never
waits for one. The whole of it is step 5.
Translation only
Translategpt-6-lunaevery string, checked
Review only
Your translationsany vendor, your teamsent with the review
{
"type": "review",
"linguist": "ln_79fdf83b",
"requester": "webmaster/cookie-consent-review",
"content_type": "general",
"source_lang": "en",
"target_lang": "ja",
"segments": [
{"id": "categories.analytics.title",
"source": "Analytics",
"context": "Cookie consent panel (shared). Name of the analytics cookie category. Single word if possible.",
"target": "アナリティクス"},
…
]
}
Step 2 · Your assets
Hand over what you already have.It becomes the translator's reference.
Brand books, style guides, glossaries, past translations, screenshots of your
product: upload them as they are, in your own folders, names and formats. There is
nothing to convert or reorganise first. Each file is recognised by what is inside it,
whatever its format: one in a shape nothing here reads directly is read by a model and
converted, beside your file, which stays as you sent it. From the next job on the
translator works with it beside every string.
You upload · as it is
Brand Voice v3.docx
Tone of voice.pdf
terms de.csv
Product glossary.tbx
memory/2025/app.tmx
screens/charging.png
screens/settings.png
Each picture is described once, when you upload it: what the screen is for,
what is on it, how it speaks. Before translating, a model works out which strings
are on which screen, and each string travels with the screen it is on.
A model reads each string and picks the terms it is about, by meaning rather
than spelling. Those travel with it, with their definitions and any wording you have
ruled out, and a check confirms they were used.
Exact matches, and the ten nearest in meaning with how near each is, as evidence
the translator weighs. Kept when right, corrected when not. Your memory is made
searchable once, by the first job that uses it, and reused after that.
Your rules for address, tone, punctuation and wording, applied to every string.
Account and project guides add up.
any document
Never rewritten. Your files stay byte for byte as uploaded, and you can download any of them back unchanged.
Split by language. Every asset is split by language: a job into German gets German terms, memory and style rules, plus what is written for every language. Keep a file per language where you can.
Two levels. Material in your account applies to every project; a project's own is added on top, and wins where they disagree.
Your folders, your codes. A language written in a file, its name or its folders is read from there, spelled as you spelled it. Folders are yours to arrange.
Unreadable is reported, never skipped. A file that can't be read says so, instead of quietly not being used. Your cabinet's Files tab shows every file, what it was read as and what came out of it.
A picture of the screen sayswhat a sentence about it can't.
How much room a button has, what sits beside a label, whether a word is a
heading or a command. The translator is never shown the picture itself: a model reads
it once and writes down what the screen is for and what is on it, and those words
travel with every string on that screen.
images: png · jpg · webp · gif · not video
What it does
Described once, when you upload it: the screen's purpose, every element on
it with its role and where it sits, and how the screen speaks.
Matched to strings by a model before translating: it works out which of
your strings are on which screen, so each one is translated knowing its place.
Kept until you delete it. Described once, used by every job after.
What to bring
Your product's screens in the account's or the project's material: they
apply to every job there.
A screen for one order, uploaded with that order instead (POST
/v1/uploads, then named on the strings it shows), up to 32 MB.
The source language on screen: the picture is matched to strings by what
they say.
Getting the most out of it
One screen per picture, at the size people see it. A collage of six
screens is described as one.
The states that change the words: the empty basket, the error, the
confirmation, each its own picture.
A note when it isn't obvious: with an order's screenshot, a line such as
“the empty state of the checkout screen” steers what the model looks for.
Your terms, chosen string by string,and checked after.
A glossary is not pasted in whole. Before translating, a model reads each
string and picks the terms it is actually about, by meaning rather than spelling, and
only those travel with it. After translating, a different model checks that they were
used, and a string that missed one is translated again.
What it does
Picked per string: in a glossary of two thousand terms, the translator sees
the two a string is about, not all two thousand.
Everything you wrote down travels: definition, part of speech, usage,
status, a forbidden variant, a column of your own such as Notes, under the name
your file gives it.
Checked by another model than the one that translated: a model marking its
own work agrees with it.
What to bring
Your glossary, in as many languages as it has, as your tool exports it: TBX,
a spreadsheet with a column per language, JSON, whatever it writes. One file serves
every target language in it, for jobs translated from the language its terms are in,
which is read from the file.
Terminology in one language, if that is what you keep: approved terms with
their definitions.
The terms that matter: product names, features, legal and domain words,
the ones a reviewer keeps correcting.
Getting the most out of it
A definition where a word means two things. “Charge” the battery and
“charge” the fee are two rows, and the definition is how the right one is picked.
The wording you have ruled out, as a forbidden variant: the check then
looks for it as well.
Language codes in the header, such as en and de-DE,
are read as written. A header saying “German” is worked out from the file first.
Every exact match, with every translation of it, and the ten remembered
strings nearest in meaning, each with how near it is. The translator decides what to
keep, what to correct and what to translate afresh, and says which it did for every
string. Nothing is copied past it.
What it does
Exact matches, every one: a string remembered two ways is shown both ways,
with each one's key, context, review state and date.
The ten nearest by meaning, scored, found as shown below.
Reused word for word, not charged: a string delivered exactly as your
memory has it is not charged the per-character rate.
What to bring
The memory you have, exported from your tool in whatever it writes: TMX,
XLIFF, PO, a spreadsheet with a column per language, its own JSON.
Approved translations: a memory full of unreviewed drafts is evidence of
drafts.
Context and keys on each unit where you have them: a unit whose key is the
same as a string's id is recognised as that very string's.
Getting the most out of it
Source, target and context together, for every translation, as Example 3 describes.
Kept current by you. Nothing a job delivers is remembered here: add what
was approved or corrected, and upload the memory again before the next order.
Stable keys. An id from a string's place in a batch names a different
string in the next order; use the key your code gives it.
How your memory is searched
An exact match is a lookup. Everything
else is found by meaning, not by spelling: sent “Dieses Feld muss ausgefüllt werden”,
the remembered “Pflichtfeld” comes back among the nearest (0.62, measured), though the two
share no word a search by spelling could have matched.
1 · Every remembered string, as a vector
Each source string in your memory is turned into an embedding: a list of numbers that
places it by what it means. Done once, by the first job that needs it, and kept: an edit
to your memory embeds only what changed.
OpenAI text-embedding-3-small, 256 dimensions · 94,000 remembered strings took two
minutes and under a cent
2 · Each string you send, compared with all of them
The string is embedded the same way, and its similarity to every remembered string is
measured: 1.00 is the same meaning, unrelated text far lower.
every remembered string is compared; nothing is filtered out first
3 · The ten nearest go to the translator, scored
Beside the exact matches, with every translation of each and how near it is. The
translator decides what to use and says so for each string: as_is,
fixed or new.
no threshold decides for it: a distant match can still settle a term
Sent: “Save your changes before leaving?” — six remembered strings, nearest first
0.76
Save changes
0.71
You have unsaved changes. Leave anyway?
0.61
Your changes have been saved
0.50
Discard changes
0.36
Delete account
0.24
Battery is charging
Measured with the embedder this service uses. The second line shares almost no
words with what was sent, and is the closest in what it asks; a search by spelling would
have put it below “Discard changes”. Your own matches, with their scores, are in every
job's record.
How you address people, how formal you are, what you never say, how you
write dates and numbers. A style guide is handed to the translator with every batch it
translates, as you wrote it.
What it does
Read whole, not summarised or picked from: every rule reaches every string.
Per language where you say so. A guide whose name or folder names a
language (style/de/voice.md) is for that language; one that names none
is for every language.
Account and project add up: your company's voice first, then the project's
own rules on top.
What to bring
The guide you already have, in whatever format it is in: a document, a web
page, a PDF. A PDF is read by a model into text, once, and the reading is kept
beside your file.
A brand book, if its tone of voice is written in prose. A board of logos
and colours has nothing a translator can apply, and is stored but not used.
One guide per target language where your rules differ by language: formal
address in German, informal in Lithuanian.
Getting the most out of it
Rules, with an example each: “address the reader as Sie; never du”, beside
one sentence written that way.
The decisions a translator would otherwise guess: address form, product
names that stay in English, quotation marks, units, how long a button may be.
Not in a string's context. Tone and audience belong in the guide, once;
a string's context says where it is and what it does.
Step 3 · Send work
Segments in,segments out.
Send an order of strings, each a segment with its id, its source and its context,
and get the same segments back with their translations. Jobs run in the
background: queued, processing, done. Ids, sources and placeholders stay exactly as
they were. A file in your own format is yours to turn into segments, and to write
the translations back into.
Context is the strongest thing you can send. With each string, say where it
appears, what it does and what it must fit: a segment's context and
max_length. A length limit is enforced.
Context is yours to send: a string without it is accepted and translated blind,
with no warning, and reads well anyway. A field the service doesn't read is named
in the job's warnings, so a misspelt one is never silent. For an interface string, add a screenshot of it in place: the picture
shows how much room there is, and the context names what sits beside it.
You send · German
{
"source_lang": "de", "target_lang": "pl-PL",
"content_type": "ui", "requester": "ci",
"segments": [
{"id": "checkout.pay_button",
"source": "{amount} bezahlen",
"context": "Button on the order summary"}
]
}
You get back · Polish
"segments": [
{"id": "checkout.pay_button",
"lang": "pl-PL",
"source": "{amount} bezahlen",
"context": "Button on the order summary",
"target": "Zapłać {amount}"}
]
Point at the screen a string lives on
Besides the screenshots in your assets, you can
attach a picture to one order, or to the strings it explains, with a note of your own:
“the empty state of the payouts screen”, “Pro is the brand, never translate it”. The
picture is described once and the description goes with those strings; your note
reaches the translator whatever the picture shows. One screen can serve twenty
labels.
# attach the picture, with a note
curl -X POST https://t.localize.io/v1/uploads \
-H "authorization: Bearer $LOCALIZE_IO_TOKEN" -H "API-Version: 2026-11-09.1" \
-F 'file=@payouts.png;type=image/png' \
-F 'meta={"note": "empty state of the payouts screen"}'
# → {"id": "up_9f2c8d1e4a7b", …}# then name it on the strings it explains
{"segments": [{"id": "payouts.empty",
"source": "No payouts yet",
"references": ["up_9f2c8d1e4a7b"]}]}
Your codes, as you sent them.pt_br, pt-BR and PT-BR find the same language, and the result comes back with your spelling. Platform names like zh_Hans are mapped once, in configuration.
Every order says who asked. A person, a team or a pipeline: it is recorded with the job, so any result can be traced back to whoever ordered it.
Checked on arrival. A language, content type, project or screenshot the order can't use is refused straight away, before anything is spent.
Step 4 · Results and the record
Every job is traceable,down to the prompt.
Nothing about how your translation was made is hidden from you. For every job you can
see who asked for it, how it was routed and which setting decided it, which model answered, the exact
prompt that went in and the reply that came out, the terms, memories and screen
descriptions that were sent with it, every check and every attempt, and what each call
cost. It is recorded as it happens, because none of it can be reconstructed from the
result afterwards.
Routedmodel gpt-6.1-sol, set by projects/mobile-app/config.json › content_types.marketing
Model call 1 · selectionchose what the string is shown: 1 glossary term of 1 · no memory match · no screen · $0.0003
Context assembledthe chosen term on the string · style guide applied
Model call 2 · translation1,184 tokens in · 96 out · 2.1 s · $0.0029
Prompt in
Translate from English (en) into Lithuanian (lt).
Glossary, for this segment:
Flow → Flow (product feature name; do not translate)
Segment ex.flow: "Create a new Flow"
…
Reply out
{"id": "ex.flow",
"text": "Sukurti naują „Flow“",
"memory_use": "new"}
Model call 3 · terminology checkjudged: the required term was used · no findings · $0.0004
Checkedcounted: all strings back, placeholders identical, limits kept · passed on attempt 1 of 3
Delivered3 calls · $0.0036 in total · 17 characters, priced at your plan
Where you read it
Your cabinet. Every job with its characters and its price, fixed when it was delivered, and a Model calls tab listing every call made for your work, each one openable to its prompt and reply.
GET /v1/jobs/{id}/trace How one job was made, in order: routing, context, calls, checks, cost.
GET /v1/calls Every model call for your account, and /v1/calls/{id} for one call whole, prompt and reply.
GET /v1/log The running record of your account, filterable by project and event.
The record shown here is a shortened illustration of a real one.
Your cabinet: every job, its characters and price, what it cost and how it was made, with Usage, BYOK,
Model calls, Projects, Configuration, Assets, Files, API keys, People and Activity beside it. Shown with a demo account.
Step 5 · Review by a person
A person you name reads it,seals every string,and the checks run again.
A review corrects more than the strings it reads. The linguist's edits, their notes
and the questions they answer are what your glossary and style guide grow from: a term
they fix the same way three times becomes a glossary entry, a tone they correct becomes a
rule, every string they approve goes into your memory. So each review makes the next
machine job better. Start with a sample: a page of each new language or kind of text,
then decide how much more needs a person. And what neither a model nor your team can
settle, such as a glossary flag on a language nobody in the room reads, goes to a
linguist rather than being guessed.
A review is a separate job, ordered only when you want one: on translations you already
have, from any vendor or your own team, or on some or all of a translation from us. Every example below is from a real review: a website's cookie-consent banner,
17 strings, English into Japanese, read by a linguist in October 2026.
Review · Who reviews
Our linguists, or your own people
A linguist is one of ours, offered to every account for the pairs they review,
or someone of yours, such as an in-house linguist or a vendor you work with, added to your
account or to one project. GET /v1/linguists lists everyone you
can name, with what you need to choose: the price, what is already waiting for them, how
fast they work and when they work.
Price. Their rate plus your plan's, per 1,000 characters of source; the model usage of preparing and checking it comes on top, at cost.
Queue. Everything waiting for them, and how much of it is yours. GET /v1/jobs?linguist=…&waiting=true lists yours.
Pace. Characters a day: as their record declares, or measured from their reviews of the last 30 days.
Schedule. Time zone, working days and hours, dates away, and whether they are at work now.
Named once, or per order. On the order as linguist, or in your configuration for a language. A review ordered with replaces goes to the same person.
One linguist, as the list gives them (shortened; values illustrative)
The linguist signs in with their own email and finds the task waiting. They
are shown what a translator would be: the same evidence, string by string.
The brief first. Your instructions, which they confirm before anything can be saved.
Each string with its evidence. Its context and limits, your terms, your translation memory with who reviewed each match and when, the screenshots themselves and your style guide, grouped into the sections of the page the strings sit on.
Edits and notes, kept as drafts. Kept as they type, and never sealed for them: a string is sealed only when they press Sign.
Checked on submit. The checks a translation gets run on their work, with progress shown. What they find comes back one issue at a time, and the string goes back to unsealed; a terminology finding they disagree with can be kept, with a reason that reaches you.
Delivered, read-only. A review they delivered opens again from their own list, each seal checked as it opens.
One string from the Japanese review
titlesigned · edited
We use cookies
Heading of the banner that appears at the bottom of the screen on a first visit. Max ~25 chars.
Sent
クッキーを使用しています
Signed
当社はCookieを使用しています
Note
It is better not to omit "We" to clarify who use cookies.
Review · Seals
Every string, sealed by the linguist who approved it
Each linguist has a key of their own from the moment their record exists,
its public half published with them. A seal covers the source, the translation, its
context and the language pair, with who sealed it and when: what someone holding only the
public key can check. Change a word and it no longer verifies. It says this service attests
that the linguist approved exactly this, unchanged since.
{"context":"Cookie consent panel (shared). Name of the analytics cookie category. Single word if possible.","linguist":"ln_79fdf83b","signed_at":"2026-10-28T07:02:47+00:00","source":"Analytics","source_lang":"en","target":"分析","target_lang":"ja","v":2}
Anyone can check it. With POST /v1/signatures/verify, or with no call to us: Ed25519, the public key it carries, over that JSON with keys sorted, no spaces, NFC text. The recipe.
Not our ids. The string's key and the key's id travel beside the seal, so it holds wherever the string is stored.
Review · After delivery
What comes back, and what to do with it
Each string comes back with what you sent, what the linguist made of it, why,
and their seal. The linguist may also leave a comment on the whole task, with pictures.
One string as delivered, from the Japanese review
{"id": "categories.analytics.title",
"lang": "ja",
"source": "Analytics",
"context": "Cookie consent panel (shared). Name of the analytics cookie category. Single word if possible.",
"target": "分析",
"draft": "アナリティクス",
"verdict": "edited",
"reviewed_by": "ln_79fdf83b",
"note": "アナリティクス is just a transliteration and sounds like a specific service name such as Google Analytics. It should refer to one of cookie categories.",
"signature": {"v": 2, "…": "…"}}
And what you can do with a review
Withdraw or replace. Take a review back before it is delivered: it is charged the platform rate, the strings already sealed and the models used. Or order the new version with replaces: the old one is withdrawn, and the same person gets the new one.
Priced in parts. The platform's $2.50 per 1,000 characters, the model calls that prepared and checked it, at cost, and with one of our linguists their own rate, shown beside them before you order, plus our 30% fee on it. Your own linguists you pay yourself. How a review is charged
Review · Better next time
A linguist's feedback improves your next translations
A review fixes more than the page it reads. What the linguist changes and
explains becomes a rule your next page is translated with, so the same mistake isn't made,
and paid for, twice.
1 · Page 1 is reviewedThe linguist edits, and says whya term changed the same way in 6 strings, formal address made informal, a label shortened to fit, a source sentence that says the wrong thing
2 · Suggested to youA fix for what caused each edita glossary entry, a style-guide rule, better context, a length limit or screenshot, a corrected source; by your agent, not applied automatically
3 · You agreeYour glossary, style guide, source and memory are updatednothing changes until you do
4 · Page 2 gets it rightTranslated with what page 1 taught, it needs fewer fixesand its review is quicker
That is why reviewed work goes one page at a time: a review can't help a page that is already translated.
Reliability
Invalid work stopsbefore it becomes bad work.
Refused at intake. Language pairs and content types you haven't configured, projects that don't exist, and models outside those offered are turned away when the order arrives.
Unknown screenshots are rejected. A string can't point at a screen that was never uploaded.
Checked twice before it is returned. Counted: every string back once, nothing empty, placeholders and tags identical, length limits, line breaks. Judged by a model: your terminology used, ruled-out terms absent.
Failures are sent back, then flagged. Strings that fail a check are retranslated with the findings, up to three attempts, each one logged. A string that still fails comes back with its best attempt and a question about it; the rest of the job is delivered.
Warnings stay visible. Material that couldn't be applied is reported with the result, not silently dropped.
Context window
Sized to what a model reads well,not to what its window holds.
Models advertise windows of a million tokens. Filling one is not reading it carefully, and
a terminology check has to find every bound term in every string. So each call is sized to
what the model reads well: fewer strings, in more calls, than its window would take.
What the window holds1,000,000 tokens
One call, all 200 strings150,000 tokens
15% of the window. Dropped once by the provider; read twice, it missed a planted
glossary error both times.
What a call is allowed32,000 tokens
Until the model is measured. The same 200 strings go in about seven calls.
From a test on a 200-string game interface job: every string, with its translation
memory and glossary terms, fit the checking model's window in one call. That was the call
that missed the error.
The smallest reader decides. Every call is read by more than one model: the one
that translates, and the one that checks your terminology, which reads the whole prompt and
the answer. A call holds as many strings as fit the one that reads least.
Measured, not assumed. Known glossary errors are planted among real strings and
checked at growing call sizes. The largest size that still finds them as well as a small call
does is that model's limit. Until a model is measured, it gets a cautious 32,000 tokens.
Light work stays in one call. The limit is counted in tokens, not strings.
Hundreds of short interface strings still fit in one call; strings that carry many memory
matches and screens go in more, smaller ones.
Never silently. A style guide too long for the limit on its own still goes
through: the model's full window decides then. And a check that cannot run is retried and
reported, never counted as passed.
$2.50 per 1,000 characters, plus model usage at cost. Memory reused word for word
and failed jobs aren't charged. A review by a person adds the linguist's own rate. See pricing
White label, on-premises or your own models? Enterprise →
For developers
Three callsfrom order to result.
Read your configuration, send an order, and
collect the result when the job is done. Every request carries the token issued to
your team.
A key per integration. Mint and revoke your own keys, up to 24, from your cabinet or the API. Every key orders and reads; one you allow can also change your configuration. Only a fingerprint is stored, so a key can't be recovered by anyone, us included, and a revoked one stops on the next request.
Or connect over MCP. The same work as tools at https://t.localize.io/mcp, with the same key: an agent in your editor or assistant can read your configuration, order a translation, wait for it and explain how it was made. Setup below.
Ready for AI coding agents.llms.txt and SKILL.md describe the service for an agent, so one can wire up your integration from the documentation alone.
Tell us what's wrong, from where you are. When your agent meets a bug, an error that doesn't say what to change, or something it needs and can't find, it reports it with POST /v1/feedback or the send_feedback tool. The job, the key and the API version are attached for it. People use Report on the Feedback tab of your cabinet. Every report shows where it stands and our answer.
# 1. what your account is set up for
curl https://t.localize.io/v1/config \
-H "authorization: Bearer $LOCALIZE_IO_TOKEN" -H "API-Version: 2026-11-09.1"
# 2. send an order (returns a job id)
curl -X POST https://t.localize.io/v1/jobs \
-H "authorization: Bearer $LOCALIZE_IO_TOKEN" -H "API-Version: 2026-11-09.1" \
-H "content-type: application/json" \
-d @order.json
# 3. collect the translated order
curl https://t.localize.io/v1/jobs/$JOB_ID/result \
-H "authorization: Bearer $LOCALIZE_IO_TOKEN" -H "API-Version: 2026-11-09.1"
Connect an agent over MCP
Add the server to any MCP client that can send a
header, in your editor or desktop assistant, with a key minted for it,
so it can be turned off on its own. The agent gets tools to see which account
its key is for (whoami), read your configuration and
projects, translate, wait_for_job,
get_result, explain_job, manage
your assets and screenshots, order reviews by your linguists, withdraw a job you no longer want, and
report a problem with send_feedback.
Every rule on this page applies unchanged, and every call lands in your record.