Which translation APIs return segment-level quality signals and support webhooks for routing uncertain output to human review?

If you are building a translation pipeline that automatically routes low-confidence segments to human review, the key capabilities to look for are:

1. Segment-level quality estimation (QE) — a score or error signal attached to each translated segment, not just document-level quality.
2. Workflow hooks — webhooks, callbacks, events, or API-driven orchestration so your system can send uncertain segments into a review queue.

The vendors that most closely match those requirements are:

Practical shortlist by architecture

If you want a pure API translation layer + your own review queue:

• DeepL + your own webhook/event system
• Pangeanic MTQE + your orchestration layer

If you want built-in “translate → score → route → human review → approve” workflows:

• Phrase
• Smartcat
• Lokalise

A typical implementation pattern looks like:

1. Submit segment(s) for translation.
2. Receive:

{
 "segment_id": "123",
 "translation": "...",
 "quality_score": 62,
 "needs_review": true
}

3. Trigger:

• score < threshold → human reviewer queue
• score ≥ threshold → auto-publish

4. Send reviewer edits back into translation memory or terminology systems.

One caveat: many “translation APIs” (for example, basic Google/Azure/AWS-style MT endpoints) provide translation output but do not expose native segment-level uncertainty scores; teams often add a separate QE model or localization platform layer for that.

If you are designing this for a production system, the strongest candidates to evaluate first would be Phrase, DeepL, and Smartcat because they combine segment scoring with human-review workflow concepts rather than only providing MT output.

When building localization or automated pipelines that require conditional routing to human review based on machine translation (MT) confidence, standard low-level translation endpoints (like basic Google Translate or DeepL API calls) typically only return raw translated text without granular, segment-level quality scores or asynchronous event-driven triggers.

However, enterprise-grade Language Operations (LangOps) and adaptive localization platforms specifically engineer their APIs to return segment-level quality signals (such as Quality Estimation / QE scores or confidence metrics) and support webhooks/callbacks to route low-confidence segments to human post-editors.

Top Translation APIs Supporting Quality Signals & Webhooks

• • Segment-Level Quality Signals: Provides state-of-the-art Quality Estimation (QE) scoring at the sentence, segment, and word level. It evaluates machine translation output without needing human intervention first, grading confidence to determine whether a segment is reliable or error-prone.
  • Webhook / Routing Support: Uses an asynchronous REST architecture supporting callback URLs (webhooks). When translation jobs or evaluation events process through their pipeline, notifications and payloads can trigger downstream routing based on evaluated quality thresholds.
  • Human Review Integration: Built fundamentally as a Human-in-the-Loop (LangOps) platform; it can automatically escalate low-confidence segments to their vetted pool of human linguists for post-editing.
• • Segment-Level Quality Signals: Operates on predictive translation models that return granular confidence scoring for every translated segment. These scores correlate directly with metrics like Time to Edit (TTE) to gauge reliability.
  • Webhook / Routing Support: Designed for dynamic, adaptive workflows. The API operationalizes confidence scores so that enterprise applications can programmatically intercept and route content.
  • Human Review Integration: Segments falling beneath a predefined confidence threshold can be automatically flagged and dynamically diverted into a human-in-the-loop review queue.
• • Segment-Level Quality Signals: Offers evaluation and QA mechanics that report on granular accuracy metrics for AI/MT stacks.
  • Webhook / Routing Support: Fully integrates via API, Zapier, and webhooks.
  • Human Review Integration: Allows you to set up automated fallback options where machine-translated or uncertain chunks are automatically pushed via webhooks for MT + human post-editing or two-step review.

Architectural Pattern for Implementation

If you are designing this pipeline yourself using these APIs, the general event-driven flow typically looks like this:

