Browse Translation API Documentation
Complete Your First Translation Workflow
In this guide, you will submit a short English text for translation, monitor the request as it moves through the Stepes workflow, and retrieve the completed target-language result.
Configure Your Environment
Store the base URL and credentials securely for the API environment assigned to your integration.
Authenticate Your Application
Confirm that the credential is valid and authorized for the intended account or workspace.
Create a Translation Project
Submit source content, locale information, target languages, and the required translation workflow.
Monitor Translation Progress
Track the project and its language jobs until they reach a result-bearing or terminal state.
Retrieve the Completed Result
Return translated content to the correct application record, content item, file, or release.
A Stepes translation request is designed as an asynchronous workflow. Instead of keeping a connection open while translation is completed, the API accepts the request, creates the necessary language jobs, and returns a project identifier that your application can use to monitor progress.
This model supports rapid automated translation as well as workflows that may include terminology controls, translation memory, professional review, quality assurance, and customer approval.
Prerequisites
Before You Begin
Prepare your account, credentials, tools, and sample content before sending the first request.
An approved Stepes API account
A valid API credential
Access to the assigned testing or production environment
cURL, Postman, or a server-side programming environment
A short source-text sample
A source locale and at least one target locale
Permission to submit the selected content
A secure place to store credentials
Use separate credentials for testing and production whenever separate environments are provided. Restrict each credential to the applications, workspaces, and permissions it requires.
Review Authentication and Credential SecurityCore Concepts
Understand the Translation Resource Model
A Stepes API request is organized around a translation project. The project connects source content, target languages, workflow requirements, processing states, and completed deliveries.
Organization
The enterprise account and its administrative, security, and governance context.
Workspace
A controlled environment for a team, application, business unit, product, or localization program.
Translation Project
The top-level request connecting source content, locales, workflow requirements, and delivery settings.
Content
The text, structured content, localization resource, or document submitted for translation.
Language Jobs
The target-specific processing activities created for the locales included in the project.
Review Activities
Optional human translation, post-editing, linguistic review, quality assurance, or approval steps.
Deliveries
The completed translated text, structured response, localization package, or downloadable file.
This guide uses one project with one inline text item and one target locale. The same model can support multiple content items, target languages, file assets, and review stages.
Learn More About Translation API ResourcesConfigure Your API Environment
Store the API base URL and credential as environment variables so your application can switch between testing and production without changing integration code.
export STEPES_BASE_URL="YOUR_STEPES_API_BASE_URL"
export STEPES_API_KEY="YOUR_STEPES_API_KEY"
$env:STEPES_BASE_URL = "YOUR_STEPES_API_BASE_URL"
$env:STEPES_API_KEY = "YOUR_STEPES_API_KEY"
Standard Request Headers
Authorization: Bearer YOUR_STEPES_API_KEY
Content-Type: application/json
Accept: application/json
The authorization header authenticates your application. Content-Type identifies the request body, and Accept identifies the preferred response format. Additional headers may be required for API version selection, workspace context, idempotency, or request tracing.
Review Environments and Base URLsAuthenticate with the API
Send a lightweight authenticated request before submitting content. This confirms that the credential, environment, account context, and API version are working together.
GET /v2/account
curl --request GET \
--url "$STEPES_BASE_URL/v2/account" \
--header "Authorization: Bearer $STEPES_API_KEY" \
--header "Accept: application/json"
const response = await fetch(
`${process.env.STEPES_BASE_URL}/v2/account`,
{
headers: {
Authorization: `Bearer ${process.env.STEPES_API_KEY}`,
Accept: "application/json"
}
}
);
const account = await response.json();
import os
import requests
response = requests.get(
f"{os.environ['STEPES_BASE_URL']}/v2/account",
headers={
"Authorization": f"Bearer {os.environ['STEPES_API_KEY']}",
"Accept": "application/json",
},
)
account = response.json()
{
"id": "org_example",
"environment": "sandbox",
"status": "active",
"apiVersion": "2.1"
}
Unauthorized
The API could not validate the credential. Confirm the value, header format, environment, expiration, and revocation status.
Forbidden
The credential is valid but lacks permission for the requested workspace, resource, workflow, or environment.
Create a Translation Project
Submit a short English support message for translation into German. The project defines the source locale, target locale, content, workflow, and application context.
POST /v2/translation-projects
curl --request POST \
--url "$STEPES_BASE_URL/v2/translation-projects" \
--header "Authorization: Bearer $STEPES_API_KEY" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "Idempotency-Key: first-translation-example-001" \
--data '{
"clientReference": "getting-started-example",
"sourceLocale": "en-US",
"targetLocales": ["de-DE"],
"content": {
"type": "text",
"items": [{
"id": "support-message",
"text": "Your order has shipped and is expected to arrive within three business days."
}]
},
"workflow": { "mode": "ai_translation" },
"metadata": { "application": "developer-quickstart" }
}'
const response = await fetch(
`${process.env.STEPES_BASE_URL}/v2/translation-projects`,
{
method: "POST",
headers: {
Authorization: `Bearer ${process.env.STEPES_API_KEY}`,
"Content-Type": "application/json",
Accept: "application/json",
"Idempotency-Key": "first-translation-example-001"
},
body: JSON.stringify({
clientReference: "getting-started-example",
sourceLocale: "en-US",
targetLocales: ["de-DE"],
content: {
type: "text",
items: [{
id: "support-message",
text: "Your order has shipped and is expected to arrive within three business days."
}]
},
workflow: { mode: "ai_translation" }
})
}
);
import os
import requests
response = requests.post(
f"{os.environ['STEPES_BASE_URL']}/v2/translation-projects",
headers={
"Authorization": f"Bearer {os.environ['STEPES_API_KEY']}",
"Content-Type": "application/json",
"Accept": "application/json",
"Idempotency-Key": "first-translation-example-001",
},
json={
"clientReference": "getting-started-example",
"sourceLocale": "en-US",
"targetLocales": ["de-DE"],
"content": {
"type": "text",
"items": [{
"id": "support-message",
"text": "Your order has shipped and is expected to arrive within three business days."
}]
},
"workflow": {"mode": "ai_translation"},
},
)
{
"id": "trp_01JEXAMPLE",
"clientReference": "getting-started-example",
"status": "accepted",
"sourceLocale": "en-US",
"targetLocales": ["de-DE"],
"createdAt": "2026-07-20T15:30:00Z",
"jobs": [{
"id": "trj_01JEXAMPLE_DE",
"targetLocale": "de-DE",
"status": "queued"
}],
"links": {
"self": "/v2/translation-projects/trp_01JEXAMPLE",
"results": "/v2/translation-projects/trp_01JEXAMPLE/results"
}
}
Understand the Request Fields
clientReference
An identifier from your application or content system used to reconcile the project with a source record, release, order, or repository item.
sourceLocale
The known locale of the source content. Explicit locale information provides more predictable workflow behavior.
targetLocales
One or more requested target locales. The API may create a language job for every target locale.
content
The source text, structured data, localization resource, or document submitted for translation.
workflow
The translation, review, quality, and approval path requested for the project.
metadata
Optional application context used for routing or reconciliation. Do not include secrets or unnecessary sensitive data.
Prevent Duplicate Requests
When the endpoint supports idempotency, reuse the same idempotency key only when retrying the same business operation with the same request data. A genuinely new translation request should receive a new key.
Idempotency-Key: first-translation-example-001Monitor Translation Progress
Save the project identifier and retrieve the latest project state until processing reaches a result-bearing or terminal status.
GET /v2/translation-projects/{projectId}
PROJECT_ID="trp_01JEXAMPLE"
curl --request GET \
--url "$STEPES_BASE_URL/v2/translation-projects/$PROJECT_ID" \
--header "Authorization: Bearer $STEPES_API_KEY" \
--header "Accept: application/json"
const terminalStates = new Set([
"completed",
"partially_completed",
"failed",
"canceled"
]);
async function waitForProject(projectId) {
let delay = 3000;
while (true) {
const response = await fetch(
`${process.env.STEPES_BASE_URL}/v2/translation-projects/${projectId}`,
{
headers: {
Authorization: `Bearer ${process.env.STEPES_API_KEY}`,
Accept: "application/json"
}
}
);
if (!response.ok) {
throw new Error(`Status request failed with ${response.status}`);
}
const project = await response.json();
if (terminalStates.has(project.status)) return project;
const retryAfter = Number(response.headers.get("retry-after"));
const waitTime = Number.isFinite(retryAfter)
? retryAfter * 1000
: delay;
await new Promise(resolve => setTimeout(resolve, waitTime));
delay = Math.min(delay * 2, 30000);
}
}
import os
import time
import requests
TERMINAL_STATES = {
"completed",
"partially_completed",
"failed",
"canceled",
}
def wait_for_project(project_id):
delay = 3
while True:
response = requests.get(
f"{os.environ['STEPES_BASE_URL']}/v2/translation-projects/{project_id}",
headers={
"Authorization": f"Bearer {os.environ['STEPES_API_KEY']}",
"Accept": "application/json",
},
)
response.raise_for_status()
project = response.json()
if project["status"] in TERMINAL_STATES:
return project
retry_after = response.headers.get("Retry-After")
time.sleep(int(retry_after) if retry_after else delay)
delay = min(delay * 2, 30)
{
"id": "trp_01JEXAMPLE",
"status": "processing",
"sourceLocale": "en-US",
"targetLocales": ["de-DE"],
"jobs": [{
"id": "trj_01JEXAMPLE_DE",
"targetLocale": "de-DE",
"status": "processing",
"progress": 65
}],
"updatedAt": "2026-07-20T15:30:18Z"
}
Common Project States
| Status | Meaning | Application Behavior |
|---|---|---|
| Accepted | The request passed initial validation and the project was created. | Save the project identifier and begin monitoring. |
| Queued | The project or language job is waiting to begin processing. | Continue monitoring at the recommended interval. |
| Processing | Translation or automated processing is in progress. | Continue monitoring or wait for a webhook event. |
| In Review | Human review, quality assurance, or approval is in progress. | Do not treat the project as complete. |
| Completed | All required target-language work completed successfully. | Retrieve and validate the available results. |
| Partially Completed | Some target-language jobs completed while others did not. | Retrieve available results and inspect incomplete jobs. |
| Failed | The project or job could not be completed. | Review the error details before correcting or retrying. |
| Canceled | Processing ended before completion. | Stop polling unless the project can be resumed. |
Poll Responsibly
- Respect the documented polling interval.
- Honor the Retry-After response header when provided.
- Stop polling after a terminal state is reached.
- Apply exponential backoff after temporary failures.
- Set a maximum monitoring duration.
- Log project and request identifiers.
- Handle partial completion and language-specific failures.
Retrieve the Translation Result
When the project reaches completed or another result-bearing state, request the translated output and associate each result with the correct source item and locale.
GET /v2/translation-projects/{projectId}/results
curl --request GET \
--url "$STEPES_BASE_URL/v2/translation-projects/$PROJECT_ID/results" \
--header "Authorization: Bearer $STEPES_API_KEY" \
--header "Accept: application/json"
const response = await fetch(
`${process.env.STEPES_BASE_URL}/v2/translation-projects/${projectId}/results`,
{
headers: {
Authorization: `Bearer ${process.env.STEPES_API_KEY}`,
Accept: "application/json"
}
}
);
const results = await response.json();
import os
import requests
response = requests.get(
f"{os.environ['STEPES_BASE_URL']}/v2/translation-projects/{project_id}/results",
headers={
"Authorization": f"Bearer {os.environ['STEPES_API_KEY']}",
"Accept": "application/json",
},
)
results = response.json()
{
"projectId": "trp_01JEXAMPLE",
"status": "completed",
"sourceLocale": "en-US",
"completedAt": "2026-07-20T15:30:24Z",
"results": [{
"jobId": "trj_01JEXAMPLE_DE",
"targetLocale": "de-DE",
"status": "completed",
"content": {
"type": "text",
"items": [{
"id": "support-message",
"translation": "Ihre Bestellung wurde versandt und wird voraussichtlich innerhalb von drei Werktagen eintreffen."
}]
}
}]
}
Verify the Result Before Publishing
Your First Translation Workflow Is Complete
You authenticated with the API, created a project, submitted content, monitored asynchronous processing, and retrieved the completed translation.
Translate a Document or Localization File
Inline text is the fastest way to test an integration. For document translation, software localization, and content-production workflows, submit a file through the supported upload process.
Typical File Workflow
- 1
Create the translation project.
- 2
Upload or register the source file.
- 3
Confirm file validation.
- 4
Start or continue the configured workflow.
- 5
Monitor the project and language jobs.
- 6
Retrieve the translated file or delivery package.
{
"clientReference": "product-guide-release-2026-07",
"sourceLocale": "en-US",
"targetLocales": ["de-DE", "fr-FR", "ja-JP"],
"content": {
"type": "file",
"fileId": "fil_01JEXAMPLE",
"fileName": "product-guide.docx"
},
"workflow": {
"mode": "ai_translation_with_human_review"
}
}
File Validation
The API may validate file format, size, integrity, password protection, embedded content, extractable text, resource structure, source-language compatibility, and account limits before translation begins.
File Delivery
Completed files may be returned through a secured result resource or time-limited download URL. Treat delivery URLs as sensitive, download files before expiration, verify project and locale information, confirm file integrity when checksums are provided, and store translated files according to your security and retention policies.
Event-Driven Processing
Replace Polling with Webhook Notifications
For production workflows, webhooks allow Stepes to notify your application when meaningful project, review, failure, and delivery events occur.
- 1
Register a secure HTTPS endpoint.
- 2
Subscribe to the events your application needs.
- 3
Receive the event payload.
- 4
Verify the webhook signature.
- 5
Return a successful response promptly.
- 6
Process the event asynchronously.
- 7
Retrieve or reconcile the associated API resource.
- 8
Handle duplicate and out-of-order events safely.
{
"id": "evt_01JEXAMPLE",
"type": "translation_project.completed",
"createdAt": "2026-07-20T15:30:24Z",
"data": {
"projectId": "trp_01JEXAMPLE",
"status": "completed",
"targetLocales": ["de-DE"],
"resultsAvailable": true
}
}
Translation Quality
Choose the Right Translation Workflow
The Stepes Translation API is designed for more than one translation method. Connect each content type to the workflow that matches its quality, speed, risk, and publishing requirements.
AI Translation
Use controlled automated translation for eligible content that requires rapid, scalable multilingual processing.
AI Translation with Human Review
Combine automated translation with professional linguistic review to improve accuracy, fluency, terminology, tone, and completeness.
Professional Human Translation
Route specialized, regulated, high-risk, or publication-critical content to qualified professional linguists.
Post-Editing and Linguistic Review
Improve machine- or AI-generated output through professional review aligned with the intended audience and use.
Quality Assurance and Approval
Add structured checks and stakeholder approval before translated content is released to downstream systems.
Apply Translation Memory and Terminology
Translation Memory
Reuse previously approved source and target-language segments to improve consistency, accelerate updates, and reduce repeated translation work.
Explore Translation MemoryTerminology Management
Control product names, technical terms, regulated language, brand expressions, and other important concepts across languages and workflows.
Explore Terminology ManagementTranslation projects may also include style guides, reference materials, subject-matter requirements, audience information, and customer-specific instructions. Provide only what the workflow needs and ensure that supporting materials comply with your data-handling policies.
Troubleshooting
Understand Common API Errors
The API returns structured error information so your application can determine what happened, whether the request must be corrected, and whether a retry is appropriate.
{
"error": {
"code": "invalid_target_locale",
"message": "The target locale is not supported for this request.",
"field": "targetLocales[0]",
"requestId": "req_01JEXAMPLE",
"documentationUrl": "https://www.stepes.com/developers/translation-api/errors-and-operations/"
}
}
Use the stable error code for programmatic handling. Use the message and field information for troubleshooting, and preserve the request identifier when contacting Stepes Developer Support.
| HTTP | Category | Typical Cause | Recommended Action |
|---|---|---|---|
| 400 | Invalid request | Malformed JSON, missing fields, invalid values, or a schema mismatch. | Correct the request before retrying. |
| 401 | Authentication failure | The credential is missing, invalid, expired, revoked, or presented incorrectly. | Correct the credential or header. |
| 403 | Insufficient permission | The credential cannot access the requested workspace, resource, environment, or workflow. | Use an authorized credential or update access. |
| 404 | Resource not found | The requested project, job, file, delivery, or workspace is unavailable to the credential. | Confirm the identifier and account context. |
| 409 | Conflicting request | The request conflicts with an existing resource or previously used idempotency key. | Retrieve the existing operation or use a new key for a new request. |
| 413 / 422 | Content or validation error | The file, locale, content type, or request data does not meet endpoint requirements. | Correct the source content or configuration. |
| 429 | Rate or usage limit | The application exceeded a documented request, concurrency, or account limit. | Honor retry guidance and reduce request pressure. |
| 5xx | Temporary service error | A temporary platform or infrastructure condition prevented completion. | Retry only with documented backoff behavior. |
Correct Before Retrying
- Invalid credentials
- Insufficient permissions
- Invalid parameters
- Unsupported locales or files
- Validation failures
- Missing required fields
Retry with Backoff When Appropriate
- Rate-limit responses
- Temporary server errors
- Network interruption
- Temporary delivery unavailability
- Documented retryable workflow conditions
Move from Testing to Production
A successful sample request confirms that the basic connection works. Before connecting production systems and content, review the integration for security, reliability, observability, and lifecycle management.
Credentials and Access
- Store secrets in an approved secrets manager.
- Separate test and production credentials.
- Restrict credentials to required permissions.
- Define credential ownership, rotation, and revocation procedures.
- Remove unused credentials promptly.
Request Reliability
- Use idempotency protection where supported.
- Apply safe retries and respect Retry-After guidance.
- Preserve project and request identifiers.
- Handle partial completion and uncertain network outcomes.
- Validate source versions before publishing returned content.
Webhook Reliability
- Verify every webhook signature.
- Respond promptly and process events asynchronously.
- Store processed event identifiers.
- Handle duplicate and out-of-order events.
- Retrieve current API state before critical actions.
Logging and Observability
- Log request, project, job, and event identifiers.
- Track response codes, error codes, latency, and final state.
- Monitor failed workflows and webhook deliveries.
- Avoid logging credentials, secrets, or unnecessary source content.
- Preserve enough context for effective technical support.
Content Security
- Confirm the selected workflow meets data-handling requirements.
- Use non-sensitive sample content during testing.
- Limit content access to authorized workspaces and users.
- Review retention, deletion, regional, and downstream storage requirements.
- Protect secured delivery URLs and downloaded files.
Version and Change Management
- Use the documented API version.
- Monitor the developer changelog and deprecation notices.
- Test changes before production deployment.
- Maintain clear integration ownership and dependency records.
- Subscribe to platform-status notifications.
Developer Documentation
Continue Building
Use the following documentation to expand the integration from a successful quickstart into a production translation workflow.
API Reference
Endpoint methods, parameters, schemas, responses, errors, and version-specific behavior.
Authentication
Credential issuance, secure storage, permissions, rotation, and revocation.
Core Concepts
Organizations, workspaces, projects, content, jobs, reviews, events, and deliveries.
Files and Content
Text, structured data, localization resources, documents, validation, and limits.
Languages and Locales
Supported languages, locale identifiers, source handling, and target-language selection.
Translation Workflows
AI translation, professional translation, review, quality assurance, and delivery configuration.
Status and Webhooks
Project states, status retrieval, event delivery, and signature verification.
Errors and Operations
Structured errors, retries, idempotency, rate limits, monitoring, and production reliability.
Developer Support
Architecture, security, testing, deployment, and troubleshooting assistance.
Translation API Getting Started Questions
Review common onboarding questions about access, testing, asynchronous processing, language selection, human review, and integration support.
Contact Stepes with information about your application, content types, expected translation volume, source and target languages, required workflows, and implementation timeline. The Stepes team can help determine the appropriate account configuration, API environment, security requirements, and onboarding path.
Request API AccessTesting options depend on the API account and integration requirements. Your onboarding information identifies available environments, testing credentials, sample-content expectations, processing limits, and how testing differs from production. Do not submit confidential or regulated content until your organization has approved the environment and workflow.
Use a short inline text request for the fastest initial test. It validates authentication, request formatting, status monitoring, and result retrieval with minimal setup. After that workflow succeeds, test a representative file if your production integration will translate documents, software resources, or structured content.
Specify the source locale whenever it is known. Explicit locale information provides more predictable workflow behavior and distinguishes regional variants such as en-US and en-GB. Automatic identification may be available for supported use cases, but it should not replace known metadata in controlled production workflows.
Translation projects are processed asynchronously. A 202 Accepted response confirms that the request passed initial validation and entered the translation workflow. Your application can then monitor the project or receive a webhook notification when results become available.
Polling is convenient during development and initial testing. Signed webhook notifications are usually more efficient for ongoing production integrations. Many implementations use webhooks for primary event processing and status requests for reconciliation, recovery, and troubleshooting.
Yes. A translation project can include multiple target locales. The API may create a separate language job for each target locale while preserving a single parent project for tracking, workflow management, and delivery.
Yes. Depending on account configuration and project requirements, a workflow may combine AI translation, professional human translation, machine translation post-editing, linguistic review, terminology validation, quality assurance, and customer approval.
Translation projects can be associated with approved language assets when supported by the account and workflow. Translation memory helps reuse approved translations, while terminology resources control important product, technical, brand, and regulated language.
Stepes Developer Support can assist with API access, authentication, environment setup, workflow design, language configuration, files, webhooks, security, error investigation, and production readiness. Include relevant request, project, and event identifiers, but never send API secrets through email or support forms.
Contact Developer SupportTranslation API
Build Your First Translation Workflow
Connect your application to secure, scalable multilingual workflows supporting AI translation, professional human expertise, terminology control, quality assurance, and content delivery in more than 100 languages.