.png)
Amazon Translate Integration Guide
Connect enterprise applications to Amazon Translate through AWS-authenticated HTTPS APIs for real-time text, document, and asynchronous batch translation.
Amazon Translate integration options at a glance
Amazon Translate provides an AWS service API over HTTPS for real-time text translation through TranslateText and real-time document translation through TranslateDocument. Its asynchronous batch model uses StartTextTranslationJob with Amazon S3 input and output locations, while DescribeTextTranslationJob supports status polling. Terminology and parallel-data operations support controlled translation vocabulary and aligned examples. Requests use AWS Signature Version 4, IAM permissions, roles, and optionally temporary credentials. Martini can orchestrate these calls, expose a normalized translation API, validate language and document inputs, coordinate S3-based workflows, poll jobs, map responses, and apply retry and audit rules.
| Integration point | Supported by Amazon Translate? | Common use cases | How Martini supports it |
|---|---|---|---|
| AWS HTTPS service API | Limited | Amazon Translate exposes JSON operations such as TranslateText, TranslateDocument, StartTextTranslationJob, and DescribeTextTranslationJob over HTTPS. It is an AWS service API rather than a conventional resource-oriented REST API. | Martini can consume HTTPS APIs in workflows and map request and response payloads. AWS Signature Version 4 signing, headers, credentials, and service-specific request construction must be configured correctly. |
| Real-time text translation | Yes | TranslateText translates text using source and target language codes and supported translation settings, including terminology where applicable. | Martini can validate the request, select language and terminology settings, invoke the operation, and expose or forward the normalized response. |
| Real-time document translation | Yes | TranslateDocument supports real-time document translation for supported document formats and request configurations. | Martini can receive document metadata or content, validate format and size requirements, invoke the API, and route the translated document response. |
| Bulk and asynchronous translation | Yes | StartTextTranslationJob starts asynchronous batch translation using Amazon S3 input and output locations. DescribeTextTranslationJob, and where applicable StopTextTranslationJob, manage job status. | Martini can start jobs, persist identifiers, poll status on a schedule, enforce timeouts, process outputs, and handle terminal failures. |
| File and Amazon S3 workflows | Yes | Batch translation uses Amazon S3 for source and translated document locations, with IAM permissions and a service role controlling access. | Martini can coordinate the S3-related workflow where the deployed environment provides the relevant S3 API or file-processing approach, including correlation and duplicate controls. |
| Terminology and parallel data | Yes | Terminology and ParallelData resources support controlled vocabulary and aligned examples for translation workflows. APIs include operations such as ImportTerminology, GetTerminology, CreateParallelData, and GetParallelData. | Martini can select resources by customer, product, region, or document type, validate availability, and include applicable settings in translation requests. |
| Webhooks and outbound callbacks | Not confirmed | The reviewed Amazon Translate documentation confirms polling through DescribeTextTranslationJob but does not confirm a general webhook or callback interface for translation events. | Martini can use scheduled polling for documented job status. Separately configured AWS eventing can be coordinated only when the required event coverage is verified. |
| AWS authentication and IAM | Yes | Requests use AWS Signature Version 4 with IAM users or roles, temporary credentials, operation-specific permissions, and service roles for S3-backed jobs. | Martini can keep credentials in secure environment configuration and apply authenticated API calls, while workflows enforce least-privilege and failure handling. |
How Amazon Translate exposes data and business events
Amazon Translate HTTPS APIs
Amazon Translate provides an AWS service API over HTTPS with JSON operations for real-time text, real-time documents, asynchronous jobs, language information, terminology, and parallel data. The API uses AWS Signature Version 4 rather than a conventional unauthenticated REST pattern.
Martini implementation pattern
Martini implementation pattern: A Martini workflow or exposed API validates the incoming request, constructs and signs the AWS service request, invokes the selected operation, maps the response into a canonical model, and routes service or authorization errors according to business rules.
Implementation sequence
Real-time translation
TranslateText supports real-time text translation, while TranslateDocument supports real-time document translation for supported formats and configurations. These operations return the translation result directly to the caller.
Martini implementation pattern
Martini implementation pattern: Martini exposes a controlled translation endpoint or consumes a request from an application, validates payload and language rules, invokes the appropriate operation, and returns a normalized response without requiring asynchronous job polling.
Implementation sequence
Asynchronous batch jobs
StartTextTranslationJob supports batch translation using Amazon S3 input and output locations. DescribeTextTranslationJob provides job status and metadata, and StopTextTranslationJob can stop a running job where applicable.
Martini implementation pattern
Martini implementation pattern: Martini starts the job after validating S3 locations and permissions, persists the Amazon Translate job identifier, and uses a scheduled workflow to poll status until completion, failure, stopping, or timeout. Completed output is processed with duplicate protection.
Implementation sequence
Terminology and parallel data
Amazon Translate provides resources for custom terminology and parallel data, with API operations for importing, creating, retrieving, and applying these resources where supported by the translation operation.
Martini implementation pattern
Martini implementation pattern: Martini determines the applicable resource from customer, product, region, or content metadata, confirms that the resource exists, adds the supported setting to the request, and records the selected resource for audit and repeatability.
Implementation sequence
Common Amazon Translate integration patterns
Pattern 1: Translate customer support messages
When to use this pattern
Use this pattern when support messages or agent responses must be translated in real time for multilingual service operations. Short messages are suitable for TranslateText, with Martini applying validation, language rules, and error routing before returning the result.
Integration direction
Example Mapping
| Amazon Translate Field | Canonical Field | Target Field |
|---|---|---|
| messageText | sourceText | Text |
| sourceLanguageCode | sourceLanguage | SourceLanguageCode |
| targetLanguageCode | targetLanguage | TargetLanguageCode |
| translatedText | translatedContent | translatedMessage |
Martini implementation pattern
Martini receives the support payload, validates the language pair and text size, optionally selects terminology, signs and invokes TranslateText, then maps the TextTranslation result back to the case or message workflow. Authentication failures and invalid requests are rejected, while transient service failures can follow controlled retry rules.
Martini capabilities used
- workflows
- API consumption
- API exposure
- data mapping
- business rules
- error handling
Pattern 2: Process batch document translation
When to use this pattern
Use this pattern for product documentation, policy documents, knowledge articles, or customer communications that are stored in Amazon S3 and translated asynchronously. It separates job submission from output processing and supports long-running workloads.
Integration direction
Example Mapping
| Amazon Translate Field | Canonical Field | Target Field |
|---|---|---|
| inputS3Uri | sourceDocumentLocation | InputDataConfig |
| outputS3Uri | translatedDocumentLocation | OutputDataConfig |
| jobName | translationCorrelationKey | JobName |
| jobStatus | processingState | JobStatus |
Martini implementation pattern
Martini validates S3 locations and permissions, starts StartTextTranslationJob, stores the returned job identifier and source checksum, then schedules DescribeTextTranslationJob polling. On completion it processes output files once; throttling and transient failures use backoff, while authorization and malformed configuration errors follow a terminal route.
Martini capabilities used
- workflows
- API consumption
- scheduling
- data mapping
- business rules
- error handling
- monitoring
Pattern 3: Govern product content with terminology
When to use this pattern
Use this pattern when product names, legal terms, SKU terminology, or approved translations must remain consistent across localized content. Martini selects the applicable Terminology or ParallelData resource using business metadata before translation.
Integration direction
Example Mapping
| Amazon Translate Field | Canonical Field | Target Field |
|---|---|---|
| productDescription | sourceContent | Text |
| businessUnit | terminologyContext | TerminologyNames |
| sourceLocale | sourceLanguage | SourceLanguageCode |
| localizedDescription | translatedContent | TranslatedText |
Martini implementation pattern
Martini reads content classification, resolves the approved resource, verifies that it is available, and invokes the supported translation operation with the selected settings. It records the resource name and source version so downstream consumers can distinguish revised content and retry safely.
Martini capabilities used
- workflows
- data mapping
- business rules
- API consumption
- error handling
- audit logging
Pattern 4: Expose a shared translation API
When to use this pattern
Use this pattern when multiple internal applications need a consistent translation contract without each application implementing AWS signing, IAM configuration, language validation, and response handling independently.
Integration direction
Example Mapping
| Amazon Translate Field | Canonical Field | Target Field |
|---|---|---|
| text | sourceText | Text |
| sourceLanguage | sourceLanguageCode | SourceLanguageCode |
| targetLanguage | targetLanguageCode | TargetLanguageCode |
| result | translatedText | TranslatedText |
Martini implementation pattern
Martini exposes a REST API with a canonical request and response model. A workflow applies payload-size and language-pair rules, selects terminology when required, signs the Amazon Translate request, normalizes errors, and returns a stable contract that can evolve independently from the AWS payload.
Martini capabilities used
- API exposure
- workflows
- API consumption
- data mapping
- business rules
- error handling
- security
Applications commonly integrated with Amazon Translate
Amazon Translate can be coordinated with AWS services and enterprise applications when translation is part of a broader content, support, or document workflow. Martini provides a centralized orchestration layer for authentication, validation, mapping, terminology selection, job tracking, and downstream delivery. The integrations below are architectural patterns rather than claims of dedicated Amazon Translate connectors.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Amazon S3 | Store source documents and translated output for Amazon Translate asynchronous jobs. | Amazon S3 → Martini → Amazon Translate → Amazon S3 | Martini validates object locations, starts the batch job, stores the job identifier and source correlation key, polls job status, and processes completed output files idempotently. |
| AWS Lambda | Invoke translation logic or coordinate lightweight AWS processing around translation requests. | AWS Lambda → Martini → Amazon Translate | Martini can receive or call the relevant HTTPS interfaces, normalize requests, apply language and payload rules, invoke Amazon Translate, and return structured results to the surrounding AWS workflow. |
| AWS Step Functions | Coordinate long-running translation jobs and status checks in AWS-based workflows. | AWS Step Functions → Martini → Amazon Translate | Martini can integrate at the orchestration boundary, centralizing request validation, AWS signing, job correlation, polling, timeout handling, and downstream delivery. |
| Amazon EventBridge | Route selected AWS application or workflow events into translation-related processing where the event design is separately configured. | Amazon EventBridge → Martini → Amazon Translate | Martini receives or coordinates the confirmed event flow, validates the event payload, invokes the appropriate Translate operation, and routes failures without assuming general Amazon Translate completion events. |
| Salesforce | Translate customer-facing case, message, or knowledge content for global service operations. | Salesforce → Martini → Amazon Translate → Salesforce | A Martini workflow receives selected Salesforce content, validates language and text size, invokes TranslateText, maps the translated response, and updates the originating or related Salesforce object with correlation and error handling. |
| ServiceNow | Translate incident descriptions, knowledge articles, catalog content, or user-submitted requests. | ServiceNow → Martini → Amazon Translate → ServiceNow | Martini consumes the approved ServiceNow payload, applies business rules and terminology selection, invokes Amazon Translate, and writes the result back while preventing duplicate updates. |
| Amazon Comprehend | Combine translation with language analysis such as classification, entity extraction, or sentiment processing. | Amazon Translate → Martini → Amazon Comprehend | Martini sequences translation and analysis APIs, maps the translated TextTranslation output into the analysis request, preserves correlation metadata, and routes service-specific failures separately. |
How to build a Amazon Translate integration in Martini
Objective
Establish the AWS API connection and protect credentials, signing material, and environment-specific configuration.
Instructions in Martini
- Configure the Amazon Translate HTTPS endpoint and AWS region.
- Use IAM roles or temporary credentials where available.
- Keep access keys, session tokens, and signing configuration in Martini secrets or secure environment configuration.
- Grant only the Translate, S3, terminology, and service-role permissions required by the workflow.
Objective
Select a real-time API request or scheduled workflow based on the translation use case and Amazon Translate operation.
Instructions in Martini
- Use an exposed Martini API or application request for TranslateText and TranslateDocument.
- Use a scheduler for asynchronous DescribeTextTranslationJob polling.
- Do not assume a general Amazon Translate completion webhook is available.
- Define correlation keys for requests and batch jobs.
Objective
Collect text, documents, language settings, or S3 job metadata and validate that the source data is available.
Instructions in Martini
- Validate source and target language codes.
- Check text size, document format, content type, and S3 object availability.
- For batch jobs, persist input and output locations and the source version or checksum.
- Retrieve job status and metadata using DescribeTextTranslationJob.
Objective
Coordinate request signing, translation calls, terminology selection, asynchronous polling, and downstream processing in a maintainable workflow.
Instructions in Martini
- Build the AWS request with the required service-specific payload and signed headers.
- Select Terminology or ParallelData based on business context where supported.
- Store job identifiers and correlation data before polling.
- Separate authentication, validation, translation, and output-processing failures.
Objective
Convert application payloads into Amazon Translate request formats and map translation results into canonical or target-system models.
Instructions in Martini
- Map source text or document metadata to the selected Translate operation.
- Normalize language codes and translation direction.
- Map TextTranslation or translated document results to the consuming application.
- Preserve correlation IDs, source versions, and resource metadata.
Objective
Enforce translation policies before service invocation and prevent invalid, duplicate, or non-compliant processing.
Instructions in Martini
- Apply allowed language-pair and content-size rules.
- Select approved terminology by customer, product, region, or document type.
- Reject malformed requests without repeated retries.
- Prevent a second active batch job for the same source version.
Common Amazon Translate data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| TextTranslation | Translated text returned by TranslateText for real-time application messages and content. | Salesforce, ServiceNow, internal applications, Amazon Comprehend | Martini validates the request, invokes TranslateText, maps the translated content and language metadata, and applies correlation and error rules. |
| TranslationDocument | Document submitted to TranslateDocument for real-time document translation. | Document applications, content repositories, Amazon S3 | Martini validates document format, content type, language codes, and size before invoking the operation and routing the translated document. |
| TextTranslationJob | Asynchronous batch translation job referencing S3 input and output locations. | Amazon S3, document applications, content repositories | Martini stores the job identifier and source correlation data, polls DescribeTextTranslationJob, handles timeout and terminal states, and processes output idempotently. |
| Terminology | Custom terminology resource for preserving approved product, legal, SKU, or domain-specific terms. | Product-content systems, knowledge repositories, commerce applications | Martini selects and validates the applicable terminology resource before adding supported terminology settings to translation requests. |
| ParallelData | Aligned source and target examples used to improve or customize translation output. | Content platforms, translation operations, Amazon Translate workflows | Martini can coordinate resource creation or retrieval, associate the resource with the relevant workflow, and record configuration metadata. |
| LanguageCode / LanguagePair | Source and target language identifiers used by translation operations and language validation. | Internal translation APIs, support systems, content platforms | Martini normalizes language codes, validates supported directions where configured, and applies fallback or rejection rules. |
Authentication and security considerations
AWS authentication and authorization
Amazon Translate requests use AWS Signature Version 4 and operation-specific IAM permissions. IAM roles, temporary credentials, and service roles can reduce reliance on long-lived access keys.
- Store credentials, session tokens, regions, and signing configuration in secure Martini environment configuration.
- Apply least-privilege permissions for Translate operations, terminology resources, S3 locations, and batch-job service roles.
- Use HTTPS and protect source and translated content according to its classification.
- Control S3 encryption, bucket policies, retention, and access separately from translation workflow logic.
Operational considerations for Amazon Translate integrations
Reliability and control points
Real-time and asynchronous operations have different payload, document, and processing constraints. Validate language codes, content types, document formats, S3 access, and size limits before calling Amazon Translate.
- Use exponential backoff for throttling and transient service failures.
- Persist job identifiers, source versions, checksums, and correlation keys for polling and recovery.
- Set polling intervals, maximum durations, and terminal handling for completed, failed, stopped, or timed-out jobs.
- Process output files idempotently and follow continuation tokens for paginated resource operations.
- Keep AWS request construction separate from business mappings and tolerate unknown response fields.
- Redact sensitive text from logs and test changes to job, terminology, and translation response handling.
Why use Martini instead of scripts or point-to-point integrations?
Centralized integration logic
Scripts can call Amazon Translate, but they often duplicate AWS signing, IAM configuration, validation, polling, retries, mapping, and audit logic across applications. Point-to-point integrations can create the same fragmentation when multiple systems need translation.
- Expose one controlled translation API for multiple internal applications.
- Orchestrate real-time calls and long-running S3-backed jobs in reusable workflows.
- Apply consistent language, terminology, payload, retry, and idempotency rules.
- Keep credentials and environment settings separate from integration mappings.
- Monitor failures and preserve correlation data without embedding translation logic in every application.
Frequently asked questions
Amazon Translate can be integrated through its AWS HTTPS service API. Enterprise workflows can use TranslateText and TranslateDocument for real-time translation, or StartTextTranslationJob with Amazon S3 input and output for asynchronous batch translation. AWS Signature Version 4, IAM permissions, roles, and temporary credentials control access.
Yes. Martini can integrate with Amazon Translate by consuming its AWS API over HTTPS, signing requests with the required AWS authentication method, orchestrating real-time or asynchronous workflows, coordinating Amazon S3 processing, and mapping results to enterprise applications. No native Martini Amazon Translate connector is documented in the supplied sources.
No. A dedicated Amazon Translate connector is not required. Martini can use Amazon Translate’s documented HTTPS API and AWS authentication mechanisms, with Amazon S3 involved for asynchronous document workflows and custom JVM-compatible logic available when advanced signing behavior is required.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Amazon Translate. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from AWS, Amazon Translate, Amazon S3, cloud infrastructure, or other third-party systems based on usage, subscription, and deployment model.
Use TranslateText for short real-time text, TranslateDocument for supported real-time document requests, and StartTextTranslationJob for S3-backed asynchronous batch translation. DescribeTextTranslationJob supports status polling. Amazon Translate GraphQL and SOAP APIs were not confirmed in the reviewed documentation.
A general Amazon Translate webhook or outbound callback interface was not confirmed. The documented asynchronous pattern uses DescribeTextTranslationJob for status retrieval. Martini can schedule polling, or coordinate separately configured AWS eventing only where the relevant event coverage is verified.
Martini can normalize source and target language codes, map application content to Amazon Translate request fields, select terminology resources, and map TextTranslation or document results back to target systems. For batch jobs, it stores the job identifier, source version, and correlation key, then processes output files idempotently.
Martini can classify failures before retrying: invalid payloads and IAM configuration issues should follow a corrective or terminal path, while throttling and transient service failures can use controlled exponential backoff. Batch workflows should persist job identifiers, use timeouts, and process outputs only once using stable business keys or source checksums.
Related Martini documentation
Operations
Integrate Amazon Translate with Martini
Use Martini to connect Amazon Translate with enterprise applications, coordinate real-time and batch translation workflows, and centralize AWS authentication, mapping, retries, and monitoring.