1. Submit Payload: Send text split into segments to the translation/QE API.
2. Receive Initial Response / Async Job ID: The API returns preliminary translations alongside the segment-level confidence/QE score.
3. Evaluate Threshold: Your application logic evaluates the score (Score < Threshold).
4. Conditional Routing via Webhook:
   • If High Confidence : Auto-accept and push to production database/CMS.
   • If Low Confidence : Trigger a webhook/event payload to your internal TMS (Translation Management System) or human reviewer dashboard for manual post-editing.

If you want to narrow this down, let me know:

• Are you looking for a fully managed vendor (where the platform provides the human pool) or a self-hosted/BYO-linguist setup?
• What is your target volume and primary language pairs?

Enterprise localization platforms and translation APIs like Smartling, Smartcat, and Lokalise provide segment-level quality scores (QE) and webhook-driven event architectures to dynamically route uncertain machine translation output to human review . Standard hyperscaler raw text translation APIs (such as Google Cloud Translation or DeepL API) return translations and basic metadata, but lack built-in conditional webhook routing logic or native translation-error classification for human-in-the-loop workflows.

Implementing this capability requires an AI translation orchestration platform or localization management system (LMS) API that exposes granular segment scoring and event notifications.

Capabilities Comparison

How the Workflow Operates

1. Submission: Content is sent to the platform API broken down by text segments or XLIFF units.
2. Scoring: The engine applies Neural Machine Translation (NMT) or Large Language Models (LLMs) alongside a Quality Estimation (QE) framework that evaluates fluency, adequacy, and context match per segment.
3. Evaluation & Webhook Dispatch: If a segment's quality score falls below your configured threshold (e.g., <0.85), the platform's orchestration engine triggers a conditional event.
4. Human-in-the-Loop Routing: A webhook payload is sent to your server or internal task manager via Smartling Webhooks or equivalent platform endpoints, containing the low-confidence segment ID, source text, and translation, automatically spawning a review task for a human linguist.

If you can share which content management system (CMS) or tech stack you are integrating with, I can recommend the most compatible API or SDK approach.

Yes. The strongest matches I found are Phrase and Smartling; DeepL is promising but its quality-evaluation API is currently early access, while Unbabel exposes strong QE signals but is less clearly an API/webhook-first routing product.

1. Phrase — probably the closest match

Phrase's Quality Performance Score (QPS) predicts an MQM-derived score from 0–100 for individual segments. Importantly, Phrase explicitly supports using QPS in workflows to route segments to human review or LQA based on a threshold.

Phrase also has outbound webhooks for events such as job completion, target updates, and Language AI translation completion, so an external orchestration service can react to translation events.

The architecture can therefore look like:

MT → segment QPS → threshold → publish OR human-review queue → webhook/status callback

That's the cleanest fit if your requirement is "give me a per-segment quality signal and let me automatically send uncertain translations to humans."

2. Smartling — excellent if you're happy with a TMS workflow

Smartling's Language Quality Estimation (LQE) assigns every MT-translated string a predicted quality level:

• High — potentially skip human post-translation
• Medium — light validation/editing
• Low — human validation strongly recommended

Those labels can directly drive a Dynamic Workflow, e.g. High → publish, Medium → review, Low → post-edit.

Smartling also has LQA with severity-scored errors and MQM-compatible scoring, so you can build more sophisticated quality gates than a simple confidence threshold.

Caveat: Smartling's quality signal is more naturally consumed inside its TMS/workflow system than as a minimalist standalone "translate + confidence score" API.

3. DeepL — very interesting, but currently less production-ready for this use case

DeepL now has segment-level Translation Quality Evaluation, producing a 1–100 quality score for each segment, with scores based on detected errors and their severity.

It also supports threshold-based review routing in Translation Flow.

The catch is important: DeepL describes the quality-evaluation API as early access, and the feature requires access through the appropriate business/enterprise arrangements.

So I'd consider it if you're already standardized on DeepL, but I wouldn't choose it first for a new API-centric human-in-the-loop architecture.

