Context-aware localization

Translation that knows where every string belongs.

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.

CurrentEnglish · source
SrovėLithuanian · electrical current

Context

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

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 says Išsaugokite pakeitimus

Išsaugokite pakeitimusas_is

Corrected · EnglishDelete account

Without memory

Ištrinti paskyrąnew

With memory

Memory says Ištrinti paskyyrą (contains a typo)

Ištrinti paskyrąfixed

new translated without a memory entry as_is remembered translation kept, after review, and not charged the per-character rate fixed 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.
Observed cost
$0.0027 without, $0.0041 with

Example 4 · Style guide

Yesterday's translation doesn't overrule today's voice.

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.

  1. ja · ui gpt-6-lunafast · languages.ja
  2. ja · marketing gpt-6.1-solstronger · content_types.marketing.languages.ja
  3. 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.

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.

Account · config.json

{
  "name": "Acme",
  "defaults": {
    "model": "openai/gpt-6-luna",
    "annotator": "google/gemini-3.5-flash-lite",
    "qa": "google/gemini-3.5-flash-lite",
    "selector": "google/gemini-3.5-flash-lite",
    "embedder": "openai/text-embedding-3-small"
  },
  "languages": {
    "de-DE": {},
    "lt":    { "model": "openai/gpt-6.1-sol" },
    "pl-PL": { "from": "de" }
  },
  "aliases": { "de_DE": "de-DE" },
  "content_types": { "ui": {}, "marketing": {} }
}

Project · projects/mobile-app/config.json

{
  "name": "Mobile app",
  "content_types": {
    "ui": {},
    "marketing": { "model": "openai/gpt-6.1-sol" }
  }
}

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

SettingWhat it decidesFor example
languagesThe 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" }
aliasesYour platform's own codes for a declared language. You get your code back in the result."de_DE": "de-DE"
content_typesThe content types an order can name. Each can be routed differently, and every order says which one it is."ui", "marketing"
modelWhich 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"
annotatorWhich model reads your screenshots and writes the description that travels with the strings on them."google/gemini-3.5-flash-lite"
selectorWhich 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"
embedderWhich model your translation memory is searched with, by meaning, so earlier translations worded differently are still found."openai/text-embedding-3-small"
qaWhich 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"
defaultsThe 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.

  1. Project this content type, into this language
  2. Project this content type
  3. Project this language
  4. Project the project, then its defaults
  5. Account this content type, into this language
  6. Account this content type
  7. Account this language
  8. 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
Reviewln_79fdf83bnamed by id

Both

Translategpt-6-lunaevery string
Reviewln_79fdf83bthe strings you choose

Or in the configuration, for a language

"languages": {
  "ja": { "linguist": "ln_79fdf83b" }
}

A real review order: one of its 17 strings

{
  "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

The translator gets · with every string

  • Screenshot

    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.

    images: png · jpg · webp · gif
  • Glossary

    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.

    any export
  • Translation memory

    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.

    any export
  • Style guide

    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.

Your assets · Screenshot · see it in Example 1

A picture of the screen says what 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 assets · Glossary · see it in Example 2

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.

Your assets · Translation memory · see it in Example 3

Your past translations, weighed for every string.

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.

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.

Sent: “Save your changes before leaving?” — six remembered strings, nearest first
0.76Save changes
0.71You have unsaved changes. Leave anyway?
0.61Your changes have been saved
0.50Discard changes
0.36Delete account
0.24Battery 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.

Your assets · Style guide · see it in Example 4

Your rules, applied to every string, in every job.

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.

  1. Accepteden → lt · marketing · project mobile-app · requested by ci@acme.example
  2. Routedmodel gpt-6.1-sol, set by projects/mobile-app/config.json › content_types.marketing
  3. Model call 1 · selectionchose what the string is shown: 1 glossary term of 1 · no memory match · no screen · $0.0003
  4. Context assembledthe chosen term on the string · style guide applied
  5. 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"}
  6. Model call 3 · terminology checkjudged: the required term was used · no findings · $0.0004
  7. Checkedcounted: all strings back, placeholders identical, limits kept · passed on attempt 1 of 3
  8. 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.

The client cabinet: jobs, characters, price, model usage, failures and warnings at the top; a list of jobs with their project, model, characters and price; and one job open beside it, showing its languages, requester, pass, model, characters, model usage, its price as characters at the plan's rate plus model usage at cost, and the start of its record.
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)

{
  "id": "ln_3f9a01c2",
  "level": "service",
  "pairs": [{"from": "en", "to": "ja"}],
  "price_per_1k_characters_usd": 10.5,
  "workload": {
    "queue": {"tasks": 3, "strings": 140, "characters": 9800},
    "yours": {"tasks": 1, "strings": 17, "characters": 663}
  },
  "throughput": {"chars_per_day": 12000, "basis": "measured"},
  "schedule": {"timezone": "Asia/Tokyo",
               "days": ["mon", "tue", "wed", "thu", "fri"],
               "hours": "09:00-18:00"},
  "availability": {"now": true},
  "keys": [{"key_id": "…", "public_key": "…", "alg": "Ed25519"}]
}

Review · The linguist's page

What the linguist sees, and what they do

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.

A real seal, from the Japanese review

"signature": {
  "v": 2, "alg": "Ed25519",
  "linguist": "ln_79fdf83b",
  "key_id": "53a6fcfa5a424554",
  "public_key": "KQu6yiHwc6+KXzZXDDDNdhfa0MpMA27evUDYWNiAVGQ=",
  "signed_at": "2026-10-28T07:02:47+00:00",
  "sig": "2aeCfP2t2mm5w3ZpDNNnHavpzzajpLNoT7bj1+cPRp0lRtPfBTRkJxo91rFTOLJ3ap7qgcHtw9xUkt/0R5HVBg=="
}

Exactly what it seals: these bytes

{"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. 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. 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. 3 · You agreeYour glossary, style guide, source and memory are updatednothing changes until you do
  4. 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 stops before 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 calls from 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.

{
  "mcpServers": {
    "localize": {
      "type": "http",
      "url": "https://t.localize.io/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_KEY"
      }
    }
  }
}