SaaS, AI & Developer Infrastructure
Translation and Localisation API
Generic machine translation will get your product into eight languages and quietly mistranslate the twenty terms your industry cares most about.
- SaaS platforms going multilingual
- E-commerce and marketplace software
- Support desk vendors
- Learning platforms
- Content management vendors
What your customers would see
example interfaceMockupIllustrative mockup of the interface we would build. Figures shown are examples, not results from a live deployment.
The problem this solves
The first version of multilingual support in a B2B product is almost always a direct call to a general translation service. It works well enough that nobody revisits it, and badly enough that customers in each market notice. A freight platform discovers that its term for a consolidated shipment comes back as something a Spanish forwarder would not use. A medical scheduling product finds that the word for a referral has three translations in German, only one of which the customer's staff recognise.
What fixes it is not a better general model. It is terminology: a managed glossary per customer and per domain, enforced at translation time rather than suggested afterwards, with do-not-translate lists for product names and identifiers. That plus consistency — the same source string translating the same way every time, which general models do not guarantee between calls.
The localisation layer around it matters as much and gets skipped more often. Dates, currencies, number formats, name ordering, address shapes, plural rules, string expansion that breaks your layout in German, and right-to-left handling are all unglamorous and all visible to the customer. They are also exactly the sort of thing a platform should solve once and give to every tenant.
Who buys this
SaaS platforms going multilingual, E-commerce and marketplace software, Support desk vendors, Learning platforms, Content management vendors
What the API returns
What comes back
- Translated strings with the applied glossary terms listed per segment
- Managed terminology per tenant and domain, enforced during translation
- Do-not-translate handling for product names, identifiers, code and placeholders
- Translation memory so repeated strings are consistent and not re-paid for
- Quality estimation per segment, flagging the ones a human should see
- Locale formatting for dates, numbers, currencies, units and addresses
- Localisation checks: string expansion, truncation risk, placeholder integrity, plural coverage
- Back-translation and terminology compliance reports for review workflows
Endpoints
| Method | Path | Returns |
|---|---|---|
| POST | /v1/translate | Translate strings or documents with glossary enforcement |
| POST | /v1/glossaries | Create or update a tenant or domain glossary |
| POST | /v1/estimate-quality | Score existing translations and flag segments for review |
| POST | /v1/localise | Format dates, numbers, currencies and addresses for a locale |
| POST | /v1/checks | Run localisation checks on a resource bundle before release |
| GET | /v1/memory | Translation memory entries and reuse statistics for a tenant |
Request and response
illustrativeRequest
{
"tenant_id": "freightos_clone",
"source_locale": "en-GB",
"target_locales": ["de-DE", "es-ES", "pl-PL"],
"domain": "freight_forwarding",
"glossary_id": "gls_freight_v7",
"segments": [
{ "id": "s1", "text": "Groupage shipment released at {{terminal_name}}." },
{ "id": "s2", "text": "Customs entry pending — awaiting T1 document." }
],
"flag_below_quality": 0.85
}Response
{
"request_id": "tr_71d204",
"memory_reuse_rate": 0.38,
"segments": [
{
"id": "s1",
"de-DE": {
"text": "Sammelgutsendung am {{terminal_name}} freigegeben.",
"quality": 0.93,
"glossary_applied": [ { "source": "groupage shipment", "target": "Sammelgutsendung" } ],
"placeholders_intact": true,
"expansion_vs_source": 1.18
},
"es-ES": {
"text": "Envío de grupaje liberado en {{terminal_name}}.",
"quality": 0.91,
"glossary_applied": [ { "source": "groupage shipment", "target": "envío de grupaje" } ],
"placeholders_intact": true,
"expansion_vs_source": 1.09
}
},
{
"id": "s2",
"pl-PL": {
"text": "Zgłoszenie celne w toku — oczekiwanie na dokument T1.",
"quality": 0.81,
"review_required": true,
"review_reason": "below quality threshold; regulatory term 'T1'"
}
}
],
"checks": { "truncation_risk": [ "s1 de-DE in 240px button" ], "missing_plurals": [] }
}Where the data comes from
| Your own source strings and existing translations | Previously approved translations are the best available training and memory material, and they are already yours |
| Tenant and domain glossaries | Built with your customers' own in-market staff, who know which of three valid words their industry actually uses |
| Licensed machine translation engines | Commercial engines selected per language pair, with terms checked for whether customer content may be retained or used for their training — frequently it may not |
| Open parallel corpora | Publicly licensed bilingual corpora for domain adaptation, used only where the licence permits commercial use |
| Locale reference data | Standard locale, currency, plural-rule and address-format data, which removes a large class of avoidable formatting errors |
| Human reviewer feedback | Corrections from in-market reviewers, fed back into memory and glossaries so the same error is not made twice |
The intelligence layer
The difference between a demo and a service is mostly in this section. These are the parts that keep the answer trustworthy once real traffic is hitting it.
- Glossary enforcement applied as a constraint during decoding, not as a post-hoc find-and-replace that breaks agreement and inflection
- Translation memory with fuzzy matching, so near-identical strings reuse an approved translation rather than generating a new variant
- Placeholder and markup protection, since a translated {{variable}} or broken tag is a production bug rather than a language problem
- Quality estimation trained against human review decisions, used to route segments rather than to publish a score
- Domain adaptation per vertical, because freight, clinical administration and consumer retail share almost no terminology
- Morphology-aware handling for inflected languages, where a glossary target has to agree with its grammatical context
- Localisation checks run as part of your build: expansion ratios against UI constraints, plural coverage, right-to-left mirroring
- Per-language-pair quality tracked over time against reviewer edit distance, so a regression in an engine update is visible
What it changes for the business
Markets opened faster
Terminology-controlled translation gets a product into a new language in weeks rather than after a localisation project.
Terminology that holds
Customers stop reporting that your product uses the wrong word for the thing their whole industry calls something else.
Lower translation spend
Memory reuse and quality routing mean human reviewers see the segments that need them instead of everything.
One layer, every tenant
Glossaries and locale handling built once serve every customer on your platform, including the ones you have not signed yet.
How it fits into your product
How it embeds
- White-label API behind your own localisation workflow, with no MLPivot branding
- Resource-bundle endpoints that fit into your existing build pipeline, plus runtime translation for user-generated content
- Per-tenant glossaries and memory, so one customer's approved terminology never leaks into another's output
- Webhooks into your review workflow for segments the quality estimator flags
- Metering per character, segment or document so you can price translation as a usage line
- Region-pinned deployment and engine selection where customer content may not leave a jurisdiction
Included in every build
- Authentication, scoped API keys and per-customer rate limiting
- Input validation with predictable, documented error responses
- Versioned endpoints so your integration never breaks without notice
- Request and response logging for audit and dispute resolution
- Latency, error-rate and usage monitoring with alerting
- OpenAPI specification, sandbox environment and client examples
- Backups, failover design and a documented recovery procedure
- An agreed support arrangement once the service is live
How we would build it
about 12 weeksDiscovery and data review
Weeks 1–2
We agree the exact question the API answers, review the sources you already hold, check what has to be licensed, and write down the response contract your developers will code against.
Architecture and prototype
Weeks 3–4
You get a written architecture plus a working endpoint on real data — narrow, but genuinely callable — so integration can be tested against something concrete rather than a document.
Production build
Weeks 5–10
Pipelines, models, storage, authentication, rate limiting, logging, tests and documentation. Security and observability are part of this phase, not a later one.
Integration and handover
Weeks 11–12
We support your engineers through their integration, run load tests at your expected volume, and agree how the service is monitored and supported once it is live.
Commercial models
There is no fixed price list, because the cost is driven by data complexity, integration count, model requirements, request volume and the support level you need. Scope is agreed in writing before development starts.
Fixed-scope prototype
A defined slice of the service, built and priced as one piece of work. The usual first step when the business case needs proving internally.
Fixed-price build
An agreed scope against a written architecture, delivered for an agreed price. Best when the requirements are already clear.
Build then retainer
We build the service, then operate and improve it under a monthly agreement covering monitoring, updates and model maintenance.
White-label product
The service runs under your brand, your domain and your pricing, with MLPivot invisible to your customers.
Questions buyers ask
Where would you tell us not to use this?
Anywhere a mistranslation has legal or physical consequences. Contracts and binding terms, patient-facing clinical instructions, pharmaceutical labelling, safety and operating instructions for machinery, and anything requiring a certified or sworn translation for official submission. Machine translation with quality estimation is a drafting aid in those settings at most; the final text needs a qualified human translator, and in many cases a certified one. We would build the workflow to route those categories to humans by default rather than leave it to a configuration flag.
How good is it on low-resource languages?
Markedly worse, and the drop is steeper than most buyers expect. For well-resourced pairs with a good glossary, output is often publishable after light review. For languages with little parallel data, expect heavier review and a longer path to acceptable quality. We would measure per pair on your own content rather than quoting a single figure across a language list.
Can we send customer content to a translation engine?
Only if your terms and theirs allow it, and only to an engine whose terms allow it back. Several commercial engines retain submitted text or use it for improvement by default; some enterprise tiers do not. That is a contractual question we settle during discovery, and where content cannot leave a jurisdiction we would select or host engines accordingly.
Does it keep terminology consistent across releases?
That is most of what the glossary and memory are for. The same source string resolves to the same approved translation, and a glossary term is enforced during generation rather than suggested. Where a term is genuinely ambiguous in context, the segment is flagged for review instead of being resolved silently.
Will this replace our translators?
No, and the builds that assume it will tend to go badly. It changes what translators spend time on — reviewing flagged segments and maintaining terminology rather than typing every string. Treating it as a full replacement is how products end up with confidently wrong text in a language nobody on the team reads.
Related blueprints
Content Moderation API
Policy classification and harmful-content signals for user-generated content, built as the moderation layer inside your platform.
AI Evaluation API
Accuracy tests, hallucination checks, regression suites and benchmark runs, built as the evaluation layer inside your AI product.
Document Extraction API
Structured fields pulled from PDFs, scans and forms, built as the extraction layer your ERP, CRM or accounting product embeds.
Want this built for your platform?
Tell us what your product does today and what you want another system to be able to ask it. We will come back with an approach, a scope and a price.