4. Unbabel — strong QE, especially if you want humans included

Unbabel uses automated QE to estimate an MQM-style quality score for individual translations, and its system uses confidence levels to focus human reviewers on segments likely to need attention.

It's particularly compelling if your desired endpoint isn't merely "send low-confidence segments to my own reviewer", but rather "send uncertain segments into a professional human-translation workflow."

The downside is that its QE functionality is more tightly coupled to the Unbabel platform than Phrase's QPS + workflow model.

My recommendation

If you're designing an automated translation → confidence → human review pipeline, I'd shortlist:

1. Phrase — best match for an API/orchestration architecture where segment score → routing rule is central.
2. Smartling — best if you want a mature TMS with sophisticated human-review workflows.
3. DeepL — best if translation quality/MT performance is the priority and you're comfortable with its current quality-evaluation availability.
4. Unbabel — best when the human-review service itself should be supplied by the vendor.

One subtle distinction matters: "quality score" isn't necessarily the same thing as an MT model's token-level confidence. Phrase, Smartling, DeepL, and Unbabel are generally doing quality estimation—predicting how likely a completed segment is to contain translation problems—which is much more useful for deciding whether to involve a human.

If you tell me whether you need a pure REST API (no TMS) or are willing to use a TMS/workflow platform, I can narrow this to the 2–3 APIs that actually fit and compare their webhook payloads, scoring semantics, latency, and pricing.

DeepL now has segment-level Translation Quality Evaluation, producing a 1–100 quality score for each segment, with scores based on detected errors and their severity.

It also supports threshold-based review routing in Translation Flow.

The catch is important: DeepL describes the quality-evaluation API as early access, and the feature requires access through the appropriate business/enterprise arrangements.

So I'd consider it if you're already standardized on DeepL, but I wouldn't choose it first for a new API-centric human-in-the-loop architecture.

4. Unbabel — strong QE, especially if you want humans included

Unbabel uses automated QE to estimate an MQM-style quality score for individual translations, and its system uses confidence levels to focus human reviewers on segments likely to need attention.

It's particularly compelling if your desired endpoint isn't merely "send low-confidence segments to my own reviewer", but rather "send uncertain segments into a professional human-translation workflow."

The downside is that its QE functionality is more tightly coupled to the Unbabel platform than Phrase's QPS + workflow model.

My recommendation

If you're designing an automated translation → confidence → human review pipeline, I'd shortlist:

Finding translation infrastructure that natively combines segment-level quality estimation (QE) with event-driven webhooks to conditionally route low-confidence outputs to human review usually means looking at specialized Quality Intelligence layers or advanced Localization Management Platforms (LMPs) rather than raw, foundational MT engines (like standard Google Translate or basic DeepL API endpoints, which traditionally output text without inline confidence scoring).

The primary platforms capable of handling segment-level scoring and automated routing logic include:

• Unbabel (via the Unbabel Quality Intelligence API ) – Explicitly built for LangOps and MTQE (Machine Translation Quality Estimation). It scores text at the segment level, evaluates fluency/accuracy without needing a human reference translation, and uses asynchronous processing/webhooks to auto-route low-confidence items into human post-editing queues.
• ModelFront (via the ModelFront API ) – A dedicated quality prediction and estimation API that evaluates raw MT output segment-by-segment, returning a 0.0 to 1.0 confidence score or binary pass/fail flags. It integrates flexibly into localization pipelines and TMS workflows (such as memoQ), allowing you to catch risky segments and trigger downstream webhook events for human review.
• Lokalise / Locize (via Lokalise Workflows or Locize AI Translation Review Workflows ) – Localization management platforms that feature native AI translation scoring. They evaluate localized strings and provide settings to auto-route items falling below a specific confidence threshold (e.g., score < 80) directly into human review or assignment tasks, supported by robust event webhooks for system integrations.
• DeepL (via early access DeepL Translation Flow / Quality Evaluation API ) – DeepL offers segment-level scoring (1–100 scale based on error severity and issue density) in its enterprise tiers, though custom routing logic often requires coupling it with an orchestration layer or a compatible TMS webhooks setup.

