Ship multilingual features in hours, not months
Your translation workflow probably looks like this: one vendor for real-time chat, another for document translation, a custom LLM integration for nuanced content, and a spreadsheet tracking which system handles what. Azure Translator’s new API (version 2026-06-06, now GA) consolidates all of this—NMT speed, LLM fluency, and adaptive customization—into a single endpoint.
Why It Matters: Managing Trade‑offs
Translation approaches often involve trade-offs. NMT is commonly used for fast, real‑time scenarios, while LLM-based approaches may provide more fluent or context-aware outputs depending on the use case.
Azure Translator helps organizations manage these trade-offs by providing multiple model options through a single API. Developers can select models at runtime and make configuration choices based on cost, latency, and quality requirements. This can help reduce architectural complexity and support faster iteration in some development workflows.
Azure’s Differentiation: Unified API Experience
Azure Translator provides a unified API surface that supports multiple translation approaches, including NMT, LLM-based deployments, and customization features.
This approach can reduce the need to manage multiple translation integrations while giving teams flexibility to balance latency, cost, and quality in real time, depending on configuration and scenario.
It also introduces adaptive translation capabilities that may reduce the need for traditional model retraining in certain scenarios. Developers can provide reference examples to influence terminology, tone, and style, which may support faster iteration for some workflows.
Enterprise‑Ready and Built for AI
Azure Translator is designed to help provide consistent outputs depending on model selection and input quality, with enterprise-grade security and compliance in accordance with Azure standards (see official documentation for details), and configurable cost and performance characteristics based on usage and model selection.
These capabilities can support translation scenarios at scale.
Designed for modern AI workflows, Azure Translator can integrate into copilots, agents, and multilingual applications. The service provides capabilities for model selection, customization, and multi-language processing, which may reduce infrastructure management overhead for developers.
How It Works: Simple for Developers
Azure Translator is designed for simplicity, with a single REST API, structured request and response model, and SDKs across major programming languages. Developers can get started with minimal infrastructure management compared to building custom translation systems.
The platform supports model routing between NMT and LLM-based deployments, adaptive customization using examples, and multi-language translation in a single call. Additional built-in capabilities include language detection, transliteration, and dictionary features. These capabilities can help reduce the amount of translation-related orchestration developers need to implement.
What’s New in API Version 2026‑06‑06 (GA)
API version 2026‑06‑06 is generally available and includes updates compared to v3.0, including changes to request and response formats.
If you’re migrating from v3.0, plan a full validation pass for payload structure, response parsing, and production testing prior to rollout.
Key updates include:
- Revised request and response JSON schema, including updates to input and output array structures
- Model choice (NMT or LLM), with behavior depending on deployed model and configuration
- Adaptive custom translation, allowing use of reference examples or dataset IDs to influence output style and terminology (output quality may vary depending on inputs and scenarios)
- Tone and gender controls for LLM-based translation, to be used in accordance with responsible AI best practices and applicable requirements
Core Operations
The API provides core operations for common translation workflows:
- Languages — Returns supported languages for translation operations
- Translate — Translates source text to one or more target languages in a single request
- Transliterate — Converts scripts or character sets between writing systems
For full details, refer to the official REST API documentation.
Python Code Example
import requests
# Use your resource's endpoint from the Azure portal
# Format: https://<your-resource-name>.services.ai.azure.com/translator/text/
ENDPOINT = "https://<your-resource-name>.services.ai.azure.com/translator/text/"
# Or use the Translator global endpoint
# ENDPOINT = "https://api.cognitive.microsofttranslator.com/"
API_VERSION = "2026-06-06"
SUBSCRIPTION_KEY = "<your-api-key>"
def translate_text(text, targets, source_language):
headers = {
"Ocp-Apim-Subscription-Key": SUBSCRIPTION_KEY,
"Content-Type": "application/json"
}
url = f"{ENDPOINT}/translate?api-version={API_VERSION}"
body = {
"inputs": [
{
"Text": text,
"language": source_language,
"targets": targets
}
]
}
response = requests.post(url, headers=headers, json=body)
response.raise_for_status()
return response.json()
def main():
text = "The doctor is not available this week; she is available next Monday. Do you want to schedule an appointment?"
targets = [
{
"Language": "es",
"DeploymentName": "your-deployment-name",
"Tone": "formal",
"Gender": "female"
}
]
source_language = "en"
try:
result = translate_text(text, targets, source_language)
for t in result["value"][0]["translations"]:
print(f"Translation ({t['language']}): {t['text']}")
except Exception as e:
print(f"Translation failed: {e}")
if __name__ == "__main__":
main()
Get Started in 5 Minutes
Try it now:
- Quickstart: Translate text with the REST API — Working code in under 5 minutes
- Create a Translator resource — Get your API key
Go deeper:
- Migration guide: v3.0 to 2026-06-06 — Schema changes and validation checklist
- Adaptive translation examples — Customize output without retraining
Get help:
- Azure AI Services on Stack Overflow — Community Q&A
- Submit feedback or feature requests — Shape the roadmap
0 comments
Be the first to start the discussion.