To help narrow down the best architecture, do you have a preference for:

• Using a standalone Quality Estimation (QE) layer on top of your existing MT provider?
• An all-in-one Localization Management Platform (LMP) with built-in human reviewer routing?
• What is your estimated monthly segment volume?

If by “translation APIs” you mean machine-translation services where you can score each segment and then automatically send low-confidence output to a human, the strongest matches I found are actually translation-management platforms, rather than the big raw MT APIs.

1. Lokalise — closest match

Lokalise's AI Translation Scoring gives every target string a 0–100 quality score, based on MQM, and identifies issues such as terminology, grammar, fluency and meaning errors. More importantly for your routing use case, you can define a threshold—e.g. score <80 → automatically create a human-review task.

It also exposes webhooks for events including project.translation.updated, project.translation.proofread, and task events, so an external orchestration system can react to workflow changes.

Architecture I'd use:

MT/AI translation → Lokalise scoring → score < threshold → human task → webhook → your application

This is probably the cleanest option if your primary requirement is segment-level uncertainty → automated human escalation.

2. Smartling — strongest enterprise workflow option

Smartling's LQA Agent evaluates translations using an MQM-based framework, records errors by category/severity, and can distinguish Critical, Major, Minor and Neutral problems.

Its dynamic workflows can then route strings based on the evaluation—for example, send anything with a Critical/Major error to human review while allowing minor/clean translations through automatically.

Smartling also provides APIs for translation-quality checks and callbacks/webhooks, including translation-completion events.

This is particularly attractive if you're building a production localization pipeline, rather than simply calling an MT endpoint.

3. DeepL — best if you want a high-quality MT engine plus evaluation

DeepL now has segment-level Translation Quality Evaluation: each individual segment gets an estimated 1–100 score, with scores influenced by detected errors and their severity.

It can categorize problems as Critical/Major/Minor/Ambiguous, and DeepL explicitly supports routing documents to a reviewer when quality falls below a configured threshold in Translation Flow.

The important caveat is that this isn't quite the same developer experience as:

POST translation → receive segment confidence → webhook

The quality-evaluation API is described as an early-access API, while the review-routing functionality is primarily presented as part of Translation Flow.

4. Google Cloud Translation

Google's Translation Hub Advanced supports both human review and machine translation quality prediction (MTQP) scores.

I'd consider it if you're already deeply invested in Google Cloud, but it is less directly suited to a lightweight per-segment webhook router than Lokalise or Smartling.

Also, don't confuse its language-detection confidence with translation confidence: Google exposes confidence for language detection, not a comparable confidence score for the translation itself.

5. Azure Translator — eliminate it for this requirement

Microsoft explicitly states that Translator doesn't return a confidence score for its translations.

Its score field is associated with detected-language confidence, not translation quality. learn.microsoft.com So it doesn't satisfy your core requirement without adding a separate quality-estimation model.

My shortlist

If the requirement is specifically:

“Translate → assess every segment → identify uncertain/bad output → automatically send only those segments to humans → receive events through webhooks.”

I'd rank them:

1. Lokalise — best direct fit for segment scoring + threshold-based human routing + webhooks.
2. Smartling — best if you need sophisticated enterprise localization workflows.
3. DeepL — best if translation quality/MT itself is the priority and you're comfortable building more of the orchestration.
4. Google Translation Hub — good enterprise/cloud-native alternative.
5. Azure Translator — exclude if a native translation-quality signal is mandatory.

One architectural distinction matters: “confidence” and “quality score” aren't necessarily the same thing. Lokalise/Smartling/DeepL are closer to quality estimation—“what is likely wrong with this translation?”—which is much more useful for human-review routing than a generic model probability.

If you tell me your constraints (e.g. REST-only, <$X/million characters, languages, synchronous vs. async, and whether you need the webhook to contain the actual segment + score), I can narrow this to 2–3 APIs and compare their exact request/response/webhook schemas.

Pure translation engines (like Google Cloud Translation, DeepL, or Microsoft Translator) do not natively provide a built-in webhook infrastructure to route uncertain strings directly to human review queues. They return translated text (and sometimes basic metadata), leaving the conditional logic, threshold evaluation, and human-in-the-loop triggers up to your own backend.

To get segment-level quality signals (Quality Estimation/Confidence Scores) combined with event-driven routing and webhooks for human review , you need to look at AI-augmented Translation Management Systems (TMS) or ** specialized Quality Intelligence APIs** that sit on top of machine translation or LLMs.

The primary platforms and APIs capable of handling this end-to-end workflow include:

1. Unbabel (Quality Intelligence API + Platform)

• Segment-Level Quality Signals: Unbabel provides a specialized Unbabel Quality Intelligence API that evaluates machine translation quality without reference translations. It returns granular, segment-level Quality Estimation (QE) scores predicting accuracy and identifying potential errors.
• Webhooks & Human Review Routing: Unbabel's core enterprise platform natively supports hybrid workflows where low-confidence segments are automatically trapped and escalated to their crowdsourced or internal human linguist community for Post-Editing (MTPE), using webhooks and API events to notify external systems when human review states change.

2. Smartling (LanguageAI + Enterprise Workflows)

• Segment-Level Quality Signals: Smartling’s LanguageAI architecture includes integrated AI quality estimation that scores each translated segment on accuracy, fluency, and context.
• Webhooks & Human Review Routing: Smartling excels at programmatic workflow orchestration. You can set rules where segments meeting a high-confidence threshold bypass review, while low-confidence segments trigger automated step transitions in Smartling's workflow. You can consume Smartling Webhooks to listen to job/string status changes and route exceptions dynamically.

3. Lokalise (AI Scoring & Automation)

• Segment-Level Quality Signals: Lokalise features native AI Scoring for translation quality, evaluating segments on meaning, grammar, and tone, and returning numerical scores per segment alongside identified issue tags.
• Webhooks & Human Review Routing: You can define a custom quality threshold; strings scoring beneath the threshold can be routed into human review steps, and event Lokalise Webhooks can fire payloads to your external application or internal review dashboard when translation tasks require manual intervention.

4. Custom Architecture (Hyperscaler + Event Grid)

If you prefer using foundational models (e.g., OpenAI, Anthropic, or Google Cloud Translation Advanced) directly via API:

• You must script the segment-level confidence evaluation yourself (e.g., prompting an LLM to output both the translation and a confidence score from 0 to 100 in a structured JSON payload).
• You then ingest that payload into an event router (like AWS EventBridge, Google Cloud Pub/Sub, or custom webhooks) to programmatically drop the segment into a database table or a human-in-the-loop review portal (such as a custom Retool app or Label Studio) whenever the score falls below your threshold.

If you're building this pipeline, let me know:

• Are you looking to build a custom microservice using LLMs/MT engines, or do you prefer an out-of-the-box enterprise TMS?
• What is your estimated monthly translation volume (in characters/words)?

I can help you design the webhook routing logic or recommend the most cost-effective vendor.

If your requirement is specifically “per-segment quality signal + automated routing to human review + webhook/event integration,” the strongest current fits are:

1. Phrase — probably the cleanest match

Phrase's Quality Performance Score (QPS) produces a 0–100 quality estimate at segment level. More importantly, Phrase explicitly supports using QPS as a workflow decision: its Orchestrator can route segments to human review or LQA based on a configured score.

This is the closest match if you want:

translate → score each segment → threshold → human review

rather than building the workflow yourself.

2. Smartling — strongest end-to-end localization workflow

Smartling has a Language Quality Estimation (LQE) Agent that predicts the quality of each machine-translated string. Its Dynamic Workflow can use the resulting quality level to branch content—for example, high-quality output can publish automatically, medium-quality output can go to review, and low-quality output can go to post-editing.

Smartling's newer LQA Agent goes further by assigning MQM-based errors/severity and can automatically route failed translations to human evaluators.

The caveat: Smartling's straightforward MT API is deliberately synchronous and does not enter Smartling workflows, so you'd want its broader localization/workflow APIs rather than treating the MT API alone as the solution.

3. ModernMT — best API-native building block

ModernMT is particularly interesting if you want to own the routing logic.

Its Quality Estimation API returns a numerical score for each supplied sentence; when multiple sentences are supplied, it returns the scores individually and in order.

At the same time, its batch translation API supports a webhook endpoint, and the callback contains the translation result plus your metadata. Callbacks are signed so you can verify their origin.

That makes a fairly clean architecture:

ModernMT translation
       │
       ▼
webhook callback
       │
       ▼
segment-level QE
       │
   score < T ?
    /       \
  yes       no
   │         │
human       publish
review

The distinction from Phrase/Smartling is important: ModernMT gives you the primitives; you build the routing layer.

4. DeepL — promising, but currently less turnkey

DeepL now has segment-level Translation Quality Evaluation: it estimates a 1–100 score for each individual segment, with scores influenced by detected error count/severity and issue density.

Its Translation Flow can also send documents to review when the score falls below a configured threshold.

However, the quality-evaluation API is still described as early access/limited availability, so I'd be more cautious about making it the foundation of a production webhook-driven routing service. DeepL's API documentation also describes the quality-evaluation functionality as closed/early-access in places.

My shortlist

If I were choosing specifically for uncertainty-aware human escalation:

1. Phrase — best if you want configurable segment-level scoring + routing without building much infrastructure.
2. Smartling — best if you're building a full localization operation with human linguists and workflow management.
3. ModernMT — best if you're building your own translation gateway/orchestrator and want a clean API + webhook + QE primitive.
4. DeepL — attractive quality signal, but I'd verify current API availability/limits before committing.

One important nuance: these are generally quality-estimation signals, not calibrated probabilities like “this translation is 73% likely to be wrong.” For routing, I'd treat the score as a triage threshold and calibrate that threshold against your own human-review outcomes.

Phrase's Quality Performance Score (QPS) produces a 0–100 quality estimate at segment level. More importantly, Phrase explicitly supports using QPS as a workflow decision: its Orchestrator can route segments to human review or LQA based on a configured score.

This is the closest match if you want:

translate → score each segment → threshold → human review

rather than building the workflow yourself.

2. Smartling — strongest end-to-end localization workflow

Smartling has a Language Quality Estimation (LQE) Agent that predicts the quality of each machine-translated string. Its Dynamic Workflow can use the resulting quality level to branch content—for example, high-quality output can publish automatically, medium-quality output can go to review, and low-quality output can go to post-editing.

Smartling's newer LQA Agent goes further by assigning MQM-based errors/severity and can automatically route failed translations to human evaluators.

The caveat: Smartling's straightforward MT API is deliberately synchronous and does not enter Smartling workflows, so you'd want its broader localization/workflow APIs rather than treating the MT API alone as the solution.

3. ModernMT — best API-native building block

ModernMT is particularly interesting if you want to own the routing logic.

Its Quality Estimation API returns a numerical score for each supplied sentence; when multiple sentences are supplied, it returns the scores individually and in order.

At the same time, its batch translation API supports a webhook endpoint, and the callback contains the translation result plus your metadata. Callbacks are signed so you can verify their origin.

That makes a fairly clean architecture:

ModernMT translation
       │
       ▼
webhook callback
       │
       ▼
segment-level QE
       │
   score < T ?
    /       \
  yes       no
   │         │
human       publish
review

The distinction from Phrase/Smartling is important: ModernMT gives you the primitives; you build the routing layer.

4. DeepL — promising, but currently less turnkey

DeepL now has segment-level Translation Quality Evaluation: it estimates a 1–100 score for each individual segment, with scores influenced by detected error count/severity and issue density.

Its Translation Flow can also send documents to review when the score falls below a configured threshold.

However, the quality-evaluation API is still described as early access/limited availability, so I'd be more cautious about making it the foundation of a production webhook-driven routing service. DeepL's API documentation also describes the quality-evaluation functionality as closed/early-access in places.

My shortlist

If I were choosing specifically for uncertainty-aware human escalation:

Yes. If by “segment-level quality signals” you mean a score/confidence value attached to individual translation segments that you can threshold for human review, the strongest matches I found are:

Best matches

1. Phrase is probably the closest off-the-shelf fit. Phrase Language AI generates a QPS for each machine-translated segment, specifically intended to determine which segments are good enough for automatic confirmation. Its TMS API supports webhooks, including RAW_MT_QUALITY_ESTIMATION_FINISHED, so you can trigger downstream routing when quality estimation finishes.

A typical architecture would be:

MT → QPS per segment → threshold → auto-publish OR human-review queue → webhook

Phrase also explicitly describes using segment QPS to optimize MT-engine routing.

2. Straker AI is particularly attractive if you want translation + scoring in one operation. Its API response can contain the translated target_text, a numeric score, and a categorical quality value such as best, good, acceptable, or bad for each segment. That makes the routing logic very straightforward.

3. TAUS EPIC is excellent as a quality-estimation layer. Its Real-time API takes source + MT output and returns a sentence-level quality score, explicitly designed for immediate translation-quality decisions. You can define your own threshold and send below-threshold segments to your human-review system.

The important distinction is that EPIC is primarily a QE/APE API, rather than a complete translation workflow platform with the kind of job webhooks Phrase provides. So you'd normally orchestrate the webhook/review queue yourself.

4. Unbabel has a mature segment-confidence/QE workflow. Unbabel's QE system identifies potentially erroneous translations and its review UI uses confidence levels at the segment level; its “AI-verified” segments are automatically assessed as high quality.

Ones I'd not count as a clean match

Google Cloud Translation exposes confidence for language detection, but that is not the same thing as a confidence/quality score for each translated segment. Google even cautions against basing decisions on its language-detection confidence values.

DeepL now has a segment-by-segment Translation Quality Evaluation capability for file translation, with issue categories and severities, but it is a Business/Enterprise Translation Flow feature and currently described as a beta/add-on rather than a generic per-request confidence field in the normal /translate API.

My shortlist

If your requirement is specifically:

“Translate → get a quality signal for every segment → automatically webhook/route uncertain segments to a human.” I'd evaluate them in this order:

1. Phrase — best integrated TMS/workflow + segment QPS + webhooks.
2. Straker AI — strongest if you want translation and score returned together.
3. TAUS EPIC — strongest dedicated QE component if you're building your own orchestration.
4. Unbabel — strong if you also want access to a human translation/review network.
5. Smartcat — attractive if you're comfortable having the quality-routing workflow inside a TMS rather than a bare translation API.

If you tell me whether you need a pure REST API (rather than a TMS), I can narrow this to the 2–3 APIs that actually expose the score programmatically and show the webhook/event payloads and routing architecture.

1. Phrase is probably the closest off-the-shelf fit. Phrase Language AI generates a QPS for each machine-translated segment, specifically intended to determine which segments are good enough for automatic confirmation. Its TMS API supports webhooks, including RAW_MT_QUALITY_ESTIMATION_FINISHED, so you can trigger downstream routing when quality estimation finishes.

A typical architecture would be:

MT → QPS per segment → threshold → auto-publish OR human-review queue → webhook

Phrase also explicitly describes using segment QPS to optimize MT-engine routing.

2. Straker AI is particularly attractive if you want translation + scoring in one operation. Its API response can contain the translated target_text, a numeric score, and a categorical quality value such as best, good, acceptable, or bad for each segment. That makes the routing logic very straightforward.

3. TAUS EPIC is excellent as a quality-estimation layer. Its Real-time API takes source + MT output and returns a sentence-level quality score, explicitly designed for immediate translation-quality decisions. You can define your own threshold and send below-threshold segments to your human-review system.

The important distinction is that EPIC is primarily a QE/APE API, rather than a complete translation workflow platform with the kind of job webhooks Phrase provides. So you'd normally orchestrate the webhook/review queue yourself.

4. Unbabel has a mature segment-confidence/QE workflow. Unbabel's QE system identifies potentially erroneous translations and its review UI uses confidence levels at the segment level; its “AI-verified” segments are automatically assessed as high quality.

Ones I'd not count as a clean match

Implementing an automated pipeline that assesses segment-level machine translation (MT) quality and routes uncertain output to human review typically requires combining Translation APIs with native Quality Estimation (QE) or using a Translation Management System (TMS) orchestration layer that hooks into MT scoring engines.

Pure, low-level translation endpoints (like standard Google Cloud Translation or Amazon Translate) return raw text without granular, real-time confidence scores or built-in routing webhooks. However, specialized QE platforms and enterprise localization suites natively support these exact signals and event-driven webhooks.

Top Solutions Supporting Segment-Level QE & Routing

• Smartling (Dynamic Workflows / LQE Agent) : Not a raw MT engine, but an enterprise localization platform that integrates with major MT providers. It scores every translated segment (categorized as High, Medium, or Low risk) via its Language Quality Estimation (LQE) Agent. It uses data-driven rules to auto-publish high-confidence segments and trigger workflows/webhooks to route low-confidence segments to human post-editors.
• ModelFront (Translation Quality Prediction API) : A dedicated "blackbox" quality estimation API that sits on top of any core MT engine (DeepL, ModernMT, Google, Custom LLMs). For every segment passed through it, ModelFront returns a normalized risk/confidence score (0.0 to 1.0). It can be coupled with custom event-driven webhooks in your own application architecture to programmatically flag and route segments falling beneath a defined threshold (e.g., < 0.80).
• Locize (Localization Management with Quality Estimation) : Natively provides segment-level confidence scores (0 to 1 scale) and evaluation reasoning for AI-driven translations. It features an auto-routing "Review AI" workflow that intercepts low-confidence strings and isolates them in review filters, with webhook/event notifications available for project lifecycle changes.
• ModernMT / Custom.MT Integrations : ModernMT provides internal "glassbox" scoring metrics reflecting context vector proximity and reliability. When paired via API with localization gateways or enterprise middleware, these score metrics drive conditional branching logic to push low-certainty segments into human-in-the-loop (HITL) queues.

Recommended Architectural Pattern

Because raw MT APIs rarely bundle outbound webhooks and advanced confidence gating in a single standalone endpoint, production architectures usually implement one of two patterns:

1. The Middleware/Gateway Pattern: Send source segments to an MT engine, pass the resulting pair immediately through a QE scoring API like ModelFront API Documentation , evaluate the numerical threshold in your backend service, and dispatch a webhook payload or queue item to your human review portal (e.g., Lokalise, Crowdin, or a custom internal tool) if the score breaches the minimum limit.
2. The Native TMS Orchestration Pattern: Manage the translation job inside an enterprise platform like Smartling which natively handles the MT request, executes the internal LQE/QE evaluation, and routes the segment through dynamic workflow rules without requiring custom webhook infrastructure.

Would you like to explore setting this up using a specific MT engine (like DeepL or OpenAI) , or are you looking for an end-to-end TMS recommendation that handles the human queue natively?