# Analytics and QC Source: https://api-docs.ollang.com/analytics-qc-monitoring Understand analytics, QC monitoring, localization performance insights, and operational reporting inside the Ollang Project Management Dashboard. ## Overview The Analytics section inside the Ollang Project Management Dashboard helps organizations: * monitor localization performance, * evaluate multilingual quality, * understand credit consumption, * track operational delivery, * benchmark AI performance, * and analyze human review behavior. Analytics provide visibility into: * Order performance, * AI localization quality, * Human review behavior, * QC progression, * operational delivery, * and billing-related insights. *** # Analytics Visibility and Permissions ## Access Requirements Analytics visibility requires: * **Access Billing** permission. Only Project Management Users with Access Billing permissions can view: * Analytics, * Payment Overview, * Credit Overview, * QC performance, * and financial reporting. Standard Project Management Users without Access Billing permission cannot access the Analytics section. *** # Analytics Sections The Analytics dashboard currently includes: Analyze localization activity across Orders. View invoicing and outstanding payment information. Monitor AI credit availability and usage. Review recently processed localization Orders. Understand localization quality progression over time. Understand how much AI-generated output required human modification. *** # Order Analytics ## Overview Order Analytics helps organizations understand: * localization volume, * workflow activity, * delivery performance, * language pair trends, * and operational behavior. Organizations can analyze localization activity across: * Order types, * language pairs, * delivery priorities, * and time periods. *** # Order Analytics Filters Order Analytics supports the following filters: Analyze operational performance within a selected timeframe. Filter analytics by localization workflow type. Analyze localization performance from a selected source language. Analyze localization behavior for specific target markets. Analyze AI-only or AI + Human Review workflows. Filter between standard and rush delivery workflows. *** # Example Analytics Query Example: ```text theme={null} Filters Applied: Start Date: January 1 End Date: February 28 Source Language: English Target Language: French Order Type: Subtitle Translation ``` Result: ```text theme={null} Localized subtitle activity for English → French within the selected timeframe ``` D1 *** # Credit Overview ## Overview Credit Overview provides visibility into: * total AI credits, * remaining AI credits, * and localization consumption. This helps organizations: * manage localization budgets, * understand operational usage, * and monitor available processing capacity. *** # Credit Visibility The dashboard currently displays: ```text theme={null} Total AI Credits ``` This helps operational teams understand: * available localization capacity, * and current AI usage availability. *** # Payment Overview ## Overview Payment Overview provides billing-related visibility for operational teams. This section helps organizations understand: * invoice-related activity, * pending payment behavior, * and financial status. *** # Payment Information The Payment Overview currently includes: Pending operational amounts expected to be invoiced. Existing balance pending payment resolution. D3 # Recent Order Details ## Overview Recent Order Details provide operational visibility into: * recently processed Orders, * localization activity, * and workflow execution. This helps Project Management Users: * quickly monitor activity, * identify recent deliveries, * and review localization progress. D4 *** # Typical Order Details Recent Orders commonly include: * Order information, * localization workflow details, * language pair information, * status, * and operational delivery details. *** # Advanced Search Navigation The Analytics section includes: * **Advanced Search** This action redirects users to: * the Global Search page. This enables teams to: * deeply investigate Orders, * search historical activity, * and perform operational tracking. Workflow: ```text theme={null} Analytics ↓ Advanced Search ↓ Global Search Page ``` *** # QC Score Progression by LLM ## Overview QC Score Progression by LLM provides: * aggregated localization quality trends. Rather than comparing individual provider runs directly, this analytics view helps organizations understand: ```text theme={null} How localization quality improves or changes over time for a selected workflow. ``` *** # Available Filters QC Score Progression supports: Analyze localization quality across a selected timeframe. Filter by source language. Filter by target language. Analyze QC progression for a specific workflow. *** # How QC Progression Works The system analyzes: * average QC scores, * quality progression trends, * and localization improvements. Example: ```text theme={null} English → French Subtitle Translation Last 2 Months ``` The dashboard may show: ```text theme={null} First Average QC Score: 78% Latest Average QC Score: 92% Best Performing LLM: Provider X Improvement: +14% ``` This helps organizations understand: * quality evolution, * workflow effectiveness, * and localization performance over time. *** # Important Clarification QC Score Progression is an aggregated trend analysis and not a side-by-side comparison of every provider run. The platform highlights: * first QC score average, * latest QC score average, * best-performing LLM, * and quality improvement trends. D5 *** # Average Human Edit Percentage ## Overview Average Human Edit Percentage helps organizations understand: ```text theme={null} How much AI-generated content was modified during human review. ``` This metric is especially useful for: * benchmarking provider quality, * evaluating localization efficiency, * identifying problematic language pairs, * and optimizing workflows. *** # Human Edit Filters Average Human Edit Percentage supports: Analyze human edit behavior within a selected timeframe. Analyze edit behavior for specific source languages. Analyze edit behavior for target markets. Evaluate edit percentage across localization workflows. *** # Measurement Methodology Human Edit Percentage is measured at: * segment level. This means the platform evaluates: ```text theme={null} How much subtitle content required modification during human review. ``` The dashboard provides: * overall average human edit percentage, * and Order-level edit details. *** # Example Human Edit Analysis Example: ```text theme={null} English → French Subtitle Translation Date Range: 30 Days ``` Result: ```text theme={null} Average Human Edit: 22% Order Details: Order A → 15% Order B → 32% Order C → 18% ``` This helps organizations identify: * efficient workflows, * high-performing providers, * and problematic localization patterns. D6 *** # Using Analytics for Workflow Optimization Organizations commonly use Analytics to answer questions such as: ```text theme={null} Which workflow performs best for English → French subtitles? ``` ```text theme={null} Which provider reduces human editing effort? ``` ```text theme={null} Which localization workflows improve QC score over time? ``` This helps teams: * improve localization quality, * optimize provider selection, * reduce review effort, * and benchmark multilingual performance. *** # Best Practices Organizations typically achieve the best outcomes by combining: ```text theme={null} QC Score Progression + Human Edit Percentage + AI QC Evaluation + Human QC Annotation ``` This provides visibility into: * AI quality, * human correction effort, * localization consistency, * and long-term optimization opportunities. *** # Important Operational Notes Only users with Access Billing permission can access the Analytics section. No. The analytics show aggregated quality progression and best-performing LLM insights rather than run-by-run comparisons. It measures how much AI-generated content was modified during human review at segment level. Yes. Analytics support Source Language and Target Language filtering. Advanced Search redirects users to the Global Search page for deeper operational investigation. Yes. Analytics help organizations benchmark localization quality, provider effectiveness, and human review effort. # FFmpeg for Video and Audio Operations Source: https://api-docs.ollang.com/apis/audio-operations/ffmpeg **FFmpeg** is a versatile and widely-used multimedia framework that can decode, encode, transcode, mux, demux, stream, filter, and play almost anything that humans and machines have created. It supports the most obscure ancient formats up to the cutting edge, making it a powerful tool for video and audio operations. ## Key Features * **High Versatility**: Supports a wide range of codecs, containers, and formats, enabling it to handle virtually any media file. * **Video Processing**: Provides tools for video scaling, color space/pixel format conversion, video filtering, and more. * **Audio Processing**: Includes features for audio resampling, rematrixing, and sample format conversion. * **Streaming Capabilities**: Can stream media over various protocols, supporting live broadcasting and streaming to multiple destinations. ## Advanced Technologies * **Complex Filtergraphs**: Allows for advanced video and audio processing workflows using filtergraphs, enabling operations like overlaying videos, adding watermarks, and applying various filters. * **Codec Support**: Utilizes a wide array of codecs for both video and audio, including H.264, HEVC, AAC, MP3, and more. * **Libav Libraries**: Incorporates several libraries (libavcodec, libavformat, libavutil, libavfilter, etc.) to provide comprehensive multimedia processing capabilities. * **Hardware Acceleration**: Supports hardware-accelerated encoding and decoding to improve performance on compatible hardware. ## Use Cases 1. **Media Conversion**: Ideal for converting media files between different formats, such as converting a video from AVI to MP4 or an audio file from WAV to MP3. 2. **Streaming**: Suitable for setting up live streaming workflows, including real-time transcoding and streaming to various platforms. 3. **Editing and Filtering**: Enables advanced editing operations like trimming, concatenating, and applying filters to video and audio files. For more details and to access the documentation, visit [FFmpeg](https://ffmpeg.org/documentation.html). # LALAL.AI Stem Separation Source: https://api-docs.ollang.com/apis/audio-operations/lalal-ai LALAL.AI — multi-network stem separation that isolates dialogue from music and effects, the first step of every AI Dubbing Order in Ollang. **LALAL.AI** is a dedicated stem separation service built on a set of proprietary neural networks, capable of splitting a track into a dozen distinct stem types. In an Ollang dubbing pipeline it does one specific and important job: separate the source audio into an isolated **dialogue stem** and a **music-and-effects (M\&E) bed**. The dialogue stem feeds transcription; the M\&E bed is preserved and remixed under the synthesized target-language voice. That separation is what makes a dub sound like a dub rather than a voiceover talking over the original mix. **Available in Ollang Workflows** as `lalalAi` — AI Dubbing · **Default**. See the [Audio Processing catalog](/providers/audio-processing). ## Separation networks The v1 API exposes six named splitters plus an `auto` option that selects the most effective one for the requested stem: `phoenix` · `orion` · `perseus` · `andromeda` · `lyra` · `lynx` · `auto` **Orion** is the one that matters most for dubbing quality. Rather than carving stems out of the mix with spectral masks, it **synthesizes** them — reconstructing the stem from what it has learned across many mixes. The practical result is markedly less of the artifact residue that betrays a dub: the watery, phase-smeared remainder left where dialogue used to be. Unless you have a reason to pin a specific network, `auto` is the sensible default: the best splitter for a stem is not the same across all of them. ## Extractable stems The API accepts twelve stem values: `vocals` · `voice` · `music` · `drum` · `bass` · `piano` · `guitar` · `electric_guitar` · `acoustic_guitar` · `synthesizer` · `strings` · `wind` `vocals` and `voice` are separate values — the first targets sung vocals, the second spoken voice, which is the one a dubbing pipeline wants. `music` is its counterpart: the bed that has to survive under the new dialogue. `guitar` is a generic value alongside the more specific `electric_guitar` and `acoustic_guitar`. For dubbing, the relevant split is voice against music. The finer stems matter when a mix has to be partially rebuilt — for example, when original dialogue sits under a music cue that must be preserved intact. ## Processing options | Option | Values | Effect | | - | - | - | | **Noise cancelling** | `0`, `1`, `2` | Filtering intensity applied to the extracted voice | | **Dereverberation** | `dereverb_enabled` | Removes room echo, which materially improves downstream transcription on live-recorded source | | **Extraction level** | `deep_extraction`, `clear_cut` | Trades completeness of the extracted stem against cleanliness of what is left behind | | **Output format** | `mp3`, `wav`, `flac`, `aac`, `ogg` | Lossless options matter when the stem is going back into a mix | ## Where it fits in a workflow LALAL.AI runs on every AI Dubbing Order and is the default for the `split` step. It is the shortest stage in the pipeline, and the one with the largest effect on whether the finished mix sounds professional. Dereverberation is worth knowing about specifically: reverb in the source is one of the more reliable ways to degrade transcription accuracy downstream, so cleaning it at the separation step improves every subsequent stage. ## Considerations * **Separation quality tracks source quality.** Heavily compressed audio, dialogue buried under a loud mix, or material already processed by another separation tool will produce a weaker M\&E bed. * **A clean stem always beats a separated one.** Where the source has a discrete dialogue stem available, supplying it directly gives a better result than separating it back out. ## Reference * [Audio Processing provider catalog](/providers/audio-processing) * [LALAL.AI](https://www.lalal.ai) * [LALAL.AI API v1 documentation](https://www.lalal.ai/api/v1/docs/) # Assign Translator to Folder Orders Source: https://api-docs.ollang.com/apis/ollang-api-reference/assign-translator-to-folder-orders POST https://api-integration.ollang.com/integration/folder/{folderId}/assign-translator-to-orders Batch assign a translator to eligible orders in a folder with optional language filters Assigns a translator to all eligible (unassigned, completed) orders in the specified folder. Optionally filter by `sourceLanguage` and/or `targetLanguage` to only assign orders matching a specific language pair. When no language filters are provided, all eligible orders in the folder are assigned. ```bash cURL (all orders) theme={null} curl -X POST "https://api-integration.ollang.com/integration/folder/60b8d6f1e1b9b1d8c6c0d8e1/assign-translator-to-orders" \ -H "X-Api-Key: " \ -H "Content-Type: application/json" \ -d '{ "translatorId": "507f1f77bcf86cd799439011" }' ``` ```bash cURL (filtered by language pair) theme={null} curl -X POST "https://api-integration.ollang.com/integration/folder/60b8d6f1e1b9b1d8c6c0d8e1/assign-translator-to-orders" \ -H "X-Api-Key: " \ -H "Content-Type: application/json" \ -d '{ "translatorId": "507f1f77bcf86cd799439011", "deadline": "2026-07-01T00:00:00.000Z", "sourceLanguage": "en", "targetLanguage": "fr" }' ``` ```javascript JavaScript theme={null} const folderId = "60b8d6f1e1b9b1d8c6c0d8e1"; const response = await fetch( `https://api-integration.ollang.com/integration/folder/${folderId}/assign-translator-to-orders`, { method: "POST", headers: { "X-Api-Key": "", "Content-Type": "application/json", }, body: JSON.stringify({ translatorId: "507f1f77bcf86cd799439011", sourceLanguage: "en", targetLanguage: "fr", }), }, ); const data = await response.json(); console.log(`Assigned ${data.assignedCount} orders`); ``` ```python Python theme={null} import requests folder_id = "60b8d6f1e1b9b1d8c6c0d8e1" response = requests.post( f"https://api-integration.ollang.com/integration/folder/{folder_id}/assign-translator-to-orders", headers={ "X-Api-Key": "", "Content-Type": "application/json", }, json={ "translatorId": "507f1f77bcf86cd799439011", "sourceLanguage": "en", "targetLanguage": "fr", }, ) data = response.json() print(f"Assigned {data['assignedCount']} orders") ``` ## Authorizations This endpoint requires API key authentication. Include your API key in the request header: * **Header name**: `X-Api-Key` * **Header value**: Your API key from the Ollang dashboard ## Path Parameters The unique identifier of the folder containing the orders. ## Body Parameters The translator ID to assign to the orders. Optional deadline for the assignment in ISO 8601 format (e.g., `2026-07-01T00:00:00.000Z`). Filter by source language code (e.g., `en`). Only orders with this source language will be assigned. Filter by target language code (e.g., `fr`). Only orders with this target language will be assigned. ## Response The number of orders that were successfully assigned. ```json 200 theme={null} { "assignedCount": 12 } ``` ```json 400 theme={null} { "statusCode": 400, "message": [ "translatorId must be a string" ], "error": "Bad Request" } ``` ```json 401 theme={null} { "error": "Unauthorized", "message": "Invalid or missing API key", "code": "UNAUTHORIZED" } ``` # Attach Folder Document Source: https://api-docs.ollang.com/apis/ollang-api-reference/attach-folder-document POST https://api-integration.ollang.com/integration/folder/{folderId}/docs Attach a guideline, glossary, or character list to a folder so every project in it inherits the document Attaches a folder-level document to a folder. The document is applied to every project that already exists in the folder **and** to projects created in it afterwards, including projects created through [Direct File Upload](/apis/ollang-api-reference/direct-file-upload). This is the API equivalent of uploading a guideline in the folder's **Guidelines** panel in the dashboard. See [Memory, Guidelines, and Custom Instructions](/memory-guidelines-custom-instructions) for how folder-level guidelines interact with project-level guidelines and global custom instructions. Ollang fetches the document from the URL you supply and stores its own copy, so a short-lived pre-signed URL is fine. The URL only needs to be readable at the moment of the call, and the document stays available to later orders after the signature expires. Have the file locally rather than hosted? Use [Upload Folder Document](/apis/ollang-api-reference/upload-folder-document) to send it directly as `multipart/form-data`, with no URL needed. ```bash cURL theme={null} curl -X POST "https://api-integration.ollang.com/integration/folder/60b8d6f1e1b9b1d8c6c0d8e1/docs" \ -H "X-Api-Key: " \ -H "Content-Type: application/json" \ -d '{ "url": "https://your-bucket.s3.amazonaws.com/brand-guideline-v3.pdf?X-Amz-Signature=...", "type": "guideline", "name": "Brand guideline v3", "size": 481203, "language": "en" }' ``` ```javascript JavaScript theme={null} const folderId = "60b8d6f1e1b9b1d8c6c0d8e1"; const response = await fetch( `https://api-integration.ollang.com/integration/folder/${folderId}/docs`, { method: "POST", headers: { "X-Api-Key": "", "Content-Type": "application/json", }, body: JSON.stringify({ url: "https://your-bucket.s3.amazonaws.com/brand-guideline-v3.pdf?X-Amz-Signature=...", type: "guideline", name: "Brand guideline v3", language: "en", }), }, ); const doc = await response.json(); console.log("Attached document:", doc.id); ``` ```python Python theme={null} import requests folder_id = "60b8d6f1e1b9b1d8c6c0d8e1" response = requests.post( f"https://api-integration.ollang.com/integration/folder/{folder_id}/docs", headers={ "X-Api-Key": "", "Content-Type": "application/json", }, json={ "url": "https://your-bucket.s3.amazonaws.com/brand-guideline-v3.pdf?X-Amz-Signature=...", "type": "guideline", "name": "Brand guideline v3", "language": "en", }, ) doc = response.json() print("Attached document:", doc["id"]) ``` ```php PHP theme={null} $folderId = '60b8d6f1e1b9b1d8c6c0d8e1'; $payload = json_encode([ 'url' => 'https://your-bucket.s3.amazonaws.com/brand-guideline-v3.pdf?X-Amz-Signature=...', 'type' => 'guideline', 'name' => 'Brand guideline v3', 'language' => 'en', ]); $curl = curl_init(); curl_setopt_array($curl, array( CURLOPT_URL => "https://api-integration.ollang.com/integration/folder/{$folderId}/docs", CURLOPT_RETURNTRANSFER => true, CURLOPT_POST => true, CURLOPT_POSTFIELDS => $payload, CURLOPT_HTTPHEADER => array( 'X-Api-Key: ', 'Content-Type: application/json' ), )); $response = curl_exec($curl); $doc = json_decode($response, true); curl_close($curl); echo "Attached document: " . $doc['id']; ``` ```go Go theme={null} package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { folderID := "60b8d6f1e1b9b1d8c6c0d8e1" url := "https://api-integration.ollang.com/integration/folder/" + folderID + "/docs" payload, _ := json.Marshal(map[string]interface{}{ "url": "https://your-bucket.s3.amazonaws.com/brand-guideline-v3.pdf?X-Amz-Signature=...", "type": "guideline", "name": "Brand guideline v3", "language": "en", }) req, _ := http.NewRequest("POST", url, bytes.NewBuffer(payload)) req.Header.Set("X-Api-Key", "") req.Header.Set("Content-Type", "application/json") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) var doc map[string]interface{} json.Unmarshal(body, &doc) fmt.Println("Attached document:", doc["id"]) } ``` ```java Java theme={null} String folderId = "60b8d6f1e1b9b1d8c6c0d8e1"; JSONObject payload = new JSONObject() .put("url", "https://your-bucket.s3.amazonaws.com/brand-guideline-v3.pdf?X-Amz-Signature=...") .put("type", "guideline") .put("name", "Brand guideline v3") .put("language", "en"); HttpResponse response = Unirest .post("https://api-integration.ollang.com/integration/folder/" + folderId + "/docs") .header("X-Api-Key", "") .header("Content-Type", "application/json") .body(payload.toString()) .asString(); JSONObject doc = new JSONObject(response.getBody()); System.out.println("Attached document: " + doc.getString("id")); ``` ## Authorizations This endpoint requires API key authentication. Include your API key in the request header: * **Header name**: `X-Api-Key` * **Header value**: Your API key from the Ollang dashboard * **Format**: `X-Api-Key: your-api-key-here` The API key user needs write access to the folder. Keys without a folder-write role receive a `403`. ## Path Parameters The unique identifier of the folder to attach the document to. ## Body Parameters A URL Ollang can read the document from, such as a pre-signed S3 URL. Must be `http` or `https`, must resolve to a public address, and must return the file without a redirect. The document must be 50 MB or smaller. The kind of folder document. One of: * `guideline` — style and tone guidance * `guideline_glossary` — terminology list * `character_list` — character names and notes Display name of the document. Defaults to `_folder_document`. Size of the document in bytes. Ollang records the size of the file it actually fetched, so this value is informational. BCP-47 language tag of the document (e.g. `en`). When omitted, each project copy uses that project's source language. ## Response Returns the created folder document. Unique identifier of the folder document. Pass this to [Remove Folder Document](/apis/ollang-api-reference/delete-folder-document). Display name of the document. One of `guideline`, `guideline_glossary`, or `character_list`. Location of the stored copy Ollang created. Size of the stored document in bytes. The `language` supplied with the request, or `null`. Identifier of the folder the document is attached to. When the document was attached, in ISO 8601 format. ```json 201 theme={null} { "id": "60b8d6f1e1b9b1d8c6c0d8f1", "name": "Brand guideline v3", "type": "guideline", "url": "https://ollang-docs.s3.eu-central-1.amazonaws.com/60b8d6f1e1b9b1d8c6c0d8e5/brand-guideline-v3.pdf", "size": 481203, "sourceLanguage": "en", "folderId": "60b8d6f1e1b9b1d8c6c0d8e1", "clientId": "60b8d6f1e1b9b1d8c6c0d8e5", "createdAt": "2026-09-02T10:14:22.511Z", "updatedAt": "2026-09-02T10:14:22.511Z" } ``` ```json 400 theme={null} { "statusCode": 400, "message": "Could not fetch the document from the provided URL. Make sure it is publicly readable and under 50 MB.", "error": "Bad Request" } ``` ```json 401 theme={null} { "error": "Unauthorized", "message": "Invalid or missing API key", "code": "UNAUTHORIZED" } ``` ```json 403 theme={null} { "statusCode": 403, "message": "You do not have permission to modify this folder", "error": "Forbidden" } ``` ```json 404 theme={null} { "statusCode": 404, "message": "Folder not found", "error": "Not Found" } ``` # Bulk Export Folders XLSX Source: https://api-docs.ollang.com/apis/ollang-api-reference/bulk-export-folders-xlsx POST https://api-integration.ollang.com/integration/folder/export-xlsx Export video timestamps, transcriptions, and translations for multiple folders as a multi-sheet XLSX spreadsheet Returns an XLSX spreadsheet with one sheet per order/language combination for all orders in the specified folders. Each sheet contains segment data (timecodes, source transcription, translated text). The spreadsheet contains the following columns per sheet: | Column | Description | | - | - | | SR NO | Sequential row number | | TCR | Timecode (start timestamp) | | SPEAKER | Speaker name | | DIALOGUES | Source transcription text | | *Target Language* | Translated text (column header is the target language code) | Sheet names follow the pattern `{OrderName} - {targetLanguage}` (max 31 characters). ```bash cURL theme={null} curl -X POST "https://api-integration.ollang.com/integration/folder/export-xlsx" \ -H "X-Api-Key: " \ -H "Content-Type: application/json" \ -d '{ "folderIds": ["60b8d6f1e1b9b1d8c6c0d8e1"], "targetLanguages": ["tr", "en"] }' \ --output bulk_export.xlsx ``` ```javascript JavaScript theme={null} const response = await fetch( "https://api-integration.ollang.com/integration/folder/export-xlsx", { method: "POST", headers: { "X-Api-Key": "", "Content-Type": "application/json", }, body: JSON.stringify({ folderIds: ["60b8d6f1e1b9b1d8c6c0d8e1"], targetLanguages: ["tr", "en"], }), }, ); const blob = await response.blob(); const url = URL.createObjectURL(blob); // Download or process the XLSX file ``` ```python Python theme={null} import requests response = requests.post( "https://api-integration.ollang.com/integration/folder/export-xlsx", headers={ "X-Api-Key": "", "Content-Type": "application/json", }, json={ "folderIds": ["60b8d6f1e1b9b1d8c6c0d8e1"], "targetLanguages": ["tr", "en"], }, ) with open("bulk_export.xlsx", "wb") as f: f.write(response.content) ``` ## Authorizations This endpoint requires API key authentication. Include your API key in the request header: * **Header name**: `X-Api-Key` * **Header value**: Your API key from the Ollang dashboard ## Body Parameters Array of folder IDs containing the orders to export. Array of target language codes to include in the export. ## Response The response is a binary XLSX file download. The response headers include: * `Content-Type: application/vnd.openxmlformats-officedocument.spreadsheetml.sheet` * `Content-Disposition: attachment; filename="bulk_export_{date}.xlsx"` ```text 200 theme={null} Binary XLSX file (multi-sheet spreadsheet with segment data) ``` ```json 400 theme={null} { "statusCode": 400, "message": [ "each value in folderIds must be a string", "folderIds should not be empty" ], "error": "Bad Request" } ``` ```json 401 theme={null} { "error": "Unauthorized", "message": "Invalid or missing API key", "code": "UNAUTHORIZED" } ``` ```json 500 theme={null} { "statusCode": 500, "message": "No segment data found for the given folders and target languages." } ``` # Cancel Human Review for an Order Source: https://api-docs.ollang.com/apis/ollang-api-reference/cancel-human-review POST https://api-integration.ollang.com/integration/orders/{orderId}/cancel-human-review Cancel an active human review request for an order. The human review credits are refunded and the order is reverted back to its AI-only (Level 0) state. Cancel an active human review request for an order. This endpoint reverts a Level 1 (Human Review) order back to Level 0 (AI-only), refunds the human review portion of the credits to the client, and disconnects the assigned translator. Only orders that are currently in progress with human review (Level 1, status `ongoing`) can be cancelled. ```bash cURL theme={null} curl -X POST "https://api-integration.ollang.com/integration/orders/60b8d6f1e1b9b1d8c6c0d8e1/cancel-human-review" \ -H "X-Api-Key: " ``` ```javascript JavaScript theme={null} const orderId = "60b8d6f1e1b9b1d8c6c0d8e1"; const response = await fetch( `https://api-integration.ollang.com/integration/orders/${orderId}/cancel-human-review`, { method: "POST", headers: { "X-Api-Key": "", }, }, ); const result = await response.json(); console.log(result); ``` ```python Python theme={null} import requests order_id = "60b8d6f1e1b9b1d8c6c0d8e1" headers = { 'X-Api-Key': '' } response = requests.post( f'https://api-integration.ollang.com/integration/orders/{order_id}/cancel-human-review', headers=headers ) print(response.json()) ``` ```php PHP theme={null} $orderId = '60b8d6f1e1b9b1d8c6c0d8e1'; $curl = curl_init(); curl_setopt_array($curl, array( CURLOPT_URL => 'https://api-integration.ollang.com/integration/orders/' . $orderId . '/cancel-human-review', CURLOPT_RETURNTRANSFER => true, CURLOPT_POST => true, CURLOPT_HTTPHEADER => array( 'X-Api-Key: ' ), )); $response = curl_exec($curl); $httpCode = curl_getinfo($curl, CURLINFO_HTTP_CODE); curl_close($curl); $result = json_decode($response, true); print_r($result); ``` ```go Go theme={null} package main import ( "fmt" "io" "net/http" ) func main() { orderId := "60b8d6f1e1b9b1d8c6c0d8e1" url := fmt.Sprintf("https://api-integration.ollang.com/integration/orders/%s/cancel-human-review", orderId) req, _ := http.NewRequest("POST", url, nil) req.Header.Set("X-Api-Key", "") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) } ``` ```java Java theme={null} String orderId = "60b8d6f1e1b9b1d8c6c0d8e1"; HttpResponse response = Unirest.post("https://api-integration.ollang.com/integration/orders/" + orderId + "/cancel-human-review") .header("X-Api-Key", "") .asString(); System.out.println(response.getBody()); ``` ## Authorizations This endpoint requires API key authentication. Include your API key in the request header: * **Header name**: `X-Api-Key` * **Header value**: Your API key from the Ollang dashboard * **Format**: `X-Api-Key: your-api-key-here` You can obtain your API key from your [Ollang dashboard](https://lab.ollang.com). ## Path Parameters The unique identifier of the order for which you want to cancel the human review. The order must be Level 1 (Human Review) and currently in `ongoing` status. ## Response Indicates whether the human review cancellation was processed successfully. A message describing the result of the request. The unique identifier of the order whose human review was cancelled. ```json 200 theme={null} { "success": true, "message": "Human Review has been cancelled and credits have been refunded.", "orderId": "60b8d6f1e1b9b1d8c6c0d8e1" } ``` ```json 400 theme={null} { "statusCode": 400, "message": "Only Level 1 (Human Review) orders can be cancelled" } ``` ```json 400 theme={null} { "statusCode": 400, "message": "Human Review can only be cancelled while the order is still in progress" } ``` ```json 404 theme={null} { "statusCode": 404, "message": "Order not found" } ``` ```json 401 theme={null} { "error": "Unauthorized", "message": "Invalid or missing API key", "code": "UNAUTHORIZED" } ``` ## How It Works When you cancel a human review request: 1. **Credit Refund** — The human review portion of the cost (Level 1 price minus Level 0 price) is refunded to your USD credit balance. 2. **Order Revert** — The order level is changed from 1 (Human Review) back to 0 (AI-only) and the status is set to `completed`. 3. **Translator Disconnect** — Any assigned translator is removed from the order. You can only cancel a human review while the order is still **in progress** (`ongoing` status). Once the translator has completed their review and the order status changes to `completed`, cancellation is no longer possible. # Cancel Order Source: https://api-docs.ollang.com/apis/ollang-api-reference/cancel-order POST https://api-integration.ollang.com/integration/orders/cancel/{orderId} Cancel an existing translation order that is no longer needed Cancel an existing translation order that is no longer needed. This action is typically irreversible, so use it carefully. Only orders in certain statuses can be cancelled. ```bash cURL theme={null} curl -X POST "https://api-integration.ollang.com/integration/orders/cancel/60b8d6f1e1b9b1d8c6c0d8e1" \ -H "X-Api-Key: " ``` ```javascript JavaScript theme={null} const orderId = "60b8d6f1e1b9b1d8c6c0d8e1"; const response = await fetch( `https://api-integration.ollang.com/integration/orders/cancel/${orderId}`, { method: "POST", headers: { "X-Api-Key": "", }, } ); if (response.status === 204) { console.log("Order cancelled successfully"); } ``` ```python Python theme={null} import requests order_id = "60b8d6f1e1b9b1d8c6c0d8e1" headers = { 'X-Api-Key': '' } response = requests.post( f'https://api-integration.ollang.com/integration/orders/cancel/{order_id}', headers=headers ) if response.status_code == 204: print("Order cancelled successfully") ``` ```php PHP theme={null} $orderId = '60b8d6f1e1b9b1d8c6c0d8e1'; $curl = curl_init(); curl_setopt_array($curl, array( CURLOPT_URL => 'https://api-integration.ollang.com/integration/orders/cancel/' . $orderId, CURLOPT_RETURNTRANSFER => true, CURLOPT_POST => true, CURLOPT_HTTPHEADER => array( 'X-Api-Key: ' ), )); $response = curl_exec($curl); $httpCode = curl_getinfo($curl, CURLINFO_HTTP_CODE); curl_close($curl); if ($httpCode === 204) { echo "Order cancelled successfully"; } ``` ```go Go theme={null} package main import ( "fmt" "net/http" ) func main() { orderId := "60b8d6f1e1b9b1d8c6c0d8e1" url := fmt.Sprintf("https://api-integration.ollang.com/integration/orders/cancel/%s", orderId) req, _ := http.NewRequest("POST", url, nil) req.Header.Set("X-Api-Key", "") client := &http.Client{} resp, _ := client.Do(req) if resp.StatusCode == 204 { fmt.Println("Order cancelled successfully") } } ``` ```java Java theme={null} String orderId = "60b8d6f1e1b9b1d8c6c0d8e1"; HttpResponse response = Unirest.post("https://api-integration.ollang.com/integration/orders/cancel/" + orderId) .header("X-Api-Key", "") .asString(); if (response.getStatus() == 204) { System.out.println("Order cancelled successfully"); } ``` ## Authorizations This endpoint requires API key authentication. Include your API key in the request header: * **Header name**: `X-Api-Key` * **Header value**: Your API key from the Ollang dashboard * **Format**: `X-Api-Key: your-api-key-here` You can obtain your API key from your [Ollang dashboard](https://lab.ollang.com). ## Path Parameters The unique identifier of the order you want to cancel. This should be a valid order ID that you have access to and that is eligible for cancellation. ## Important Notes **Order Cancellation is Irreversible** Once an order is cancelled, it cannot be restored. Make sure you really want to cancel the order before making this request. **Cancellation Eligibility** Not all orders can be cancelled. Orders that are already in progress, completed, or delivered typically cannot be cancelled. Only orders in `pending` or early `ongoing` status are usually eligible for cancellation. ## Response This endpoint returns no content on successful cancellation (HTTP 204 status code). The absence of an error response indicates that the order was successfully cancelled. ```json 204 theme={null} No content - Order cancelled successfully ``` ```json 404 theme={null} { "error": "Order not found", "message": "No order found with the provided orderId", "code": "ORDER_NOT_FOUND" } ``` ```json 400 theme={null} { "error": "Cannot cancel order", "message": "Order cannot be cancelled because it is already in progress or completed", "code": "ORDER_NOT_CANCELLABLE" } ``` ```json 403 theme={null} { "error": "Access denied", "message": "You don't have permission to cancel this order", "code": "ACCESS_DENIED" } ``` ```json 409 theme={null} { "error": "Order already cancelled", "message": "This order has already been cancelled", "code": "ORDER_ALREADY_CANCELLED" } ``` ```json 401 theme={null} { "error": "Unauthorized", "message": "Invalid or missing API key", "code": "UNAUTHORIZED" } ``` # Create a Revision For an Order Source: https://api-docs.ollang.com/apis/ollang-api-reference/create-a-revision-for-an-order POST https://api-integration.ollang.com/integration/revision/{orderId} Create a revision request for an existing order to report issues or request changes Create a revision request for an existing order to report issues or request changes to the delivered content. This endpoint allows you to specify the type of issue and provide detailed feedback for correction. ```bash cURL theme={null} curl -X POST "https://api-integration.ollang.com/integration/revision/60b8d6f1e1b9b1d8c6c0d8e1" \ -H "X-Api-Key: " \ -H "Content-Type: application/json" \ -d '{ "type": "wrongSubtitle", "time": "02:15:30", "description": "The subtitle at this timestamp is incorrectly translated. Should be '\''Hello world'\'' instead of '\''Hello universe'\''." }' ``` ```javascript JavaScript theme={null} const orderId = "60b8d6f1e1b9b1d8c6c0d8e1"; const response = await fetch( `https://api-integration.ollang.com/integration/revision/${orderId}`, { method: "POST", headers: { "X-Api-Key": "", "Content-Type": "application/json", }, body: JSON.stringify({ type: "wrongSubtitle", time: "02:15:30", description: "The subtitle at this timestamp is incorrectly translated. Should be 'Hello world' instead of 'Hello universe'.", }), } ); const revisionData = await response.json(); ``` ```python Python theme={null} import requests import json order_id = "60b8d6f1e1b9b1d8c6c0d8e1" data = { "type": "wrongSubtitle", "time": "02:15:30", "description": "The subtitle at this timestamp is incorrectly translated. Should be 'Hello world' instead of 'Hello universe'." } headers = { 'X-Api-Key': '', 'Content-Type': 'application/json' } response = requests.post( f'https://api-integration.ollang.com/integration/revision/{order_id}', headers=headers, data=json.dumps(data) ) revision_data = response.json() ``` ```php PHP theme={null} $orderId = '60b8d6f1e1b9b1d8c6c0d8e1'; $data = array( 'type' => 'wrongSubtitle', 'time' => '02:15:30', 'description' => 'The subtitle at this timestamp is incorrectly translated. Should be \'Hello world\' instead of \'Hello universe\'.' ); $curl = curl_init(); curl_setopt_array($curl, array( CURLOPT_URL => 'https://api-integration.ollang.com/integration/revision/' . $orderId, CURLOPT_RETURNTRANSFER => true, CURLOPT_POST => true, CURLOPT_HTTPHEADER => array( 'X-Api-Key: ', 'Content-Type: application/json' ), CURLOPT_POSTFIELDS => json_encode($data), )); $response = curl_exec($curl); curl_close($curl); ``` ```go Go theme={null} package main import ( "bytes" "encoding/json" "fmt" "net/http" ) func main() { orderId := "60b8d6f1e1b9b1d8c6c0d8e1" url := fmt.Sprintf("https://api-integration.ollang.com/integration/revision/%s", orderId) data := map[string]interface{}{ "type": "wrongSubtitle", "time": "02:15:30", "description": "The subtitle at this timestamp is incorrectly translated. Should be 'Hello world' instead of 'Hello universe'.", } jsonData, _ := json.Marshal(data) req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData)) req.Header.Set("X-Api-Key", "") req.Header.Set("Content-Type", "application/json") client := &http.Client{} resp, _ := client.Do(req) } ``` ```java Java theme={null} import org.json.JSONObject; String orderId = "60b8d6f1e1b9b1d8c6c0d8e1"; JSONObject requestBody = new JSONObject(); requestBody.put("type", "wrongSubtitle"); requestBody.put("time", "02:15:30"); requestBody.put("description", "The subtitle at this timestamp is incorrectly translated. Should be 'Hello world' instead of 'Hello universe'."); HttpResponse response = Unirest.post("https://api-integration.ollang.com/integration/revision/" + orderId) .header("X-Api-Key", "") .header("Content-Type", "application/json") .body(requestBody.toString()) .asString(); ``` ## Authorizations This endpoint requires API key authentication. Include your API key in the request header: * **Header name**: `X-Api-Key` * **Header value**: Your API key from the Ollang dashboard * **Format**: `X-Api-Key: your-api-key-here` You can obtain your API key from your [Ollang dashboard](https://lab.ollang.com). ## Path Parameters The unique identifier of the order for which you want to create a revision. This should be a completed or delivered order that you have access to. ## Body Parameters The type of revision needed. Available options: - `missingSubtitle` - Subtitle is missing at a specific time - `wrongSubtitle` - Subtitle content is incorrect - `syncError` - Subtitle timing is not synchronized with audio - `formatError` - Subtitle formatting issues - `other` - Other types of issues not covered above Timestamp indicating where the issue occurs in the content. Format: "HH:MM:SS" (e.g., "02:15:30" for 2 hours, 15 minutes, 30 seconds). Optional detailed description of the revision request. Provide specific information about what needs to be corrected, including the expected result. ## Response Unique identifier of the created revision request. Creation date and time of the revision request (ISO 8601 format). The type of revision that was requested. The timestamp where the issue occurs in the content. The description provided for the revision request. ```json 201 theme={null} { "id": "rev_60b8d6f1e1b9b1d8c6c0d8e1", "createdAt": "2024-01-17T10:30:00Z", "type": "wrongSubtitle", "time": "02:15:30", "description": "The subtitle at this timestamp is incorrectly translated. Should be 'Hello world' instead of 'Hello universe'." } ``` ```json 404 theme={null} { "error": "Order not found", "message": "No order found with the provided orderId", "code": "ORDER_NOT_FOUND" } ``` ```json 400 theme={null} { "error": "Invalid revision type", "message": "Revision type must be one of: missingSubtitle, wrongSubtitle, syncError, formatError, other", "code": "INVALID_REVISION_TYPE" } ``` ```json 400 theme={null} { "error": "Order not eligible for revision", "message": "Only completed or delivered orders can have revision requests", "code": "ORDER_NOT_ELIGIBLE" } ``` ```json 403 theme={null} { "error": "Access denied", "message": "You don't have permission to create revisions for this order", "code": "ACCESS_DENIED" } ``` ```json 401 theme={null} { "error": "Unauthorized", "message": "Invalid or missing API key", "code": "UNAUTHORIZED" } ``` # Create Custom Instruction Source: https://api-docs.ollang.com/apis/ollang-api-reference/create-custom-instruction POST https://api-integration.ollang.com/integration/custom-instructions Create a new custom translation instruction for your account Create a custom instruction string (guideline) that can influence how translations are produced for your projects. ```bash cURL theme={null} curl -X POST "https://api-integration.ollang.com/integration/custom-instructions" \ -H "X-Api-Key: " \ -H "Content-Type: application/json" \ -d '{ "key": "tone_and_register", "value": "Match the formality level of the source. Business emails should remain professional.", "description": "Instructions for maintaining appropriate tone and register" }' ``` ```javascript JavaScript theme={null} const response = await fetch( "https://api-integration.ollang.com/integration/custom-instructions", { method: "POST", headers: { "X-Api-Key": "", "Content-Type": "application/json", }, body: JSON.stringify({ key: "tone_and_register", value: "Match the formality level of the source. Business emails should remain professional.", description: "Instructions for maintaining appropriate tone and register", }), } ); const created = await response.json(); ``` ```python Python theme={null} import requests data = { "key": "tone_and_register", "value": "Match the formality level of the source. Business emails should remain professional.", "description": "Instructions for maintaining appropriate tone and register", } headers = { "X-Api-Key": "", "Content-Type": "application/json", } response = requests.post( "https://api-integration.ollang.com/integration/custom-instructions", headers=headers, json=data, ) created = response.json() ``` ## Authorizations This endpoint requires API key authentication. * **Header name**: `X-Api-Key` * **Header value**: Your API key from the [Ollang dashboard](https://lab.ollang.com) ## Body Parameters Machine-friendly identifier for this instruction (e.g. `tone_and_register`). The full instruction text. Optional longer description of what this instruction controls. ## Response Returns the created custom instruction, including `id`, timestamps, and `scopeRefId`. Same shape as [List Custom Instructions](/apis/ollang-api-reference/list-custom-instructions). ```json 201 theme={null} { "id": "507f1f77bcf86cd799439011", "key": "tone_and_register", "value": "Match the formality level of the source. Business emails should remain professional.", "active": true, "description": "Instructions for maintaining appropriate tone and register", "scopeRefId": "507f1f77bcf86cd799439012", "createdAt": "2023-10-05T12:34:56.789Z", "updatedAt": "2023-10-05T12:34:56.789Z" } ``` ```json 400 theme={null} { "statusCode": 400, "message": ["key should not be empty"] } ``` ```json 401 theme={null} { "error": "Unauthorized", "message": "Invalid or missing API key" } ``` # Create Memory Source: https://api-docs.ollang.com/apis/ollang-api-reference/create-memory POST https://api-integration.ollang.com/integration/memories Create a new translation memory for your account Create an empty translation memory. Fill it with the [Import Memory Items](/apis/ollang-api-reference/import-memory-items) endpoint, then pass its id as `selectedMemories` when [creating an order](/apis/ollang-api-reference/create-order). ```bash cURL theme={null} curl -X POST "https://api-integration.ollang.com/integration/memories" \ -H "X-Api-Key: " \ -H "Content-Type: application/json" \ -d '{ "title": "Product documentation EN→FR" }' ``` ```javascript JavaScript theme={null} const response = await fetch( "https://api-integration.ollang.com/integration/memories", { method: "POST", headers: { "X-Api-Key": "", "Content-Type": "application/json", }, body: JSON.stringify({ title: "Product documentation EN→FR", }), } ); const memory = await response.json(); ``` ```python Python theme={null} import requests data = {"title": "Product documentation EN→FR"} headers = { "X-Api-Key": "", "Content-Type": "application/json", } response = requests.post( "https://api-integration.ollang.com/integration/memories", json=data, headers=headers, ) memory = response.json() ``` ## Authorizations This endpoint requires API key authentication. * **Header name**: `X-Api-Key` * **Header value**: Your API key from the [Ollang dashboard](https://lab.ollang.com) ## Body Parameters Human-readable name of the translation memory. ## Response Returns the created translation memory object. Unique identifier of the translation memory. Human-readable name of the translation memory. Number of translation units stored in the memory. Always `0` for a newly created memory. Creation timestamp (ISO 8601). Last update timestamp (ISO 8601). ```json 201 theme={null} { "id": "507f1f77bcf86cd799439011", "title": "Product documentation EN→FR", "memoryItemsCount": 0, "createdAt": "2026-08-11T09:15:00.000Z", "updatedAt": "2026-08-11T09:15:00.000Z" } ``` ```json 403 theme={null} { "statusCode": 403, "message": "Translation Memory feature is not available in your current plan. Please upgrade to access this feature." } ``` ```json 401 theme={null} { "error": "Unauthorized", "message": "Invalid or missing API key" } ``` # Create Order Source: https://api-docs.ollang.com/apis/ollang-api-reference/create-order POST https://api-integration.ollang.com/integration/orders/create Create a new translation order for your uploaded video projects Create a new translation order for your uploaded video projects. This endpoint allows you to request specific translation services such as closed captions, subtitles, dubbing, and more. ```bash cURL theme={null} curl -X POST "https://api-integration.ollang.com/integration/orders/create" \ -H "X-Api-Key: " \ -H "Content-Type: application/json" \ -d '{ "orderType": "cc", "level": 1, "projectId": "60b8d6f1e1b9b1d8c6c0d8e1", "targetLanguageConfigs": [ { "language": "fr", "isRush": false }, { "language": "es", "isRush": true } ], "callbackUrl": "https://your-domain.com/webhooks/order-completed", "autoQc": true, "selectedMemories": ["60b8d6f1e1b9b1d8c6c0d8e1"] }' ``` ```javascript JavaScript theme={null} const response = await fetch( "https://api-integration.ollang.com/integration/orders/create", { method: "POST", headers: { "X-Api-Key": "", "Content-Type": "application/json", }, body: JSON.stringify({ orderType: "cc", level: 1, projectId: "60b8d6f1e1b9b1d8c6c0d8e1", targetLanguageConfigs: [ { language: "fr", isRush: false, }, { language: "es", isRush: true, }, ], callbackUrl: "https://your-domain.com/webhooks/order-completed", autoQc: true, selectedMemories: ["60b8d6f1e1b9b1d8c6c0d8e1"], }), } ); ``` ```python Python theme={null} import requests import json data = { "orderType": "cc", "level": 1, "projectId": "60b8d6f1e1b9b1d8c6c0d8e1", "targetLanguageConfigs": [ { "language": "fr", "isRush": False }, { "language": "es", "isRush": True } ], "callbackUrl": "https://your-domain.com/webhooks/order-completed", "autoQc": True, "selectedMemories": ["60b8d6f1e1b9b1d8c6c0d8e1"] } headers = { 'X-Api-Key': '', 'Content-Type': 'application/json' } response = requests.post( 'https://api-integration.ollang.com/integration/orders/create', headers=headers, data=json.dumps(data) ) ``` ```php PHP theme={null} $data = array( 'orderType' => 'cc', 'level' => 1, 'projectId' => '60b8d6f1e1b9b1d8c6c0d8e1', 'targetLanguageConfigs' => array( array( 'language' => 'fr', 'isRush' => false ), array( 'language' => 'es', 'isRush' => true ) ), 'callbackUrl' => 'https://your-domain.com/webhooks/order-completed', 'autoQc' => true, 'selectedMemories' => array('60b8d6f1e1b9b1d8c6c0d8e1') ); $curl = curl_init(); curl_setopt_array($curl, array( CURLOPT_URL => 'https://api-integration.ollang.com/integration/orders/create', CURLOPT_RETURNTRANSFER => true, CURLOPT_POST => true, CURLOPT_HTTPHEADER => array( 'X-Api-Key: ', 'Content-Type: application/json' ), CURLOPT_POSTFIELDS => json_encode($data), )); $response = curl_exec($curl); curl_close($curl); ``` ```go Go theme={null} package main import ( "bytes" "encoding/json" "net/http" ) func main() { data := map[string]interface{}{ "orderType": "cc", "level": 1, "projectId": "60b8d6f1e1b9b1d8c6c0d8e1", "targetLanguageConfigs": []map[string]interface{}{ { "language": "fr", "isRush": false, }, { "language": "es", "isRush": true, }, }, "callbackUrl": "https://your-domain.com/webhooks/order-completed", "autoQc": true, "selectedMemories": []string{"60b8d6f1e1b9b1d8c6c0d8e1"}, } jsonData, _ := json.Marshal(data) req, _ := http.NewRequest("POST", "https://api-integration.ollang.com/integration/orders/create", bytes.NewBuffer(jsonData)) req.Header.Set("X-Api-Key", "") req.Header.Set("Content-Type", "application/json") client := &http.Client{} resp, _ := client.Do(req) } ``` ```java Java theme={null} import org.json.JSONArray; import org.json.JSONObject; JSONObject targetLang1 = new JSONObject(); targetLang1.put("language", "fr"); targetLang1.put("isRush", false); JSONObject targetLang2 = new JSONObject(); targetLang2.put("language", "es"); targetLang2.put("isRush", true); JSONArray targetLanguageConfigs = new JSONArray(); targetLanguageConfigs.put(targetLang1); targetLanguageConfigs.put(targetLang2); JSONObject requestBody = new JSONObject(); requestBody.put("orderType", "cc"); requestBody.put("level", 1); requestBody.put("projectId", "60b8d6f1e1b9b1d8c6c0d8e1"); requestBody.put("targetLanguageConfigs", targetLanguageConfigs); requestBody.put("callbackUrl", "https://your-domain.com/webhooks/order-completed"); requestBody.put("autoQc", true); HttpResponse response = Unirest.post("https://api-integration.ollang.com/integration/orders/create") .header("X-Api-Key", "") .header("Content-Type", "application/json") .body(requestBody.toString()) .asString(); ``` ## Authorizations This endpoint requires API key authentication. Include your API key in the request header: * **Header name**: `X-Api-Key` * **Header value**: Your API key from the Ollang dashboard * **Format**: `X-Api-Key: your-api-key-here` You can obtain your API key from your [Ollang dashboard](https://lab.ollang.com). ## Body Parameters Type of the order. Available options: - `cc` - Closed captions - `subtitle` - Subtitles - `aiDubbing` - AI Dubbing - `studioDubbing` - Studio-produced dubbing - `document` - Document translation (including Image to Image when the source is a JPEG, JPG, or PNG from Direct Upload) Service level for the order. Level 0 means full AI generated and Level 1 is Human Review added version. Unique identifier of the project this order belongs to. This should be a project ID from a previous video upload. Array of target language configurations. At least one target language configuration is required. ISO 639-1 language code (e.g., 'fr', 'es', 'de') Whether this language requires rush delivery Subtype of the order, specific to closed captions or transcription types. Must be one of: `closedCaption` or `timecodedTranscription`. Style of dubbing for audio orders. Must be one of: `overdub`, `lipsync`, or `audioDescription`. Optional URL to receive a `POST` request when the order completes. Must be a valid URL (`http` or `https`). The callback payload includes the completed order's translated content (documents, subtitle files, etc.) so you can process results immediately without a separate API call. See [Order completion callback](#order-completion-callback). When set to `true`, a QC evaluation will automatically run after the AI order completes. Defaults to `false`. Auto-QC only applies to top-level orders (child orders created as part of a parent order are excluded). Optional array of translation memory ids to apply to the created orders (maximum 20, no duplicates). Each id must be a memory owned by your account — get ids from [List Memories](/apis/ollang-api-reference/list-memories) or [Create Memory](/apis/ollang-api-reference/create-memory). Stored translation units are matched per target language at translation time. Only document, subtitle/cc, and Adobe AE orders consume memories; other order types ignore this field. ## Order completion callback When `callbackUrl` is provided, Ollang sends a `POST` request to that URL after the order reaches a completed state. The request uses `Content-Type: application/json` and has a **10-second timeout**. Callback failures do not affect the order itself. Implement idempotent handling and validate payloads on your side; you can always confirm status and outputs with [Get Order by ID](/apis/ollang-api-reference/get-order-by-id). ### Callback payload The callback `POST` body includes the completed order's translated content, matching the shape of the [Get Order by ID](/apis/ollang-api-reference/get-order-by-id) response: | Field | Type | Description | | - | - | - | | `orderId` | `string` | The unique identifier of the completed order. | | `status` | `string` | Always `"completed"`. | | `orderType` | `string` | The order type (e.g., `cc`, `subtitle`, `document`, `aiDubbing`). | | `targetLanguage` | `string` | Target language code (ISO 639-1). | | `completedAt` | `string` | Completion timestamp (ISO 8601). | | `orderDocs` | `array` | All documents associated with the order — source files, translated subtitles, embedded videos, dubbed audio, translated documents, images, etc. Each object includes `id`, `name`, `url`, `type`, `size`, `duration`, `wordCount`, `sourceLanguage`, `createdAt`, and `updatedAt`. | | `vttUrl` | `string` | Signed URL to download the VTT subtitle file (valid for 7 days). Empty string if not applicable to the order type. | ### Example callback payload ```json theme={null} { "orderId": "507f1f77bcf86cd799439015", "status": "completed", "orderType": "subtitle", "targetLanguage": "fr", "completedAt": "2024-01-16T14:20:00.000Z", "orderDocs": [ { "id": "doc_123abc", "name": "Source Video.mp4", "url": "https://example.com/videos/source.mp4", "type": "source_video", "size": 1073741824, "duration": 7200, "wordCount": null, "sourceLanguage": "en", "createdAt": "2024-01-15T10:30:00Z", "updatedAt": "2024-01-15T10:30:00Z" }, { "id": "doc_456def", "name": "French Subtitles.srt", "url": "https://example.com/subtitles/fr.srt", "type": "created_subtitle", "size": 8192, "duration": null, "wordCount": 1250, "sourceLanguage": "fr", "createdAt": "2024-01-16T14:20:00Z", "updatedAt": "2024-01-16T14:20:00Z" } ], "vttUrl": "https://example.com/subtitles/507f1f77bcf86cd799439015.vtt" } ``` ## Response The endpoint returns an **array** of created orders — one per `targetLanguageConfigs` entry. Each element is an object with a single `orderId` field. If you pass three target languages, you get three order IDs back in the same order you supplied them. Array of created orders. Each entry corresponds to one `targetLanguageConfigs` item, in the same order. Unique identifier of the created order. Use this with [Get Order by ID](/apis/ollang-api-reference/get-order-by-id), [Cancel Order](/apis/ollang-api-reference/cancel-order), or any other order-scoped endpoint. ```json 201 theme={null} [ { "orderId": "507f1f77bcf86cd799439015" }, { "orderId": "507f1f77bcf86cd799439016" } ] ``` ```json 400 theme={null} { "error": "Invalid order type", "message": "orderType must be one of: cc, subtitle, document, aiDubbing, studioDubbing", "code": "INVALID_ORDER_TYPE" } ``` ```json 404 theme={null} { "error": "Project not found", "message": "No project found with the provided projectId", "code": "PROJECT_NOT_FOUND" } ``` ```json 400 theme={null} { "error": "Invalid target language", "message": "At least one targetLanguageConfig is required", "code": "MISSING_TARGET_LANGUAGES" } ``` ```json 401 theme={null} { "error": "Unauthorized", "message": "Invalid or missing API key", "code": "UNAUTHORIZED" } ``` # Delete a Specific Revision Source: https://api-docs.ollang.com/apis/ollang-api-reference/delete-a-specific-revision DELETE https://api-integration.ollang.com/integration/revision/{orderId}/{revId} Delete a specific revision request that is no longer needed or was created in error Delete a specific revision request that is no longer needed or was created in error. This action is irreversible, so use it carefully to remove revision requests that are no longer relevant. ```bash cURL theme={null} curl -X DELETE "https://api-integration.ollang.com/integration/revision/60b8d6f1e1b9b1d8c6c0d8e1/rev_60b8d6f1e1b9b1d8c6c0d8e2" \ -H "X-Api-Key: " ``` ```javascript JavaScript theme={null} const orderId = "60b8d6f1e1b9b1d8c6c0d8e1"; const revisionId = "rev_60b8d6f1e1b9b1d8c6c0d8e2"; const response = await fetch( `https://api-integration.ollang.com/integration/revision/${orderId}/${revisionId}`, { method: "DELETE", headers: { "X-Api-Key": "", }, } ); if (response.status === 204) { console.log("Revision deleted successfully"); } ``` ```python Python theme={null} import requests order_id = "60b8d6f1e1b9b1d8c6c0d8e1" revision_id = "rev_60b8d6f1e1b9b1d8c6c0d8e2" headers = { 'X-Api-Key': '' } response = requests.delete( f'https://api-integration.ollang.com/integration/revision/{order_id}/{revision_id}', headers=headers ) if response.status_code == 204: print("Revision deleted successfully") ``` ```php PHP theme={null} $orderId = '60b8d6f1e1b9b1d8c6c0d8e1'; $revisionId = 'rev_60b8d6f1e1b9b1d8c6c0d8e2'; $curl = curl_init(); curl_setopt_array($curl, array( CURLOPT_URL => 'https://api-integration.ollang.com/integration/revision/' . $orderId . '/' . $revisionId, CURLOPT_RETURNTRANSFER => true, CURLOPT_CUSTOMREQUEST => 'DELETE', CURLOPT_HTTPHEADER => array( 'X-Api-Key: ' ), )); $response = curl_exec($curl); $httpCode = curl_getinfo($curl, CURLINFO_HTTP_CODE); curl_close($curl); if ($httpCode === 204) { echo "Revision deleted successfully"; } ``` ```go Go theme={null} package main import ( "fmt" "net/http" ) func main() { orderId := "60b8d6f1e1b9b1d8c6c0d8e1" revisionId := "rev_60b8d6f1e1b9b1d8c6c0d8e2" url := fmt.Sprintf("https://api-integration.ollang.com/integration/revision/%s/%s", orderId, revisionId) req, _ := http.NewRequest("DELETE", url, nil) req.Header.Set("X-Api-Key", "") client := &http.Client{} resp, _ := client.Do(req) if resp.StatusCode == 204 { fmt.Println("Revision deleted successfully") } } ``` ```java Java theme={null} String orderId = "60b8d6f1e1b9b1d8c6c0d8e1"; String revisionId = "rev_60b8d6f1e1b9b1d8c6c0d8e2"; HttpResponse response = Unirest.delete("https://api-integration.ollang.com/integration/revision/" + orderId + "/" + revisionId) .header("X-Api-Key", "") .asString(); if (response.getStatus() == 204) { System.out.println("Revision deleted successfully"); } ``` ## Authorizations This endpoint requires API key authentication. Include your API key in the request header: * **Header name**: `X-Api-Key` * **Header value**: Your API key from the Ollang dashboard * **Format**: `X-Api-Key: your-api-key-here` You can obtain your API key from your [Ollang dashboard](https://lab.ollang.com). ## Path Parameters The unique identifier of the order that contains the revision you want to delete. This should be a valid order ID that you have access to. The unique identifier of the specific revision request you want to delete. This should be a valid revision ID that belongs to the specified order. ## Response This endpoint returns no content on successful deletion (HTTP 204 status code). The absence of an error response indicates that the revision was successfully deleted. ```json 204 theme={null} No content - Revision deleted successfully ``` ```json 404 theme={null} { "error": "Revision not found", "message": "No revision found with the provided revisionId for the specified order", "code": "REVISION_NOT_FOUND" } ``` ```json 404 theme={null} { "error": "Order not found", "message": "No order found with the provided orderId", "code": "ORDER_NOT_FOUND" } ``` ```json 403 theme={null} { "error": "Access denied", "message": "You don't have permission to delete revisions for this order", "code": "ACCESS_DENIED" } ``` ```json 401 theme={null} { "error": "Unauthorized", "message": "Invalid or missing API key", "code": "UNAUTHORIZED" } ``` ```json 400 theme={null} { "error": "Invalid revision", "message": "The revision does not belong to the specified order", "code": "REVISION_ORDER_MISMATCH" } ``` # Delete Custom Instruction Source: https://api-docs.ollang.com/apis/ollang-api-reference/delete-custom-instruction DELETE https://api-integration.ollang.com/integration/custom-instructions/{instructionId} Permanently remove a custom translation instruction Delete a custom instruction by ID. This cannot be undone. ```bash cURL theme={null} curl -X DELETE "https://api-integration.ollang.com/integration/custom-instructions/507f1f77bcf86cd799439011" \ -H "X-Api-Key: " ``` ```javascript JavaScript theme={null} const instructionId = "507f1f77bcf86cd799439011"; await fetch( `https://api-integration.ollang.com/integration/custom-instructions/${instructionId}`, { method: "DELETE", headers: { "X-Api-Key": "", }, } ); ``` ```python Python theme={null} import requests instruction_id = "507f1f77bcf86cd799439011" headers = {"X-Api-Key": ""} requests.delete( f"https://api-integration.ollang.com/integration/custom-instructions/{instruction_id}", headers=headers, ) ``` ## Authorizations This endpoint requires API key authentication. * **Header name**: `X-Api-Key` * **Header value**: Your API key from the [Ollang dashboard](https://lab.ollang.com) ## Path Parameters The custom instruction’s unique identifier. ## Response A successful delete returns **204 No Content** with an empty body. ```text 204 theme={null} ``` ```json 404 theme={null} { "statusCode": 404, "message": "Custom instruction not found" } ``` ```json 401 theme={null} { "error": "Unauthorized", "message": "Invalid or missing API key" } ``` # Remove Folder Document Source: https://api-docs.ollang.com/apis/ollang-api-reference/delete-folder-document DELETE https://api-integration.ollang.com/integration/folder/{folderId}/docs/{docId} Detach a guideline, glossary, or character list from a folder and from the projects it was applied to Removes a folder-level document from a folder. The copies that were applied to projects inside the folder are removed with it, so no project keeps a guideline the folder no longer has. Orders created before the removal keep the guidance they were already processed with. The removal affects work that runs after it. ```bash cURL theme={null} curl -X DELETE "https://api-integration.ollang.com/integration/folder/60b8d6f1e1b9b1d8c6c0d8e1/docs/60b8d6f1e1b9b1d8c6c0d8f1" \ -H "X-Api-Key: " ``` ```javascript JavaScript theme={null} const folderId = "60b8d6f1e1b9b1d8c6c0d8e1"; const docId = "60b8d6f1e1b9b1d8c6c0d8f1"; await fetch( `https://api-integration.ollang.com/integration/folder/${folderId}/docs/${docId}`, { method: "DELETE", headers: { "X-Api-Key": "", }, }, ); ``` ```python Python theme={null} import requests folder_id = "60b8d6f1e1b9b1d8c6c0d8e1" doc_id = "60b8d6f1e1b9b1d8c6c0d8f1" requests.delete( f"https://api-integration.ollang.com/integration/folder/{folder_id}/docs/{doc_id}", headers={"X-Api-Key": ""}, ) ``` ```php PHP theme={null} $folderId = '60b8d6f1e1b9b1d8c6c0d8e1'; $docId = '60b8d6f1e1b9b1d8c6c0d8f1'; $curl = curl_init(); curl_setopt_array($curl, array( CURLOPT_URL => "https://api-integration.ollang.com/integration/folder/{$folderId}/docs/{$docId}", CURLOPT_RETURNTRANSFER => true, CURLOPT_CUSTOMREQUEST => 'DELETE', CURLOPT_HTTPHEADER => array( 'X-Api-Key: ' ), )); curl_exec($curl); curl_close($curl); ``` ```go Go theme={null} package main import ( "net/http" ) func main() { folderID := "60b8d6f1e1b9b1d8c6c0d8e1" docID := "60b8d6f1e1b9b1d8c6c0d8f1" url := "https://api-integration.ollang.com/integration/folder/" + folderID + "/docs/" + docID req, _ := http.NewRequest("DELETE", url, nil) req.Header.Set("X-Api-Key", "") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() } ``` ```java Java theme={null} String folderId = "60b8d6f1e1b9b1d8c6c0d8e1"; String docId = "60b8d6f1e1b9b1d8c6c0d8f1"; Unirest .delete("https://api-integration.ollang.com/integration/folder/" + folderId + "/docs/" + docId) .header("X-Api-Key", "") .asString(); ``` ## Authorizations This endpoint requires API key authentication. Include your API key in the request header: * **Header name**: `X-Api-Key` * **Header value**: Your API key from the Ollang dashboard * **Format**: `X-Api-Key: your-api-key-here` The API key user needs write access to the folder. Keys without a folder-write role receive a `403`. ## Path Parameters The unique identifier of the folder the document belongs to. The unique identifier of the folder document. Retrieve document IDs with [List Folder Documents](/apis/ollang-api-reference/list-folder-documents). ## Response Returns an empty body on success. ```json 200 theme={null} {} ``` ```json 401 theme={null} { "error": "Unauthorized", "message": "Invalid or missing API key", "code": "UNAUTHORIZED" } ``` ```json 403 theme={null} { "statusCode": 403, "message": "You do not have permission to modify this folder", "error": "Forbidden" } ``` ```json 404 theme={null} { "statusCode": 404, "message": "Folder document not found", "error": "Not Found" } ``` # Delete Memory Source: https://api-docs.ollang.com/apis/ollang-api-reference/delete-memory DELETE https://api-integration.ollang.com/integration/memories/{memoryId} Permanently remove a translation memory Delete a translation memory by ID, along with its stored translation units. This cannot be undone. Orders that reference the memory via `selectedMemories` will no longer receive matches from it. ```bash cURL theme={null} curl -X DELETE "https://api-integration.ollang.com/integration/memories/507f1f77bcf86cd799439011" \ -H "X-Api-Key: " ``` ```javascript JavaScript theme={null} const memoryId = "507f1f77bcf86cd799439011"; await fetch( `https://api-integration.ollang.com/integration/memories/${memoryId}`, { method: "DELETE", headers: { "X-Api-Key": "", }, } ); ``` ```python Python theme={null} import requests memory_id = "507f1f77bcf86cd799439011" headers = {"X-Api-Key": ""} requests.delete( f"https://api-integration.ollang.com/integration/memories/{memory_id}", headers=headers, ) ``` ## Authorizations This endpoint requires API key authentication. * **Header name**: `X-Api-Key` * **Header value**: Your API key from the [Ollang dashboard](https://lab.ollang.com) ## Path Parameters The translation memory's unique identifier. ## Response A successful delete returns **204 No Content** with an empty body. ```text 204 theme={null} ``` ```json 404 theme={null} { "statusCode": 404, "message": "Memory not found" } ``` ```json 401 theme={null} { "error": "Unauthorized", "message": "Invalid or missing API key" } ``` # Direct File Upload Source: https://api-docs.ollang.com/apis/ollang-api-reference/direct-file-upload POST https://api-integration.ollang.com/integration/upload/direct Upload files directly to the platform for processing and translation services. Supports multiple file formats including MP4, MP3, DOCX, PDF, JPEG, PNG for Image to Image translation, and more Upload files directly to the platform by calling this endpoint to process your content for translation and transcription services. This endpoint accepts a wide variety of file formats including: * **Video files**: MP4, AVI, MOV, WMV * **Audio files**: MP3, WAV, AAC, M4A * **Document files**: DOCX, PDF, TXT, RTF * **Vector graphics**: SVG (translated as a document: the text changes in place and you get an SVG back with its paths and styles intact) * **Presentation files**: PPTX, PPT * **Spreadsheet files**: XLSX, XLS * **Image to Image translation**: JPEG, JPG, PNG (direct upload for image-based translation) * **And many more formats** All uploaded files can be processed for translation into your target language. For **Image to Image** translation, use Direct Upload with a JPEG, JPG, or PNG file, then create a document order as usual. ```bash cURL theme={null} curl -X POST "https://api-integration.ollang.com/integration/upload/direct" \ -H "X-Api-Key: " \ -H "Content-Type: multipart/form-data" \ -F "file=@/path/to/your/document.pdf" \ -F "name=contract_document" \ -F "sourceLanguage=en" \ -F "folderId=60b8d6f1e1b9b1d8c6c0d8e2" ``` ```javascript JavaScript theme={null} const formData = new FormData(); formData.append("file", fileToUpload); // Can be any supported file type formData.append("name", "contract_document"); formData.append("sourceLanguage", "en"); formData.append("folderId", "60b8d6f1e1b9b1d8c6c0d8e2"); const response = await fetch( "https://api-integration.ollang.com/integration/upload/direct", { method: "POST", headers: { "X-Api-Key": "", }, body: formData, }, ); ``` ```python Python theme={null} import requests files = {'file': open('path/to/your/document.pdf', 'rb')} # Any supported file type data = { 'name': 'contract_document', 'sourceLanguage': 'en', 'folderId': '60b8d6f1e1b9b1d8c6c0d8e2' } headers = {'X-Api-Key': ''} response = requests.post( 'https://api-integration.ollang.com/integration/upload/direct', files=files, data=data, headers=headers ) ``` ```php PHP theme={null} $curl = curl_init(); curl_setopt_array($curl, array( CURLOPT_URL => 'https://api-integration.ollang.com/integration/upload/direct', CURLOPT_RETURNTRANSFER => true, CURLOPT_POST => true, CURLOPT_HTTPHEADER => array( 'X-Api-Key: ' ), CURLOPT_POSTFIELDS => array( 'file' => new CURLFile('path/to/your/document.pdf'), // Any supported file type 'name' => 'contract_document', 'sourceLanguage' => 'en', 'folderId' => '60b8d6f1e1b9b1d8c6c0d8e2' ), )); $response = curl_exec($curl); curl_close($curl); ``` ```go Go theme={null} package main import ( "bytes" "io" "mime/multipart" "net/http" "os" ) func main() { file, _ := os.Open("path/to/your/document.pdf") // Any supported file type defer file.Close() body := &bytes.Buffer{} writer := multipart.NewWriter(body) part, _ := writer.CreateFormFile("file", "document.pdf") io.Copy(part, file) writer.WriteField("name", "contract_document") writer.WriteField("sourceLanguage", "en") writer.WriteField("folderId", "60b8d6f1e1b9b1d8c6c0d8e2") writer.Close() req, _ := http.NewRequest("POST", "https://api-integration.ollang.com/integration/upload/direct", body) req.Header.Set("X-Api-Key", "") req.Header.Set("Content-Type", writer.FormDataContentType()) client := &http.Client{} resp, _ := client.Do(req) } ``` ```java Java theme={null} HttpResponse response = Unirest.post("https://api-integration.ollang.com/integration/upload/direct") .header("X-Api-Key", "") .field("file", new File("path/to/your/document.pdf")) // Any supported file type .field("name", "contract_document") .field("sourceLanguage", "en") .field("folderId", "60b8d6f1e1b9b1d8c6c0d8e2") .asString(); ``` ## Authorizations This endpoint requires API key authentication. Include your API key in the request header: * **Header name**: `X-Api-Key` * **Header value**: Your API key from the Ollang dashboard * **Format**: `X-Api-Key: your-api-key-here` You can obtain your API key from your [Ollang dashboard](https://lab.ollang.com). ## The multipart filename matters The stored file's extension comes from the `filename` of the multipart `file` part, not from the `name` field. A part sent without a filename is rejected with `400 Unsupported file type`, as is one whose extension the platform cannot process — before the project is created, so a rejected upload leaves nothing behind. Most HTTP clients set the filename from the file you hand them (`curl -F file=@video.mp4`, Python's `open(...)`, a JavaScript `File`). The exception is a bare `Blob` in JavaScript, which has no name of its own — `FormData` then defaults the filename to `blob`. Name it explicitly: ```javascript theme={null} const formData = new FormData(); formData.append("file", new Blob([bytes]), "en.json"); formData.append("name", "App strings"); formData.append("sourceLanguage", "en"); ``` The three-argument `append` requires a `Blob`, so wrap raw bytes rather than passing a `Buffer` or `Uint8Array` straight in — those throw `TypeError: parameter 2 is not of type 'Blob'`. A `File` carries the name itself, but it is only a global from Node 20 onwards. ## Body Parameters The file to upload for translation. Supports a wide range of file formats including: **Video formats**: MP4, AVI, MOV, WMV, FLV, MKV **Audio formats**: MP3, WAV, AAC, M4A, FLAC, OGG **Document formats**: DOCX, DOC, PDF, TXT, RTF, ODT **Presentation formats**: PPTX, PPT, ODP **Spreadsheet formats**: XLSX, XLS, ODS, CSV **Image formats (Image to Image translation)**: JPEG, JPG, PNG **Other formats**: HTML, XML, SVG, JSON, SRT, VTT, IDML, DITA, DITAMAP, DITAVAL Maximum file size: 30GB for video files, 100MB for document files. **Note: For testing in the API playground, the upload limit is 5MB.** Name of the file being uploaded. This will be used as the identifier for your uploaded content. Should be descriptive and unique for easy identification. It does not need an extension: the uploaded file's extension is appended to it unless `name` already ends in that same extension. The source language of the file content. Use standard language codes such as: * 'en' for English - 'es' for Spanish - 'fr' for French - 'de' for German - 'zh' for Chinese - 'ja' for Japanese - 'tr' for Turkish - And many more supported languages Array of order notes for additional instructions or information about the upload. Each entry is an order note object. Example: `[{"details": "Please ignore the subtitles for 30 seconds", "timeStamp": "02:15:30"}]` Note content (e.g., "Preserve formatting", "Technical document", "Marketing content"). Optional timestamp for the note when the content is a video or audio file, in `HH:MM:SS` format (e.g., "02:15:30"). Optional folder ID to place the project in. The folder must belong to the same client account. If not provided, the project will be placed in the default "API Uploads" folder. You can retrieve available folder IDs using the [Retrieve All Folders](/apis/ollang-api-reference/retrieve-all-folders) endpoint. Any folder-level documents on the target folder — guidelines, glossaries, and character lists — are applied to the new project automatically, the same way they are for projects created in the dashboard. See [Attach Folder Document](/apis/ollang-api-reference/attach-folder-document). ## Response Unique identifier for the project associated with the uploaded file. Use this ID to create, track, and manage your uploaded content throughout the translation process. ```json 201 theme={null} { "projectId": "60b8d6f1e1b9b1d8c6c0d8e1" } ``` ```json 400 theme={null} { "code": 40001, "error": "UnsupportedFileTypeException", "message": "Unsupported file type", "data": "{\"filename\":\"blob\",\"reason\":\"The uploaded file has no extension. Send the file under its real name.\"}" } ``` ```json 413 theme={null} { "error": "File too large", "message": "File exceeds maximum size limit. Video files: 30GB max, Document files: 100MB max", "code": "FILE_TOO_LARGE" } ``` ```json 401 theme={null} { "error": "Unauthorized", "message": "Invalid or missing API key", "code": "UNAUTHORIZED" } ``` # Export Content Source: https://api-docs.ollang.com/apis/ollang-api-reference/export-content GET https://api-integration.ollang.com/integration/content/export Export your content translations as JSON, filtered by language, tags, and orders Export all content translations for your account. You can filter by target language(s), tag(s), and order ID(s). Single-language exports return a flat key-value map; multi-language exports return a map grouped by language code. ```bash cURL (single language) theme={null} curl -X GET "https://api-integration.ollang.com/integration/content/export?targetLanguage=tr" \ -H "X-Api-Key: " ``` ```bash cURL (multiple languages, bracket syntax) theme={null} curl -X GET "https://api-integration.ollang.com/integration/content/export?targetLanguages[]=tr&targetLanguages[]=en" \ -H "X-Api-Key: " ``` ```bash cURL (multiple languages, repeated-key syntax) theme={null} curl -X GET "https://api-integration.ollang.com/integration/content/export?targetLanguages=tr&targetLanguages=en" \ -H "X-Api-Key: " ``` ```bash cURL (with tag and order filter) theme={null} curl -X GET "https://api-integration.ollang.com/integration/content/export?targetLanguage=tr&tags[]=ui&orderIds[]=60b8d6f1e1b9b1d8c6c0d8e1" \ -H "X-Api-Key: " ``` ```javascript JavaScript theme={null} const params = new URLSearchParams(); params.append("targetLanguages[]", "tr"); params.append("targetLanguages[]", "en"); params.append("tags[]", "ui"); const response = await fetch( `https://api-integration.ollang.com/integration/content/export?${params}`, { method: "GET", headers: { "X-Api-Key": "", }, }, ); const data = await response.json(); ``` ```python Python theme={null} import requests params = { "targetLanguages[]": ["tr", "en"], "tags[]": ["ui"], } response = requests.get( "https://api-integration.ollang.com/integration/content/export", params=params, headers={"X-Api-Key": ""}, ) data = response.json() ``` ## Authorizations This endpoint requires API key authentication. Include your API key in the request header: * **Header name**: `X-Api-Key` * **Header value**: Your API key from the Ollang dashboard ## Query Parameters Filter by a single target language code (e.g., `tr`). Use `targetLanguages` for multi-language export. Do not send both `targetLanguage` and `targetLanguages` in the same request — pick one. Filter by one or more target language codes. When multiple languages are provided, the response is grouped by language. Two syntaxes are accepted and treated equivalently: * Bracket form: `?targetLanguages[]=tr&targetLanguages[]=en` * Repeated-key form: `?targetLanguages=tr&targetLanguages=en` A single value (`?targetLanguages=tr`) is also accepted and is coerced into a one-element array. Filter by a single tag. Filter by one or more tags. Returns content terms that have at least one of the specified tags. Accepts both `?tags[]=ui&tags[]=marketing` and `?tags=ui&tags=marketing`. Filter by one or more order IDs. Only content terms associated with the specified orders will be included. Accepts both `?orderIds[]=a&orderIds[]=b` and `?orderIds=a&orderIds=b`. ## Response The response format depends on how many languages are requested: **Single language** — flat key-value map where keys are source texts and values are translations: ```json theme={null} { "Good morning": "Günaydın", "Sign in": "Giriş Yap", "Dashboard": "Pano" } ``` **Multiple languages** — map keyed by language code, each containing a flat key-value map: ```json theme={null} { "tr": { "Good morning": "Günaydın", "Sign in": "Giriş Yap" }, "en": { "Good morning": "Good morning", "Sign in": "Sign in" } } ``` ```json 200 (single language) theme={null} { "Good morning": "Günaydın", "Sign in": "Giriş Yap", "Dashboard": "Pano", "Settings": "Ayarlar" } ``` ```json 200 (multiple languages) theme={null} { "tr": { "Good morning": "Günaydın", "Sign in": "Giriş Yap" }, "es": { "Good morning": "Buenos días", "Sign in": "Iniciar sesión" } } ``` ```json 200 (empty - no matching content) theme={null} {} ``` ```json 400 theme={null} { "statusCode": 400, "message": [ "each value in targetLanguages must be a string" ], "error": "Bad Request" } ``` ```json 401 theme={null} { "error": "Unauthorized", "message": "Invalid or missing API key", "code": "UNAUTHORIZED" } ``` # Export Order XLSX Source: https://api-docs.ollang.com/apis/ollang-api-reference/export-order-xlsx GET https://api-integration.ollang.com/integration/orders/{orderId}/export-xlsx Export video timestamps, transcriptions, and translations for a single order as an XLSX spreadsheet Returns an XLSX spreadsheet containing segment data (timecodes, source transcription, translated text) for the given order. The target language is resolved automatically from the order. The spreadsheet contains the following columns: | Column | Description | | - | - | | SR NO | Sequential row number | | TCR | Timecode (start timestamp) | | SPEAKER | Speaker name | | DIALOGUES | Source transcription text | | *Target Language* | Translated text (column header is the target language code) | ```bash cURL theme={null} curl -X GET "https://api-integration.ollang.com/integration/orders/60b8d6f1e1b9b1d8c6c0d8e1/export-xlsx" \ -H "X-Api-Key: " \ --output order_export.xlsx ``` ```javascript JavaScript theme={null} const orderId = "60b8d6f1e1b9b1d8c6c0d8e1"; const response = await fetch( `https://api-integration.ollang.com/integration/orders/${orderId}/export-xlsx`, { method: "GET", headers: { "X-Api-Key": "", }, }, ); const blob = await response.blob(); const url = URL.createObjectURL(blob); // Download or process the XLSX file ``` ```python Python theme={null} import requests order_id = "60b8d6f1e1b9b1d8c6c0d8e1" response = requests.get( f"https://api-integration.ollang.com/integration/orders/{order_id}/export-xlsx", headers={"X-Api-Key": ""}, ) with open("order_export.xlsx", "wb") as f: f.write(response.content) ``` ## Authorizations This endpoint requires API key authentication. Include your API key in the request header: * **Header name**: `X-Api-Key` * **Header value**: Your API key from the Ollang dashboard ## Path Parameters The unique identifier of the order to export. ## Response The response is a binary XLSX file download. The response headers include: * `Content-Type: application/vnd.openxmlformats-officedocument.spreadsheetml.sheet` * `Content-Disposition: attachment; filename="{OrderName}_{targetLanguage}.xlsx"` ```text 200 theme={null} Binary XLSX file (spreadsheet with segment data) ``` ```json 401 theme={null} { "error": "Unauthorized", "message": "Invalid or missing API key", "code": "UNAUTHORIZED" } ``` ```json 500 theme={null} { "statusCode": 500, "message": "No segment data found for order 60b8d6f1e1b9b1d8c6c0d8e1 with target language tr." } ``` # Create Figma Order Source: https://api-docs.ollang.com/apis/ollang-api-reference/figma-create-order POST https://api-integration.ollang.com/integration/orders/figma/create Import a Figma file and create translation orders in one step Import a Figma design file and create AI translation orders for one or more target languages. This endpoint handles the full pipeline: importing text layers from Figma, creating/reusing the project, and triggering translation for each target language. The Figma file is always re-imported to capture the latest design state. If a project already exists for this file, it will be reused. ```bash cURL theme={null} curl -X POST "https://api-integration.ollang.com/integration/orders/figma/create" \ -H "X-Api-Key: " \ -H "Content-Type: application/json" \ -d '{ "fileKey": "UwNAtPYAu5JPIhFc03M71h", "fileUrl": "https://www.figma.com/design/UwNAtPYAu5JPIhFc03M71h/My-Design", "sourceLanguage": "en", "targetLanguages": ["fr", "de", "tr"] }' ``` ```javascript JavaScript theme={null} const response = await fetch( "https://api-integration.ollang.com/integration/orders/figma/create", { method: "POST", headers: { "X-Api-Key": "", "Content-Type": "application/json", }, body: JSON.stringify({ fileKey: "UwNAtPYAu5JPIhFc03M71h", fileUrl: "https://www.figma.com/design/UwNAtPYAu5JPIhFc03M71h/My-Design", sourceLanguage: "en", targetLanguages: ["fr", "de", "tr"], }), } ); const result = await response.json(); console.log(result.orders); // [{orderId, targetLanguage, status}] ``` ```python Python theme={null} import requests headers = { 'X-Api-Key': '', 'Content-Type': 'application/json' } payload = { 'fileKey': 'UwNAtPYAu5JPIhFc03M71h', 'fileUrl': 'https://www.figma.com/design/UwNAtPYAu5JPIhFc03M71h/My-Design', 'sourceLanguage': 'en', 'targetLanguages': ['fr', 'de', 'tr'] } response = requests.post( 'https://api-integration.ollang.com/integration/orders/figma/create', headers=headers, json=payload ) result = response.json() print(result['orders']) ``` ## Authorizations This endpoint requires API key authentication. Include your API key in the request header: * **Header name**: `X-Api-Key` * **Header value**: Your API key from the Ollang dashboard ## Prerequisites Your Figma account must be connected to Ollang via OAuth before using this endpoint. Connect your Figma account from the [Ollang dashboard](https://lab.ollang.com) under Settings → Integrations → Figma. ## Body Parameters The Figma file key. This is the identifier in the Figma URL between `/design/` and the file name. Example: For `https://www.figma.com/design/UwNAtPYAu5JPIhFc03M71h/My-Design`, the file key is `UwNAtPYAu5JPIhFc03M71h`. The full Figma file URL. Must contain `figma.com`. The source language code of the design content (e.g., `en`, `fr`, `de`). Array of target language codes to translate into. At least one is required. Optional folder ID to organize the project in. If not provided, a default folder is used. ## Response The ID of the created or reused project. The ID of the Figma import record containing extracted text layers. Array of created orders, one per target language. The unique order identifier. The target language code for this order. Initial order status (`ongoing`). ## Error Responses | Status | Description | | - | - | | 400 | Figma account not connected, or missing/invalid parameters | | 409 | An active order for a target language already exists in this project | | 422 | Figma file import failed (API error or access issue) | ```json 201 theme={null} { "projectId": "60b8d6f1e1b9b1d8c6c0d8e1", "importId": "60b8d6f1e1b9b1d8c6c0d8e2", "orders": [ { "orderId": "60b8d6f1e1b9b1d8c6c0d8e3", "targetLanguage": "fr", "status": "ongoing" }, { "orderId": "60b8d6f1e1b9b1d8c6c0d8e4", "targetLanguage": "de", "status": "ongoing" }, { "orderId": "60b8d6f1e1b9b1d8c6c0d8e5", "targetLanguage": "tr", "status": "ongoing" } ] } ``` ```json 400 theme={null} { "statusCode": 400, "message": "Figma account not connected. Please connect your Figma account in the Ollang dashboard first." } ``` ```json 409 theme={null} { "statusCode": 409, "message": "An active order for \"fr\" already exists in this project. Wait for it to complete or cancel it before creating a new one." } ``` # Get Figma Orders Source: https://api-docs.ollang.com/apis/ollang-api-reference/figma-get-orders GET https://api-integration.ollang.com/integration/orders/figma List all translation orders for a Figma file Retrieve all translation orders associated with a specific Figma file. Orders are returned sorted by creation date (newest first) and include review info when an order is at a review gate. ```bash cURL theme={null} curl -X GET "https://api-integration.ollang.com/integration/orders/figma?fileKey=UwNAtPYAu5JPIhFc03M71h" \ -H "X-Api-Key: " ``` ```javascript JavaScript theme={null} const fileKey = "UwNAtPYAu5JPIhFc03M71h"; const response = await fetch( `https://api-integration.ollang.com/integration/orders/figma?fileKey=${fileKey}`, { headers: { "X-Api-Key": "", }, } ); const orders = await response.json(); console.log(orders); ``` ```python Python theme={null} import requests headers = { 'X-Api-Key': '' } response = requests.get( 'https://api-integration.ollang.com/integration/orders/figma', headers=headers, params={'fileKey': 'UwNAtPYAu5JPIhFc03M71h'} ) orders = response.json() print(orders) ``` ## Authorizations This endpoint requires API key authentication. Include your API key in the request header: * **Header name**: `X-Api-Key` * **Header value**: Your API key from the Ollang dashboard ## Query Parameters The Figma file key to look up orders for. Only orders whose project contains a document with this file key will be returned. ## Response Returns an array of order objects. The unique order identifier. Current order status: `ongoing`, `review`, `waitingForApprove`, `completed`, `delivered`, `pending`, `revision`. The target language code for this order. ISO 8601 timestamp of when the order was created. The display name of the order. Present when the order is currently at a review gate. `null` otherwise. Name of the team responsible for the review. Hex color of the team tag (e.g., `#FF5733`). May be null. Type of review: `assignment` or `comment`. ```json 200 theme={null} [ { "id": "60b8d6f1e1b9b1d8c6c0d8e3", "status": "completed", "targetLanguage": "fr", "createdAt": "2026-08-19T10:30:00.000Z", "orderName": "My Design → FR", "reviewInfo": null }, { "id": "60b8d6f1e1b9b1d8c6c0d8e4", "status": "review", "targetLanguage": "de", "createdAt": "2026-08-19T10:30:00.000Z", "orderName": "My Design → DE", "reviewInfo": { "teamTagName": "Medical Review", "teamTagColor": "#FF5733", "reviewType": "assignment" } }, { "id": "60b8d6f1e1b9b1d8c6c0d8e5", "status": "ongoing", "targetLanguage": "tr", "createdAt": "2026-08-19T10:30:00.000Z", "orderName": "My Design → TR", "reviewInfo": null } ] ``` ```json 200 (empty) theme={null} [] ``` # Get Figma Order Status Source: https://api-docs.ollang.com/apis/ollang-api-reference/figma-order-status GET https://api-integration.ollang.com/integration/orders/figma/{orderId}/status Get the current status of a Figma translation order including review info Retrieve the current status of a specific Figma translation order. When the order is at a review gate, additional information about the reviewing team is included. ```bash cURL theme={null} curl -X GET "https://api-integration.ollang.com/integration/orders/figma/60b8d6f1e1b9b1d8c6c0d8e3/status" \ -H "X-Api-Key: " ``` ```javascript JavaScript theme={null} const orderId = "60b8d6f1e1b9b1d8c6c0d8e3"; const response = await fetch( `https://api-integration.ollang.com/integration/orders/figma/${orderId}/status`, { headers: { "X-Api-Key": "", }, } ); const status = await response.json(); console.log(status); ``` ```python Python theme={null} import requests order_id = "60b8d6f1e1b9b1d8c6c0d8e3" headers = { 'X-Api-Key': '' } response = requests.get( f'https://api-integration.ollang.com/integration/orders/figma/{order_id}/status', headers=headers ) status = response.json() print(status) ``` ## Authorizations This endpoint requires API key authentication. Include your API key in the request header: * **Header name**: `X-Api-Key` * **Header value**: Your API key from the Ollang dashboard ## Path Parameters The unique identifier of the order. ## Response The unique order identifier. Current order status: `ongoing`, `review`, `waitingForApprove`, `completed`, `delivered`, `pending`, `revision`. The target language code for this order. ISO 8601 timestamp of when the order was created. ISO 8601 timestamp of when the order was completed/delivered. `null` if not yet completed. The display name of the order. Present when the order is currently at a review gate. `null` otherwise. Name of the team responsible for the review. Hex color of the team tag. May be null. Type of review: `assignment` or `comment`. ```json 200 (ongoing) theme={null} { "id": "60b8d6f1e1b9b1d8c6c0d8e3", "status": "ongoing", "targetLanguage": "fr", "createdAt": "2026-08-19T10:30:00.000Z", "completedAt": null, "orderName": "My Design → FR", "reviewInfo": null } ``` ```json 200 (in review) theme={null} { "id": "60b8d6f1e1b9b1d8c6c0d8e4", "status": "review", "targetLanguage": "de", "createdAt": "2026-08-19T10:30:00.000Z", "completedAt": null, "orderName": "My Design → DE", "reviewInfo": { "teamTagName": "Medical Review", "teamTagColor": "#FF5733", "reviewType": "assignment" } } ``` ```json 200 (completed) theme={null} { "id": "60b8d6f1e1b9b1d8c6c0d8e5", "status": "completed", "targetLanguage": "tr", "createdAt": "2026-08-19T10:30:00.000Z", "completedAt": "2026-08-19T11:45:00.000Z", "orderName": "My Design → TR", "reviewInfo": null } ``` ```json 404 theme={null} { "statusCode": 404, "message": "Order not found" } ``` # Get All Revisions for an Order Source: https://api-docs.ollang.com/apis/ollang-api-reference/get-all-revision-for-an-order GET https://api-integration.ollang.com/integration/revision/{orderId} Retrieve all revision requests created for a specific order Retrieve all revision requests that have been created for a specific order. This endpoint provides a complete history of issues reported and changes requested for the order's delivered content. ```bash cURL theme={null} curl -X GET "https://api-integration.ollang.com/integration/revision/60b8d6f1e1b9b1d8c6c0d8e1" \ -H "X-Api-Key: " ``` ```javascript JavaScript theme={null} const orderId = "60b8d6f1e1b9b1d8c6c0d8e1"; const response = await fetch( `https://api-integration.ollang.com/integration/revision/${orderId}`, { method: "GET", headers: { "X-Api-Key": "", }, } ); const revisions = await response.json(); console.log(`Found ${revisions.length} revisions for order ${orderId}`); ``` ```python Python theme={null} import requests order_id = "60b8d6f1e1b9b1d8c6c0d8e1" headers = { 'X-Api-Key': '' } response = requests.get( f'https://api-integration.ollang.com/integration/revision/{order_id}', headers=headers ) revisions = response.json() print(f"Found {len(revisions)} revisions for order {order_id}") ``` ```php PHP theme={null} $orderId = '60b8d6f1e1b9b1d8c6c0d8e1'; $curl = curl_init(); curl_setopt_array($curl, array( CURLOPT_URL => 'https://api-integration.ollang.com/integration/revision/' . $orderId, CURLOPT_RETURNTRANSFER => true, CURLOPT_HTTPHEADER => array( 'X-Api-Key: ' ), )); $response = curl_exec($curl); curl_close($curl); $revisions = json_decode($response, true); echo "Found " . count($revisions) . " revisions for order " . $orderId; ``` ```go Go theme={null} package main import ( "encoding/json" "fmt" "net/http" ) func main() { orderId := "60b8d6f1e1b9b1d8c6c0d8e1" url := fmt.Sprintf("https://api-integration.ollang.com/integration/revision/%s", orderId) req, _ := http.NewRequest("GET", url, nil) req.Header.Set("X-Api-Key", "") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() var revisions []map[string]interface{} json.NewDecoder(resp.Body).Decode(&revisions) fmt.Printf("Found %d revisions for order %s\n", len(revisions), orderId) } ``` ```java Java theme={null} import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; String orderId = "60b8d6f1e1b9b1d8c6c0d8e1"; HttpResponse response = Unirest.get("https://api-integration.ollang.com/integration/revision/" + orderId) .header("X-Api-Key", "") .asString(); ObjectMapper mapper = new ObjectMapper(); JsonNode revisions = mapper.readTree(response.getBody()); System.out.println("Found " + revisions.size() + " revisions for order " + orderId); ``` ## Authorizations This endpoint requires API key authentication. Include your API key in the request header: * **Header name**: `X-Api-Key` * **Header value**: Your API key from the Ollang dashboard * **Format**: `X-Api-Key: your-api-key-here` You can obtain your API key from your [Ollang dashboard](https://lab.ollang.com). ## Path Parameters The unique identifier of the order for which you want to retrieve all revision requests. This should be a valid order ID that you have access to. ## Response The endpoint returns an array of revision objects. Each revision object contains the following fields: Unique identifier of the revision request. Creation date and time of the revision request (ISO 8601 format). The type of revision that was requested. Possible values: - `missingSubtitle` * Subtitle is missing at a specific time - `wrongSubtitle` - Subtitle content is incorrect - `syncError` - Subtitle timing is not synchronized with audio - `formatError` - Subtitle formatting issues - `other` - Other types of issues Timestamp indicating where the issue occurs in the content (format: "HH:MM:SS"). Detailed description of the revision request, if provided. ```json 200 theme={null} [ { "id": "rev_60b8d6f1e1b9b1d8c6c0d8e1", "createdAt": "2024-01-17T10:30:00Z", "type": "wrongSubtitle", "time": "02:15:30", "description": "The subtitle at this timestamp is incorrectly translated. Should be 'Hello world' instead of 'Hello universe'." }, { "id": "rev_60b8d6f1e1b9b1d8c6c0d8e2", "createdAt": "2024-01-17T14:45:00Z", "type": "syncError", "time": "01:42:15", "description": "Subtitle appears 2 seconds too late compared to the spoken dialogue." }, { "id": "rev_60b8d6f1e1b9b1d8c6c0d8e3", "createdAt": "2024-01-18T09:20:00Z", "type": "missingSubtitle", "time": "03:28:45", "description": "No subtitle appears during the character's important monologue." } ] ``` ```json 200 Empty Array theme={null} [] ``` ```json 404 theme={null} { "error": "Order not found", "message": "No order found with the provided orderId", "code": "ORDER_NOT_FOUND" } ``` ```json 403 theme={null} { "error": "Access denied", "message": "You don't have permission to view revisions for this order", "code": "ACCESS_DENIED" } ``` ```json 401 theme={null} { "error": "Unauthorized", "message": "Invalid or missing API key", "code": "UNAUTHORIZED" } ``` # Get Credit Wallet Source: https://api-docs.ollang.com/apis/ollang-api-reference/get-credit-wallet GET https://api-integration.ollang.com/integration/credits Retrieve the account AI credit wallet balance with USD equivalents Returns the account AI credit wallet: total, remaining, and used credits, each with its USD equivalent at the account rate of **1000 credits = \$1**. The response also includes the currency, the conversion rate, and the last time balances were synced. This endpoint is restricted to **account owners and billing managers**. The API key must belong to a user with the `client_owner` or `client_accessBillings` role, otherwise the request is rejected with `403`. ```bash cURL theme={null} curl -X GET "https://api-integration.ollang.com/integration/credits" \ -H "X-Api-Key: " ``` ```javascript JavaScript theme={null} const response = await fetch( "https://api-integration.ollang.com/integration/credits", { method: "GET", headers: { "X-Api-Key": "", }, } ); const wallet = await response.json(); ``` ```python Python theme={null} import requests headers = { 'X-Api-Key': '' } response = requests.get( 'https://api-integration.ollang.com/integration/credits', headers=headers ) ``` ```php PHP theme={null} $curl = curl_init(); curl_setopt_array($curl, array( CURLOPT_URL => 'https://api-integration.ollang.com/integration/credits', CURLOPT_RETURNTRANSFER => true, CURLOPT_HTTPHEADER => array( 'X-Api-Key: ' ), )); $response = curl_exec($curl); curl_close($curl); ``` ```go Go theme={null} package main import ( "net/http" ) func main() { req, _ := http.NewRequest("GET", "https://api-integration.ollang.com/integration/credits", nil) req.Header.Set("X-Api-Key", "") client := &http.Client{} resp, _ := client.Do(req) } ``` ```java Java theme={null} HttpResponse response = Unirest.get("https://api-integration.ollang.com/integration/credits") .header("X-Api-Key", "") .asString(); ``` ## Authorizations This endpoint requires API key authentication. Include your API key in the request header: * **Header name**: `X-Api-Key` * **Header value**: Your API key from the Ollang dashboard * **Format**: `X-Api-Key: your-api-key-here` You can obtain your API key from your [Ollang dashboard](https://lab.ollang.com). The key must belong to a user with the `client_owner` or `client_accessBillings` role. Requests from keys without one of these billing roles are rejected with `403`. ## Response Total AI credits assigned to the account (active + depleted). Unit: credits. Currently remaining AI credits. Unit: credits. AI credits consumed so far. Unit: credits. Currency the credits convert to (for example `USD`). Conversion rate: credits per one unit of currency (for example `1000`). Total credits expressed in USD (`totalCredits / 1000`). Remaining credits expressed in USD (`remainingCredits / 1000`). Used credits expressed in USD (`usedCredits / 1000`). Last time credit balances were synced (ISO 8601 format), or `null` if never synced. ```json 200 theme={null} { "totalCredits": 30000000, "remainingCredits": 26649461.48, "usedCredits": 3350538.52, "currency": "USD", "creditsPerUsd": 1000, "totalUsd": 30000, "remainingUsd": 26649.46, "usedUsd": 3350.54, "lastSyncDate": "2026-01-15T10:30:00Z" } ``` ```json 401 theme={null} { "error": "Unauthorized", "message": "Invalid or missing API key", "code": "UNAUTHORIZED" } ``` ```json 403 theme={null} { "error": "Access denied", "message": "The API key user lacks the client_owner or client_accessBillings role", "code": "ACCESS_DENIED" } ``` # Get Custom Instruction Suggestions Source: https://api-docs.ollang.com/apis/ollang-api-reference/get-custom-instruction-suggestions GET https://api-integration.ollang.com/integration/custom-instructions/suggestions Retrieve suggested preset custom instructions you can adopt or adapt Returns a curated list of suggested custom instructions (templates). Use these as starting points when creating your own via [Create Custom Instruction](/apis/ollang-api-reference/create-custom-instruction). ```bash cURL theme={null} curl -X GET "https://api-integration.ollang.com/integration/custom-instructions/suggestions" \ -H "X-Api-Key: " ``` ```javascript JavaScript theme={null} const response = await fetch( "https://api-integration.ollang.com/integration/custom-instructions/suggestions", { method: "GET", headers: { "X-Api-Key": "", }, } ); const suggestions = await response.json(); ``` ```python Python theme={null} import requests headers = {"X-Api-Key": ""} response = requests.get( "https://api-integration.ollang.com/integration/custom-instructions/suggestions", headers=headers, ) suggestions = response.json() ``` ## Authorizations This endpoint requires API key authentication. * **Header name**: `X-Api-Key` * **Header value**: Your API key from the [Ollang dashboard](https://lab.ollang.com) ## Response Each suggestion includes key, value, optional description, and `active` (template default). Suggested instruction key. Suggested instruction body text. Optional explanation of the suggestion. Whether the template is marked active by default. ```json 200 theme={null} [ { "key": "tone_and_register", "value": "Match the formality level of the source. Business emails should remain professional.", "description": "Instructions for maintaining appropriate tone and register", "active": true } ] ``` ```json 401 theme={null} { "error": "Unauthorized", "message": "Invalid or missing API key" } ``` # Get Folder Order Language Pairs Source: https://api-docs.ollang.com/apis/ollang-api-reference/get-folder-order-language-pairs GET https://api-integration.ollang.com/integration/folder/{folderId}/order-language-pairs Get distinct source/target language pairs from eligible orders in a folder Returns the distinct source/target language combinations from orders in a folder. Use `status=unassigned` (default) to get pairs available for assignment, or `status=assigned` to get pairs available for unassignment. This endpoint is useful for populating language filter dropdowns before calling the assign or unassign endpoints. ```bash cURL (unassigned orders - default) theme={null} curl -X GET "https://api-integration.ollang.com/integration/folder/60b8d6f1e1b9b1d8c6c0d8e1/order-language-pairs" \ -H "X-Api-Key: " ``` ```bash cURL (assigned orders) theme={null} curl -X GET "https://api-integration.ollang.com/integration/folder/60b8d6f1e1b9b1d8c6c0d8e1/order-language-pairs?status=assigned" \ -H "X-Api-Key: " ``` ```javascript JavaScript theme={null} const folderId = "60b8d6f1e1b9b1d8c6c0d8e1"; const response = await fetch( `https://api-integration.ollang.com/integration/folder/${folderId}/order-language-pairs?status=unassigned`, { method: "GET", headers: { "X-Api-Key": "", }, }, ); const data = await response.json(); console.log(data.pairs); // [{ sourceLanguage: "en", targetLanguage: "fr" }, { sourceLanguage: "en", targetLanguage: "tr" }] ``` ```python Python theme={null} import requests folder_id = "60b8d6f1e1b9b1d8c6c0d8e1" response = requests.get( f"https://api-integration.ollang.com/integration/folder/{folder_id}/order-language-pairs", headers={"X-Api-Key": ""}, params={"status": "unassigned"}, ) data = response.json() for pair in data["pairs"]: print(f"{pair['sourceLanguage']} → {pair['targetLanguage']}") ``` ## Authorizations This endpoint requires API key authentication. Include your API key in the request header: * **Header name**: `X-Api-Key` * **Header value**: Your API key from the Ollang dashboard ## Path Parameters The unique identifier of the folder. ## Query Parameters Filter by order status. Accepted values: * `unassigned` (default) — returns language pairs from orders available for assignment * `assigned` — returns language pairs from orders available for unassignment ## Response Array of distinct language pair objects. Source language code (e.g., `en`). Target language code (e.g., `fr`). ```json 200 theme={null} { "pairs": [ { "sourceLanguage": "en", "targetLanguage": "fr" }, { "sourceLanguage": "en", "targetLanguage": "tr" }, { "sourceLanguage": "en", "targetLanguage": "de" } ] } ``` ```json 200 (empty - no eligible orders) theme={null} { "pairs": [] } ``` ```json 401 theme={null} { "error": "Unauthorized", "message": "Invalid or missing API key", "code": "UNAUTHORIZED" } ``` # Get Memory by ID Source: https://api-docs.ollang.com/apis/ollang-api-reference/get-memory-by-id GET https://api-integration.ollang.com/integration/memories/{memoryId} Retrieve a single translation memory Retrieve one translation memory by ID, including its stored translation-unit count. ```bash cURL theme={null} curl -X GET "https://api-integration.ollang.com/integration/memories/507f1f77bcf86cd799439011" \ -H "X-Api-Key: " ``` ```javascript JavaScript theme={null} const memoryId = "507f1f77bcf86cd799439011"; const response = await fetch( `https://api-integration.ollang.com/integration/memories/${memoryId}`, { method: "GET", headers: { "X-Api-Key": "", }, } ); const memory = await response.json(); ``` ```python Python theme={null} import requests memory_id = "507f1f77bcf86cd799439011" headers = {"X-Api-Key": ""} response = requests.get( f"https://api-integration.ollang.com/integration/memories/{memory_id}", headers=headers, ) memory = response.json() ``` ## Authorizations This endpoint requires API key authentication. * **Header name**: `X-Api-Key` * **Header value**: Your API key from the [Ollang dashboard](https://lab.ollang.com) ## Path Parameters The translation memory's unique identifier. ## Response Returns the translation memory object. Unique identifier of the translation memory. Human-readable name of the translation memory. Number of translation units stored in the memory. Creation timestamp (ISO 8601). Last update timestamp (ISO 8601). ```json 200 theme={null} { "id": "507f1f77bcf86cd799439011", "title": "Product documentation EN→FR", "memoryItemsCount": 12480, "createdAt": "2023-10-05T12:34:56.789Z", "updatedAt": "2023-10-05T12:34:56.789Z" } ``` ```json 404 theme={null} { "statusCode": 404, "message": "Memory not found" } ``` ```json 401 theme={null} { "error": "Unauthorized", "message": "Invalid or missing API key" } ``` # Get Memory Import Job Source: https://api-docs.ollang.com/apis/ollang-api-reference/get-memory-import-job GET https://api-integration.ollang.com/integration/memories/import-jobs/{jobId} Track the progress of a memory import job Returns the progress of an import job created by [Import Memory Items](/apis/ollang-api-reference/import-memory-items) (or by a dashboard file upload), including the vectorization step that makes the imported units available to semantic matching. Imported units are matched by exact lookup as soon as the job's `status` reaches `completed`; semantic matching becomes available once `vectorizationStatus` also reaches `completed`. ```bash cURL theme={null} curl -X GET "https://api-integration.ollang.com/integration/memories/import-jobs/66b8d6f1e1b9b1d8c6c0d8e1" \ -H "X-Api-Key: " ``` ```javascript JavaScript theme={null} const jobId = "66b8d6f1e1b9b1d8c6c0d8e1"; const response = await fetch( `https://api-integration.ollang.com/integration/memories/import-jobs/${jobId}`, { method: "GET", headers: { "X-Api-Key": "", }, } ); const job = await response.json(); ``` ```python Python theme={null} import requests job_id = "66b8d6f1e1b9b1d8c6c0d8e1" headers = {"X-Api-Key": ""} response = requests.get( f"https://api-integration.ollang.com/integration/memories/import-jobs/{job_id}", headers=headers, ) job = response.json() ``` ## Authorizations This endpoint requires API key authentication. * **Header name**: `X-Api-Key` * **Header value**: Your API key from the [Ollang dashboard](https://lab.ollang.com) ## Path Parameters The import job's unique identifier, as returned by the import endpoint. ## Response Identifier of the import job. Status of the import: `pending`, `processing`, `completed`, or `failed`. Import progress percentage (0–100). Number of translation units imported. `null` until the job completes. Human-readable error message when the job failed. Completion timestamp (ISO 8601). `null` until the job completes. Status of the vectorization step: `pending`, `processing`, `completed`, or `failed`. Vectorization progress percentage (0–100). Human-readable error message when vectorization failed. Vectorization completion timestamp (ISO 8601). ```json 200 (completed) theme={null} { "jobId": "66b8d6f1e1b9b1d8c6c0d8e1", "status": "completed", "progress": 100, "itemsCount": 250, "error": null, "completedAt": "2026-08-12T09:20:00.000Z", "vectorizationStatus": "processing", "vectorizationProgress": 0, "vectorizationError": null, "vectorizationCompletedAt": null } ``` ```json 200 (processing) theme={null} { "jobId": "66b8d6f1e1b9b1d8c6c0d8e1", "status": "processing", "progress": 40, "itemsCount": null, "error": null, "completedAt": null, "vectorizationStatus": "pending", "vectorizationProgress": 0, "vectorizationError": null, "vectorizationCompletedAt": null } ``` ```json 404 theme={null} { "statusCode": 404, "message": "Job not found" } ``` ```json 401 theme={null} { "error": "Unauthorized", "message": "Invalid or missing API key" } ``` # Get Order by ID Source: https://api-docs.ollang.com/apis/ollang-api-reference/get-order-by-id GET https://api-integration.ollang.com/integration/orders/{orderId} Retrieve detailed information about a specific translation order by its unique identifier Retrieve detailed information about a specific translation order using its unique identifier. This endpoint provides comprehensive order details including status, documents, and financial information. ```bash cURL theme={null} curl -X GET "https://api-integration.ollang.com/integration/orders/60b8d6f1e1b9b1d8c6c0d8e1" \ -H "X-Api-Key: " ``` ```javascript JavaScript theme={null} const orderId = "60b8d6f1e1b9b1d8c6c0d8e1"; const response = await fetch( `https://api-integration.ollang.com/integration/orders/${orderId}`, { method: "GET", headers: { "X-Api-Key": "", }, }, ); const orderData = await response.json(); ``` ```python Python theme={null} import requests order_id = "60b8d6f1e1b9b1d8c6c0d8e1" headers = { 'X-Api-Key': '' } response = requests.get( f'https://api-integration.ollang.com/integration/orders/{order_id}', headers=headers ) order_data = response.json() ``` ```php PHP theme={null} $orderId = '60b8d6f1e1b9b1d8c6c0d8e1'; $curl = curl_init(); curl_setopt_array($curl, array( CURLOPT_URL => 'https://api-integration.ollang.com/integration/orders/' . $orderId, CURLOPT_RETURNTRANSFER => true, CURLOPT_HTTPHEADER => array( 'X-Api-Key: ' ), )); $response = curl_exec($curl); curl_close($curl); ``` ```go Go theme={null} package main import ( "fmt" "net/http" ) func main() { orderId := "60b8d6f1e1b9b1d8c6c0d8e1" url := fmt.Sprintf("https://api-integration.ollang.com/integration/orders/%s", orderId) req, _ := http.NewRequest("GET", url, nil) req.Header.Set("X-Api-Key", "") client := &http.Client{} resp, _ := client.Do(req) } ``` ```java Java theme={null} String orderId = "60b8d6f1e1b9b1d8c6c0d8e1"; HttpResponse response = Unirest.get("https://api-integration.ollang.com/integration/orders/" + orderId) .header("X-Api-Key", "") .asString(); ``` ## Authorizations This endpoint requires API key authentication. Include your API key in the request header: * **Header name**: `X-Api-Key` * **Header value**: Your API key from the Ollang dashboard * **Format**: `X-Api-Key: your-api-key-here` You can obtain your API key from your [Ollang dashboard](https://lab.ollang.com). ## Path Parameters The unique identifier of the order you want to retrieve. This should be a valid order ID that you have access to. ## Response Unique identifier of the order. Creation date and time of the order (ISO 8601 format). Name or title of the order. Source language of the content. Uses ISO 639-1 language codes (e.g., 'en', 'tr', 'fr'). Target language for translation. Uses ISO 639-1 language codes (e.g., 'en', 'tr', 'fr'). Type of the order. Creatable values are `cc`, `subtitle`, `document`, `aiDubbing`, and `studioDubbing` — see [Order Types](/apis/ollang-api-reference/order-types). The platform may additionally return legacy or system-generated values such as `proofreading`, `other`, or `revision` on orders that were not created through [Create Order](/apis/ollang-api-reference/create-order). Current status of the order. Possible values: `pending`, `ongoing`, `completed`, `revision`, `delayed`, `waitingForCC`, `waitingForSubtitle`, `delivered`, `qualityCheck`, `readyToSent`. Rate applied to the order for pricing calculation. Associated project identifier that this order belongs to. Service level for the order. Level 0 means full AI generated and Level 1 is Human Review added version. Folder identifier where the order files are organized and stored. URL to download the VTT subtitle file associated with the order (if available). Array of documents associated with the order. Unique identifier of the document. Name of the document. URL to access or download the document. Type of the document (e.g., sourceVideo, subtitle, translation). Size of the document in bytes. Duration in seconds (for audio/video files). Word count (for text documents). Source language of the document content. Document creation date (ISO 8601 format). Document last update date (ISO 8601 format). Financial details related to the order. Total amount to be paid for this order. Quality check evaluation for this order, if available. This field is present when a QC evaluation has been run on the order. Unique identifier of the evaluation. Order ID this evaluation belongs to. Creation timestamp of the evaluation (ISO 8601 format). Text summary of the evaluation results. Overall evaluation scores for each criterion. Name of the evaluation criterion (e.g., "Accuracy", "Fluency"). Description of what this criterion measures. Score value for this criterion. Segment-by-segment evaluation details. ID of the segment being evaluated. Explanation of the evaluation for this segment. Suggested improvement for this segment. Whether the evaluation is still being processed. Delivery milestones recorded for this order, oldest first. Use this to track an order's delivery history programmatically — when the AI output became available, when a translator delivered their work, and when the order was delivered to you. Returns an empty array for orders that have not reached a milestone yet, and for orders created before delivery-event tracking was introduced (the log is not backfilled). The same event type can appear more than once — for example an LSP re-delivery, or an order that was rerun. The milestone this event records. One of: * `ai_delivered` — the AI pipeline finished and AI results became available for the order. * `translator_delivered` — a translator delivered their work. * `lsp_approved` — an LSP admin or project manager approved a member's delivery. * `order_delivered` — the order reached a delivered/completed state and the deliverable is available to you. When the milestone happened (ISO 8601 format). What kind of actor produced the event: `ai`, `translator`, `lsp`, or `system`. `system` means the event was produced by the pipeline itself rather than by an identifiable actor. Identifier of the actor within its own domain (translator or LSP id). Null for `ai` and `system` events, and when the actor could not be resolved. ```json 200 theme={null} { "id": "60b8d6f1e1b9b1d8c6c0d8e1", "createdAt": "2024-01-15T10:30:00Z", "name": "Sample Project - Episode 1", "sourceLanguage": "en", "targetLanguage": "fr", "type": "cc", "status": "completed", "rate": 0.15, "projectId": "proj_xyz789", "level": 0, "folderId": "folder_abc123", "vttUrl": "https://example.com/subtitles/sample_project_fr.vtt", "orderDocs": [ { "id": "doc_123abc", "name": "Sample Project - Source Video", "url": "https://example.com/videos/sample_project.mp4", "type": "sourceVideo", "size": 1073741824, "duration": 7200, "sourceLanguage": "en", "createdAt": "2024-01-15T10:30:00Z", "updatedAt": "2024-01-15T10:30:00Z" }, { "id": "doc_456def", "name": "French Subtitles", "url": "https://example.com/subtitles/sample_project_fr.srt", "type": "subtitle", "size": 8192, "wordCount": 1250, "sourceLanguage": "fr", "createdAt": "2024-01-16T14:20:00Z", "updatedAt": "2024-01-16T14:20:00Z" } ], "finance": { "paymentAmount": 150.75 }, "latestEvaluation": { "id": "eval_abc123def456", "orderId": "60b8d6f1e1b9b1d8c6c0d8e1", "createdAt": "2024-01-17T09:00:00Z", "textSummary": "The translation demonstrates good overall quality with high accuracy and natural fluency. Minor improvements suggested for cultural adaptation.", "scores": [ { "name": "Accuracy", "description": "Translation accuracy and correctness", "value": 92.5 }, { "name": "Fluency", "description": "Natural flow and readability in target language", "value": 88.0 }, { "name": "Tone", "description": "Consistency with original tone and style", "value": 90.0 }, { "name": "Cultural Fit", "description": "Cultural appropriateness for target audience", "value": 85.5 } ], "segmentEvals": [ { "id": "seg_001", "explain": "Minor grammatical adjustment recommended", "suggestedNewValue": "Improved translation text here" } ], "isLoading": false }, "deliveryEvents": [ { "type": "ai_delivered", "occurredAt": "2024-01-15T11:05:00.000Z", "actorType": "ai", "actorId": null }, { "type": "translator_delivered", "occurredAt": "2024-01-16T14:20:00.000Z", "actorType": "translator", "actorId": "7c1f4a2b9e3d5061a8b2c4d7" }, { "type": "order_delivered", "occurredAt": "2024-01-16T14:20:03.000Z", "actorType": "translator", "actorId": "7c1f4a2b9e3d5061a8b2c4d7" } ] } ``` ```json 404 theme={null} { "error": "Order not found", "message": "No order found with the provided orderId", "code": "ORDER_NOT_FOUND" } ``` ```json 403 theme={null} { "error": "Access denied", "message": "You don't have permission to access this order", "code": "ACCESS_DENIED" } ``` ```json 401 theme={null} { "error": "Unauthorized", "message": "Invalid or missing API key", "code": "UNAUTHORIZED" } ``` # Get Orders Source: https://api-docs.ollang.com/apis/ollang-api-reference/get-orders GET https://api-integration.ollang.com/integration/orders Retrieve a list of translation orders with optional pagination and filters Retrieve a list of your translation orders with optional pagination and filtering capabilities. This endpoint allows you to view and manage all your submitted orders. ```bash cURL theme={null} curl -X GET "https://api-integration.ollang.com/integration/orders?pageOptions[page]=1&pageOptions[take]=10&pageOptions[search]=sample&pageOptions[orderBy]=createdAt&pageOptions[orderDirection]=desc" \ -H "X-Api-Key: " ``` ```bash cURL with filters theme={null} curl -X GET "https://api-integration.ollang.com/integration/orders" \ -H "X-Api-Key: " \ -G \ -d "pageOptions[page]=1" \ -d "pageOptions[take]=20" \ -d "filter[type]=cc" \ -d "filter[name]=sample" \ -d "filter[createdAtRange][from]=2024-01-01T00:00:00Z" \ -d "filter[createdAtRange][to]=2024-12-31T23:59:59Z" ``` ```javascript JavaScript theme={null} const params = new URLSearchParams({ "pageOptions[page]": "1", "pageOptions[take]": "10", "pageOptions[search]": "sample", "pageOptions[orderBy]": "createdAt", "pageOptions[orderDirection]": "desc", }); const response = await fetch( `https://api-integration.ollang.com/integration/orders?${params}`, { method: "GET", headers: { "X-Api-Key": "", }, } ); ``` ```javascript JavaScript with filters theme={null} const params = new URLSearchParams({ "pageOptions[page]": "1", "pageOptions[take]": "20", "filter[type]": "cc", "filter[name]": "sample", "filter[createdAtRange][from]": "2024-01-01T00:00:00Z", "filter[createdAtRange][to]": "2024-12-31T23:59:59Z", }); const response = await fetch( `https://api-integration.ollang.com/integration/orders?${params}`, { headers: { "X-Api-Key": "", }, } ); ``` ```python Python theme={null} import requests params = { 'pageOptions[page]': 1, 'pageOptions[take]': 10, 'pageOptions[search]': 'sample', 'pageOptions[orderBy]': 'createdAt', 'pageOptions[orderDirection]': 'desc' } headers = { 'X-Api-Key': '' } response = requests.get( 'https://api-integration.ollang.com/integration/orders', params=params, headers=headers ) ``` ```python Python with filters theme={null} import requests params = { 'pageOptions[page]': 1, 'pageOptions[take]': 20, 'filter[type]': 'cc', 'filter[name]': 'sample', 'filter[createdAtRange][from]': '2024-01-01T00:00:00Z', 'filter[createdAtRange][to]': '2024-12-31T23:59:59Z' } headers = { 'X-Api-Key': '' } response = requests.get( 'https://api-integration.ollang.com/integration/orders', params=params, headers=headers ) ``` ```php PHP theme={null} $params = http_build_query([ 'pageOptions' => [ 'page' => 1, 'take' => 10, 'search' => 'sample', 'orderBy' => 'createdAt', 'orderDirection' => 'desc' ] ]); $curl = curl_init(); curl_setopt_array($curl, array( CURLOPT_URL => 'https://api-integration.ollang.com/integration/orders?' . $params, CURLOPT_RETURNTRANSFER => true, CURLOPT_HTTPHEADER => array( 'X-Api-Key: ' ), )); $response = curl_exec($curl); curl_close($curl); ``` ```go Go theme={null} package main import ( "fmt" "net/http" "net/url" ) func main() { baseURL := "https://api-integration.ollang.com/integration/orders" params := url.Values{} params.Add("pageOptions[page]", "1") params.Add("pageOptions[take]", "10") params.Add("pageOptions[search]", "sample") params.Add("pageOptions[orderBy]", "createdAt") params.Add("pageOptions[orderDirection]", "desc") req, _ := http.NewRequest("GET", baseURL + "?" + params.Encode(), nil) req.Header.Set("X-Api-Key", "") client := &http.Client{} resp, _ := client.Do(req) } ``` ```java Java theme={null} String params = "pageOptions[page]=1&pageOptions[take]=10&pageOptions[search]=sample&pageOptions[orderBy]=createdAt&pageOptions[orderDirection]=desc"; HttpResponse response = Unirest.get("https://api-integration.ollang.com/integration/orders?" + params) .header("X-Api-Key", "") .asString(); ``` ## Authorizations This endpoint requires API key authentication. Include your API key in the request header: * **Header name**: `X-Api-Key` * **Header value**: Your API key from the Ollang dashboard * **Format**: `X-Api-Key: your-api-key-here` You can obtain your API key from your [Ollang dashboard](https://lab.ollang.com). ## Query Parameters ### Pagination Parameters The page number to retrieve. Must be 1 or greater. The number of items per page. Must be between 1 and 50. ### Sorting Parameters The field to sort the results by. Common values: `id`, `createdAt`, `name`, `status`. The direction to sort the results. Options: `asc`, `desc`. ### Search Parameters A search term to filter the results. Searches across order names and other relevant fields. ### Filter Parameters Filter by order type. Common values are the five creatable types — `cc`, `subtitle`, `document`, `aiDubbing`, and `studioDubbing` (see [Order Types](/apis/ollang-api-reference/order-types)). Legacy or system-generated values (`proofreading`, `other`, `revision`) are also accepted and may match historical orders that were not created through [Create Order](/apis/ollang-api-reference/create-order). Filter by the name of the order. Filter by creation date range - start date (ISO 8601 format). Filter by creation date range - end date (ISO 8601 format). ## Response Array of order objects containing order details. Unique identifier of the order. Name of the order. Source language of the order content. Target language for translation. Current status of the order. Possible values: `pending`, `ongoing`, `completed`, `revision`, `delayed`, `waitingForCC`, `waitingForSubtitle`, `delivered`, `qualityCheck`, `readyToSent`. Type of the order. Possible values: `cc`, `subtitle`, `document`, `aiDubbing`, `studioDubbing`, `proofreading`, `other`, `revision`. Creation date of the order (ISO 8601 format). Client identifier associated with the order. Project identifier associated with the order. Pagination metadata. Current page number. Number of items per page. Number of items in current page. Total number of pages. Whether there is a next page available. Whether there is a previous page available. ```json 200 theme={null} { "data": [ { "id": "60b8d6f1e1b9b1d8c6c0d8e1", "name": "Sample Project - Episode 1", "sourceLanguage": "en", "targetLanguage": "fr", "status": "completed", "type": "cc", "createdAt": "2024-01-15T10:30:00Z", "clientId": "client_abc123", "projectId": "proj_xyz789" }, { "id": "60b8d6f1e1b9b1d8c6c0d8e2", "name": "Corporate Training Video", "sourceLanguage": "en", "targetLanguage": "es", "status": "ongoing", "type": "aiDubbing", "createdAt": "2024-01-14T15:45:00Z", "clientId": "client_abc123", "projectId": "proj_xyz790" } ], "meta": { "page": 1, "take": 10, "itemCount": 2, "pageCount": 1, "hasNextPage": false, "hasPreviousPage": false } } ``` ```json 400 theme={null} { "error": "Invalid pagination parameters", "message": "Page must be greater than 0 and take must be between 1 and 50", "code": "INVALID_PAGINATION" } ``` ```json 401 theme={null} { "error": "Unauthorized", "message": "Invalid or missing API key", "code": "UNAUTHORIZED" } ``` # Get Project By ID Source: https://api-docs.ollang.com/apis/ollang-api-reference/get-project-by-id GET https://api-integration.ollang.com/integration/project/{projectId} Retrieve detailed information about a specific project using its unique identifier Retrieve comprehensive details about a specific project, including associated documents and metadata. This endpoint provides more detailed information than the projects list endpoint. ```bash cURL theme={null} curl -X GET "https://api-integration.ollang.com/integration/project/60b8d6f1e1b9b1d8c6c0d8e1" \ -H "X-Api-Key: " ``` ```javascript JavaScript theme={null} const projectId = "60b8d6f1e1b9b1d8c6c0d8e1"; const response = await fetch( `https://api-integration.ollang.com/integration/project/${projectId}`, { method: "GET", headers: { "X-Api-Key": "", }, } ); const project = await response.json(); console.log("Project details:", project); ``` ```python Python theme={null} import requests project_id = "60b8d6f1e1b9b1d8c6c0d8e1" headers = { 'X-Api-Key': '' } response = requests.get( f'https://api-integration.ollang.com/integration/project/{project_id}', headers=headers ) project = response.json() print("Project details:", project) ``` ```php PHP theme={null} $projectId = '60b8d6f1e1b9b1d8c6c0d8e1'; $curl = curl_init(); curl_setopt_array($curl, array( CURLOPT_URL => 'https://api-integration.ollang.com/integration/project/' . $projectId, CURLOPT_RETURNTRANSFER => true, CURLOPT_HTTPHEADER => array( 'X-Api-Key: ' ), )); $response = curl_exec($curl); $project = json_decode($response, true); curl_close($curl); echo "Project details: " . json_encode($project); ``` ```go Go theme={null} package main import ( "encoding/json" "fmt" "io" "net/http" ) func main() { projectId := "60b8d6f1e1b9b1d8c6c0d8e1" url := fmt.Sprintf("https://api-integration.ollang.com/integration/project/%s", projectId) req, _ := http.NewRequest("GET", url, nil) req.Header.Set("X-Api-Key", "") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) var project map[string]interface{} json.Unmarshal(body, &project) fmt.Println("Project details:", project) } ``` ```java Java theme={null} String projectId = "60b8d6f1e1b9b1d8c6c0d8e1"; String url = "https://api-integration.ollang.com/integration/project/" + projectId; HttpResponse response = Unirest.get(url) .header("X-Api-Key", "") .asString(); JSONObject project = new JSONObject(response.getBody()); System.out.println("Project details: " + project.toString()); ``` ## Authorizations This endpoint requires API key authentication. Include your API key in the request header: * **Header name**: `X-Api-Key` * **Header value**: Your API key from the Ollang dashboard * **Format**: `X-Api-Key: your-api-key-here` You can obtain your API key from your [Ollang dashboard](https://lab.ollang.com). ## Path Parameters The unique identifier of the project to retrieve. This should be a valid MongoDB ObjectId that you have access to. ## Response The response contains detailed information about the requested project, including all associated documents. Unique identifier of the project. Name of the project as provided during upload. Source language of the project using ISO 639-1 language codes (e.g., "en", "tr", "fr"). The date and time when the project was created in ISO 8601 format. Identifier of the folder associated with the project for organization purposes. Array of documents associated with the project, including source files and generated content. Unique identifier of the document. The creation date of the document in ISO 8601 format. The last update date of the document in ISO 8601 format. Name of the document. URL of the document for access or download. Type of the document. See [Document Types](#document-types) for available values. Size of the document in bytes. Storage URL of the document if different from the main URL. Word count of the document, applicable to text documents. Duration of the document if it is a media file, in seconds. Source language of the document, typically in ISO 639-1 format. URL of the waveform image if applicable to audio documents. Identifier of the project this document is associated with. Identifier of the order this document is associated with. Identifier of the client who owns the document. URL of the thumbnail image of the document. Identifier of the folder where the document is stored. Number of orders related to this project. ```json 200 theme={null} { "id": "60b8d6f1e1b9b1d8c6c0d8e1", "name": "Marketing Video Q4", "sourceLanguage": "en", "createdAt": "2024-01-15T10:30:45.511Z", "folderId": "60b8d6f1e1b9b1d8c6c0d8e2", "projectDocs": [ { "id": "60b8d6f1e1b9b1d8c6c0d8e3", "createdAt": "2024-01-15T10:30:45.511Z", "updatedAt": "2024-01-15T10:35:22.847Z", "name": "marketing_video_q4.mp4", "url": "https://storage.ollang.com/files/marketing_video_q4.mp4", "type": "source_video", "size": 157286400, "duration": 240, "sourceLanguage": "en", "clientId": "60b8d6f1e1b9b1d8c6c0d8e4", "projectId": "60b8d6f1e1b9b1d8c6c0d8e1", "folderId": "60b8d6f1e1b9b1d8c6c0d8e2", "thumbnailUrl": "https://storage.ollang.com/thumbnails/marketing_video_q4.jpg" }, { "id": "60b8d6f1e1b9b1d8c6c0d8e5", "createdAt": "2024-01-15T10:32:18.211Z", "updatedAt": "2024-01-15T10:32:18.211Z", "name": "marketing_video_waveform.png", "url": "https://storage.ollang.com/waveforms/marketing_video_waveform.png", "type": "created_waveform", "size": 524288, "clientId": "60b8d6f1e1b9b1d8c6c0d8e4", "projectId": "60b8d6f1e1b9b1d8c6c0d8e1", "folderId": "60b8d6f1e1b9b1d8c6c0d8e2" } ], "ordersCount": 3 } ``` ```json 404 theme={null} { "error": "Project not found", "message": "No project found with the provided projectId", "code": "PROJECT_NOT_FOUND" } ``` ```json 403 theme={null} { "error": "Access denied", "message": "You don't have permission to access this project", "code": "ACCESS_DENIED" } ``` ```json 401 theme={null} { "error": "Unauthorized", "message": "Invalid or missing API key", "code": "UNAUTHORIZED" } ``` ```json 400 theme={null} { "error": "Invalid project ID", "message": "The provided projectId is not a valid MongoDB ObjectId", "code": "INVALID_PROJECT_ID" } ``` # Health Check Source: https://api-docs.ollang.com/apis/ollang-api-reference/health-check GET https://api-integration.ollang.com/health Check the health status and availability of the Integration API service Check the health status of the Integration API service. This endpoint is used to monitor service availability and is typically called by load balancers, monitoring systems, and health check tools to ensure the service is operational. `/health` reports whether `api-integration.ollang.com` is reachable and healthy from your network. For platform-wide availability, open incidents, and scheduled maintenance, see [status.ollang.com](https://status.ollang.com). ```bash cURL theme={null} curl -X GET "https://api-integration.ollang.com/health" ``` ```javascript JavaScript theme={null} const response = await fetch("https://api-integration.ollang.com/health", { method: "GET", }); const healthStatus = await response.json(); console.log("Health status:", healthStatus); ``` ```python Python theme={null} import requests response = requests.get('https://api-integration.ollang.com/health') health_status = response.json() print("Health status:", health_status) ``` ```php PHP theme={null} $curl = curl_init(); curl_setopt_array($curl, array( CURLOPT_URL => 'https://api-integration.ollang.com/health', CURLOPT_RETURNTRANSFER => true, )); $response = curl_exec($curl); $healthStatus = json_decode($response, true); curl_close($curl); echo "Health status: " . json_encode($healthStatus); ``` ```go Go theme={null} package main import ( "encoding/json" "fmt" "io" "net/http" ) func main() { resp, err := http.Get("https://api-integration.ollang.com/health") if err != nil { panic(err) } defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) var healthStatus map[string]interface{} json.Unmarshal(body, &healthStatus) fmt.Println("Health status:", healthStatus) } ``` ```java Java theme={null} HttpResponse response = Unirest.get("https://api-integration.ollang.com/health") .asString(); JSONObject healthStatus = new JSONObject(response.getBody()); System.out.println("Health status: " + healthStatus.toString()); ``` ## Authorizations This endpoint does not require any authentication. It is publicly accessible to allow monitoring systems and load balancers to check service health without API keys. You do not need to enter an X-Api-Key for this endpoint. You can leave the X-Api-Key field empty. ## Response The response contains the current health status of the service with a timestamp and status indicator. Unix timestamp (in milliseconds) indicating when the health check was performed. Current status of the service. Possible values are: - `OK` - Service is healthy and operational - `NOK` - Service is experiencing issues (rarely returned; usually results in HTTP error) ```json 200 theme={null} { "time": 1704711600000, "status": "OK" } ``` ```json 500 theme={null} { "error": "Application unhealthy state", "message": "Service is experiencing internal issues", "code": -6 } ``` ```json 503 theme={null} { "error": "Service Unavailable", "message": "Service is temporarily unavailable", "code": "SERVICE_UNAVAILABLE" } ``` ## HTTP Status Codes **OK** - Service is healthy and all systems are operational. **Internal Server Error** - Service is unhealthy due to internal issues. **Service Unavailable** - Service is temporarily unavailable or under maintenance. # Import Content Source: https://api-docs.ollang.com/apis/ollang-api-reference/import-content POST https://api-integration.ollang.com/integration/content/import Import translation units into your content database Import translation units (source text + target text pairs) into your content database. This is useful for bulk-loading translations from external systems, TMS exports, or programmatic workflows. Imported content terms become immediately available in the [Content Management](/apis/ollang-api-reference/export-content) page and can be exported, tagged, and edited. ```bash cURL theme={null} curl -X POST "https://api-integration.ollang.com/integration/content/import" \ -H "X-Api-Key: " \ -H "Content-Type: application/json" \ -d '{ "targetLanguage": "de", "translations": [ { "sourceText": "Good morning", "targetText": "Guten Morgen" }, { "sourceText": "Sign in", "targetText": "Anmelden" }, { "sourceText": "Dashboard", "targetText": "Übersicht" } ] }' ``` ```javascript JavaScript theme={null} const response = await fetch( "https://api-integration.ollang.com/integration/content/import", { method: "POST", headers: { "X-Api-Key": "", "Content-Type": "application/json", }, body: JSON.stringify({ targetLanguage: "de", translations: [ { sourceText: "Good morning", targetText: "Guten Morgen" }, { sourceText: "Sign in", targetText: "Anmelden" }, { sourceText: "Dashboard", targetText: "Übersicht" }, ], }), }, ); const result = await response.json(); // { success: true, imported: 3 } ``` ```python Python theme={null} import requests data = { "targetLanguage": "de", "translations": [ {"sourceText": "Good morning", "targetText": "Guten Morgen"}, {"sourceText": "Sign in", "targetText": "Anmelden"}, {"sourceText": "Dashboard", "targetText": "Übersicht"}, ], } response = requests.post( "https://api-integration.ollang.com/integration/content/import", json=data, headers={"X-Api-Key": ""}, ) result = response.json() ``` ```php PHP theme={null} $data = [ 'targetLanguage' => 'de', 'translations' => [ ['sourceText' => 'Good morning', 'targetText' => 'Guten Morgen'], ['sourceText' => 'Sign in', 'targetText' => 'Anmelden'], ['sourceText' => 'Dashboard', 'targetText' => 'Übersicht'], ], ]; $curl = curl_init(); curl_setopt_array($curl, [ CURLOPT_URL => 'https://api-integration.ollang.com/integration/content/import', CURLOPT_RETURNTRANSFER => true, CURLOPT_POST => true, CURLOPT_HTTPHEADER => [ 'X-Api-Key: ', 'Content-Type: application/json', ], CURLOPT_POSTFIELDS => json_encode($data), ]); $response = curl_exec($curl); curl_close($curl); ``` ```go Go theme={null} package main import ( "bytes" "encoding/json" "net/http" ) func main() { data := map[string]interface{}{ "targetLanguage": "de", "translations": []map[string]string{ {"sourceText": "Good morning", "targetText": "Guten Morgen"}, {"sourceText": "Sign in", "targetText": "Anmelden"}, {"sourceText": "Dashboard", "targetText": "Übersicht"}, }, } jsonData, _ := json.Marshal(data) req, _ := http.NewRequest("POST", "https://api-integration.ollang.com/integration/content/import", bytes.NewBuffer(jsonData)) req.Header.Set("X-Api-Key", "") req.Header.Set("Content-Type", "application/json") client := &http.Client{} client.Do(req) } ``` ## Authorizations This endpoint requires API key authentication. Include your API key in the request header: * **Header name**: `X-Api-Key` * **Header value**: Your API key from the Ollang dashboard ## Body Parameters The target language code for all translations in this import batch (e.g., `de`, `fr`, `ja`). All translation units in the `translations` array must be in this language. Array of translation units to import. Each unit represents a source-target text pair. The original source text (key). This is used to match and deduplicate content terms across languages. The translated text in the target language. Optional element identifier for tracking the origin of this translation (e.g., a DOM element ID, a JSON key path, or a custom reference). Content type classification. Common values: `text`, `ui`, `subtitle`, `navigation`. Defaults to `text`. ## Behavior * If a content term with the same `sourceText` already exists, a new target entry for the specified language is added (or the existing one is updated). * If the `sourceText` does not exist, a new content term is created with the provided translation. * Import is idempotent for the same `sourceText` + `targetLanguage` combination — re-importing updates the target text. ## Response Whether the import completed successfully. The number of translation units that were processed. ```json 201 theme={null} { "success": true, "imported": 3 } ``` ```json 400 theme={null} { "statusCode": 400, "message": [ "targetLanguage should not be empty", "translations should not be empty" ], "error": "Bad Request" } ``` ```json 401 theme={null} { "error": "Unauthorized", "message": "Invalid or missing API key", "code": "UNAUTHORIZED" } ``` # Import Memory Items Source: https://api-docs.ollang.com/apis/ollang-api-reference/import-memory-items POST https://api-integration.ollang.com/integration/memories/{memoryId}/items/import Add translation units to a translation memory Queue translation units (source/target text per language pair) for import into a translation memory. The units are processed asynchronously through the same import pipeline as dashboard file uploads — including the vectorization step that makes them available to semantic matching — so the endpoint returns an import job to poll rather than a synchronous result. A single request accepts up to **1000 items**; send multiple requests for larger corpora. A memory can hold several language pairs at once — matches are resolved per target language at translation time. Poll [Get Memory Import Job](/apis/ollang-api-reference/get-memory-import-job) with the returned `jobId` to track progress. ```bash cURL theme={null} curl -X POST "https://api-integration.ollang.com/integration/memories/507f1f77bcf86cd799439011/items/import" \ -H "X-Api-Key: " \ -H "Content-Type: application/json" \ -d '{ "items": [ { "sourceLanguage": "en", "targetLanguage": "fr", "sourceText": "Getting started", "targetText": "Premiers pas" }, { "sourceLanguage": "en", "targetLanguage": "fr", "sourceText": "Release notes", "targetText": "Notes de version" } ] }' ``` ```javascript JavaScript theme={null} const memoryId = "507f1f77bcf86cd799439011"; const response = await fetch( `https://api-integration.ollang.com/integration/memories/${memoryId}/items/import`, { method: "POST", headers: { "X-Api-Key": "", "Content-Type": "application/json", }, body: JSON.stringify({ items: [ { sourceLanguage: "en", targetLanguage: "fr", sourceText: "Getting started", targetText: "Premiers pas", }, { sourceLanguage: "en", targetLanguage: "fr", sourceText: "Release notes", targetText: "Notes de version", }, ], }), } ); const { jobId } = await response.json(); // Poll the import job until it (and vectorization) completes const job = await fetch( `https://api-integration.ollang.com/integration/memories/import-jobs/${jobId}`, { headers: { "X-Api-Key": "" } } ).then((r) => r.json()); ``` ```python Python theme={null} import requests memory_id = "507f1f77bcf86cd799439011" data = { "items": [ { "sourceLanguage": "en", "targetLanguage": "fr", "sourceText": "Getting started", "targetText": "Premiers pas", }, { "sourceLanguage": "en", "targetLanguage": "fr", "sourceText": "Release notes", "targetText": "Notes de version", }, ] } headers = { "X-Api-Key": "", "Content-Type": "application/json", } response = requests.post( f"https://api-integration.ollang.com/integration/memories/{memory_id}/items/import", json=data, headers=headers, ) job_id = response.json()["jobId"] # Poll the import job until it (and vectorization) completes job = requests.get( f"https://api-integration.ollang.com/integration/memories/import-jobs/{job_id}", headers=headers, ).json() ``` ## Authorizations This endpoint requires API key authentication. * **Header name**: `X-Api-Key` * **Header value**: Your API key from the [Ollang dashboard](https://lab.ollang.com) ## Path Parameters The translation memory's unique identifier. ## Body Parameters Translation units to add to the memory. Minimum 1, maximum 1000 per request. Language code of the source text (e.g. `en`). Language code of the target text (e.g. `fr`). Source-language text of the translation unit. Target-language text of the translation unit. ## Response Returns the import job created for the request. Identifier of the import job. Poll [Get Memory Import Job](/apis/ollang-api-reference/get-memory-import-job) for progress. Initial status of the import job. Always `pending` on creation; it moves through `processing` to `completed` (or `failed`). ```json 201 theme={null} { "jobId": "66b8d6f1e1b9b1d8c6c0d8e1", "status": "pending" } ``` ```json 404 theme={null} { "statusCode": 404, "message": "Memory not found" } ``` ```json 400 theme={null} { "statusCode": 400, "message": [ "items must contain no more than 1000 elements" ], "error": "Bad Request" } ``` ```json 401 theme={null} { "error": "Unauthorized", "message": "Invalid or missing API key" } ``` # List Consumption Source: https://api-docs.ollang.com/apis/ollang-api-reference/list-consumption GET https://api-integration.ollang.com/integration/consumption Retrieve a paginated list of AI credit consumption line items with filtering Returns a paginated list of AI credit consumption line items — one row per provider run — equivalent to the dashboard **Consumption Breakdown** export. Each line includes the credits used, the USD equivalent under your account rate, the provider and service, the requestor who created the order, and the requestor's program tags. This endpoint is restricted to **account owners and billing managers**. The API key must belong to a user with the `client_owner` or `client_accessBillings` role, otherwise the request is rejected with `403`. ```bash cURL theme={null} curl -X GET "https://api-integration.ollang.com/integration/consumption?pageOptions[page]=1&pageOptions[take]=10&pageOptions[orderBy]=occurredAt&pageOptions[orderDirection]=desc" \ -H "X-Api-Key: " ``` ```bash cURL with filters theme={null} curl -X GET "https://api-integration.ollang.com/integration/consumption" \ -H "X-Api-Key: " \ -G \ -d "pageOptions[page]=1" \ -d "pageOptions[take]=20" \ -d "filter[from]=2026-01-01T00:00:00Z" \ -d "filter[to]=2026-01-31T23:59:59Z" \ -d "filter[provider]=elevenlabs" \ -d "filter[orderType]=document" \ -d "filter[createdBy]=jane@acme.com" \ -d "filter[tag]=Energy Studio" ``` ```javascript JavaScript theme={null} const params = new URLSearchParams({ "pageOptions[page]": "1", "pageOptions[take]": "10", "pageOptions[orderBy]": "occurredAt", "pageOptions[orderDirection]": "desc", }); const response = await fetch( `https://api-integration.ollang.com/integration/consumption?${params}`, { method: "GET", headers: { "X-Api-Key": "", }, } ); ``` ```javascript JavaScript with filters theme={null} const params = new URLSearchParams({ "pageOptions[page]": "1", "pageOptions[take]": "20", "filter[from]": "2026-01-01T00:00:00Z", "filter[to]": "2026-01-31T23:59:59Z", "filter[provider]": "elevenlabs", "filter[orderType]": "document", "filter[createdBy]": "jane@acme.com", "filter[tag]": "Energy Studio", }); const response = await fetch( `https://api-integration.ollang.com/integration/consumption?${params}`, { headers: { "X-Api-Key": "", }, } ); ``` ```python Python theme={null} import requests params = { 'pageOptions[page]': 1, 'pageOptions[take]': 10, 'pageOptions[orderBy]': 'occurredAt', 'pageOptions[orderDirection]': 'desc' } headers = { 'X-Api-Key': '' } response = requests.get( 'https://api-integration.ollang.com/integration/consumption', params=params, headers=headers ) ``` ```python Python with filters theme={null} import requests params = { 'pageOptions[page]': 1, 'pageOptions[take]': 20, 'filter[from]': '2026-01-01T00:00:00Z', 'filter[to]': '2026-01-31T23:59:59Z', 'filter[provider]': 'elevenlabs', 'filter[orderType]': 'document', 'filter[createdBy]': 'jane@acme.com', 'filter[tag]': 'Energy Studio' } headers = { 'X-Api-Key': '' } response = requests.get( 'https://api-integration.ollang.com/integration/consumption', params=params, headers=headers ) ``` ```php PHP theme={null} $params = http_build_query([ 'pageOptions' => [ 'page' => 1, 'take' => 10, 'orderBy' => 'occurredAt', 'orderDirection' => 'desc' ] ]); $curl = curl_init(); curl_setopt_array($curl, array( CURLOPT_URL => 'https://api-integration.ollang.com/integration/consumption?' . $params, CURLOPT_RETURNTRANSFER => true, CURLOPT_HTTPHEADER => array( 'X-Api-Key: ' ), )); $response = curl_exec($curl); curl_close($curl); ``` ```go Go theme={null} package main import ( "fmt" "net/http" "net/url" ) func main() { baseURL := "https://api-integration.ollang.com/integration/consumption" params := url.Values{} params.Add("pageOptions[page]", "1") params.Add("pageOptions[take]", "10") params.Add("pageOptions[orderBy]", "occurredAt") params.Add("pageOptions[orderDirection]", "desc") req, _ := http.NewRequest("GET", baseURL + "?" + params.Encode(), nil) req.Header.Set("X-Api-Key", "") client := &http.Client{} resp, _ := client.Do(req) } ``` ```java Java theme={null} String params = "pageOptions[page]=1&pageOptions[take]=10&pageOptions[orderBy]=occurredAt&pageOptions[orderDirection]=desc"; HttpResponse response = Unirest.get("https://api-integration.ollang.com/integration/consumption?" + params) .header("X-Api-Key", "") .asString(); ``` ## Authorizations This endpoint requires API key authentication. Include your API key in the request header: * **Header name**: `X-Api-Key` * **Header value**: Your API key from the Ollang dashboard * **Format**: `X-Api-Key: your-api-key-here` You can obtain your API key from your [Ollang dashboard](https://lab.ollang.com). The key must belong to a user with the `client_owner` or `client_accessBillings` role. Requests from keys without one of these billing roles are rejected with `403`. ## Query Parameters ### Pagination Parameters The page number to retrieve. Must be 1 or greater. The number of items per page. Must be between 1 and 50. ### Sorting Parameters The field to sort the results by. Common values: `occurredAt`, `creditsUsed`, `provider`. The direction to sort the results. Options: `asc`, `desc`. ### Search Parameters A search term to filter the results across relevant fields. ### Filter Parameters Search by order name (case-insensitive contains). Include consumption from this date onward (inclusive, ISO 8601 format). Include consumption up to this date (inclusive, ISO 8601 format). Filter by provider key, for example `openai`, `gemini`, or `elevenlabs`. Use the `providerKey` value returned on each line item. Filter by order type. Values: `cc`, `subtitle`, `document`, `aiDubbing`, `studioDubbing`, `proofreading`, `other`, `revision` (see [Order Types](/apis/ollang-api-reference/order-types)). Filter by requestor. Accepts a user id or an email address. Filter by a single order id. Filter by a single program tag value, for example `Energy Studio`. ## Response Array of consumption line items — one row per provider run. Stable consumption line id. Id of the order this consumption line belongs to. Display name of the order. The requestor who created the order. Requestor user id. Requestor full name. Requestor email address. Type of the order. Possible values: `cc`, `subtitle`, `document`, `aiDubbing`, `studioDubbing`, `proofreading`, `other`, `revision`. Credits consumed for this line. Unit: credits. USD equivalent under the account commercial rate (credits / 1000). Unit: USD. Provider display name (for example `Elevenlabs`). Raw provider key used for filtering (for example `elevenlabs`). Service / pipeline stage (for example `Text to Speech`). Program tags of the requestor. ISO 8601 timestamp of when the consumption occurred. Id of the project the order belongs to. Optional. Pagination metadata. Current page number. Number of items per page. Total number of items across all pages. Total number of pages. Whether there is a next page available. Whether there is a previous page available. ```json 200 theme={null} { "data": [ { "id": "cons_60b8d6f1e1b9b1d8c6c0d8e1", "orderId": "60b8d6f1e1b9b1d8c6c0d8e1", "orderName": "Sample Project - Episode 1", "createdBy": { "id": "user_abc123", "name": "Jane Doe", "email": "jane@acme.com" }, "orderType": "document", "creditsUsed": 9923, "usdEquivalent": 9.92, "provider": "Elevenlabs", "providerKey": "elevenlabs", "service": "Text to Speech", "tags": ["Energy Studio"], "occurredAt": "2026-01-15T10:30:00Z", "projectId": "proj_xyz789" } ], "meta": { "page": 1, "take": 10, "itemCount": 1, "pageCount": 1, "hasNextPage": false, "hasPreviousPage": false } } ``` ```json 401 theme={null} { "error": "Unauthorized", "message": "Invalid or missing API key", "code": "UNAUTHORIZED" } ``` ```json 403 theme={null} { "error": "Access denied", "message": "The API key user lacks the client_owner or client_accessBillings role", "code": "ACCESS_DENIED" } ``` # List Custom Instructions Source: https://api-docs.ollang.com/apis/ollang-api-reference/list-custom-instructions GET https://api-integration.ollang.com/integration/custom-instructions Retrieve all custom translation instructions configured for your account Retrieve every custom instruction (translation guidelines) owned by your API key’s account. Use these with the SDK’s `ollang.customInstructions` helpers or when you need IDs for updates or deletes. ```bash cURL theme={null} curl -X GET "https://api-integration.ollang.com/integration/custom-instructions" \ -H "X-Api-Key: " ``` ```javascript JavaScript theme={null} const response = await fetch( "https://api-integration.ollang.com/integration/custom-instructions", { method: "GET", headers: { "X-Api-Key": "", }, }, ); const instructions = await response.json(); ``` ```python Python theme={null} import requests headers = {"X-Api-Key": ""} response = requests.get( "https://api-integration.ollang.com/integration/custom-instructions", headers=headers, ) instructions = response.json() ``` ## Authorizations This endpoint requires API key authentication. * **Header name**: `X-Api-Key` * **Header value**: Your API key from the [Ollang dashboard](https://lab.ollang.com) ## Response Returns an array of custom instruction objects. Unique identifier of the custom instruction. Machine-friendly name for the instruction (e.g. `tone_and_register`). The instruction text applied to translation workflows. Whether the instruction is currently enabled. Optional human-readable description. Scope reference (client) identifier. Creation timestamp (ISO 8601). Last update timestamp (ISO 8601). ```json 200 theme={null} [ { "id": "507f1f77bcf86cd799439011", "key": "tone_and_register", "value": "Match the formality level of the source.", "active": true, "description": "Tone and register guidelines", "scopeRefId": "507f1f77bcf86cd799439012", "createdAt": "2023-10-05T12:34:56.789Z", "updatedAt": "2023-10-05T12:34:56.789Z" } ] ``` ```json 401 theme={null} { "error": "Unauthorized", "message": "Invalid or missing API key", "code": "UNAUTHORIZED" } ``` # List Folder Documents Source: https://api-docs.ollang.com/apis/ollang-api-reference/list-folder-documents GET https://api-integration.ollang.com/integration/folder/{folderId}/docs List the guideline, glossary, and character-list documents attached to a folder Returns the folder-level documents attached to a folder: guidelines, guideline glossaries, and character lists. These documents apply to every project inside the folder, so they are the API equivalent of the **Guidelines** panel on a folder in the dashboard. Only the three folder-level document types are returned. Source files attached to individual projects are not included. ```bash cURL theme={null} curl -X GET "https://api-integration.ollang.com/integration/folder/60b8d6f1e1b9b1d8c6c0d8e1/docs" \ -H "X-Api-Key: " ``` ```javascript JavaScript theme={null} const folderId = "60b8d6f1e1b9b1d8c6c0d8e1"; const response = await fetch( `https://api-integration.ollang.com/integration/folder/${folderId}/docs`, { method: "GET", headers: { "X-Api-Key": "", }, }, ); const docs = await response.json(); console.log(`${docs.length} folder documents`); ``` ```python Python theme={null} import requests folder_id = "60b8d6f1e1b9b1d8c6c0d8e1" response = requests.get( f"https://api-integration.ollang.com/integration/folder/{folder_id}/docs", headers={"X-Api-Key": ""}, ) for doc in response.json(): print(doc["type"], doc["name"]) ``` ```php PHP theme={null} $folderId = '60b8d6f1e1b9b1d8c6c0d8e1'; $curl = curl_init(); curl_setopt_array($curl, array( CURLOPT_URL => "https://api-integration.ollang.com/integration/folder/{$folderId}/docs", CURLOPT_RETURNTRANSFER => true, CURLOPT_HTTPHEADER => array( 'X-Api-Key: ' ), )); $response = curl_exec($curl); $docs = json_decode($response, true); curl_close($curl); echo "Folder documents: " . count($docs); ``` ```go Go theme={null} package main import ( "encoding/json" "fmt" "io" "net/http" ) func main() { folderID := "60b8d6f1e1b9b1d8c6c0d8e1" url := "https://api-integration.ollang.com/integration/folder/" + folderID + "/docs" req, _ := http.NewRequest("GET", url, nil) req.Header.Set("X-Api-Key", "") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) var docs []map[string]interface{} json.Unmarshal(body, &docs) fmt.Println("Folder documents:", len(docs)) } ``` ```java Java theme={null} String folderId = "60b8d6f1e1b9b1d8c6c0d8e1"; HttpResponse response = Unirest .get("https://api-integration.ollang.com/integration/folder/" + folderId + "/docs") .header("X-Api-Key", "") .asString(); JSONArray docs = new JSONArray(response.getBody()); System.out.println("Folder documents: " + docs.length()); ``` ## Authorizations This endpoint requires API key authentication. Include your API key in the request header: * **Header name**: `X-Api-Key` * **Header value**: Your API key from the Ollang dashboard * **Format**: `X-Api-Key: your-api-key-here` You can obtain your API key from your [Ollang dashboard](https://lab.ollang.com). ## Path Parameters The unique identifier of the folder. Retrieve folder IDs with [Retrieve All Folders](/apis/ollang-api-reference/retrieve-all-folders). ## Response An array of folder document objects. Unique identifier of the document. Pass this to [Remove Folder Document](/apis/ollang-api-reference/delete-folder-document) to detach it. Display name of the document. One of `guideline`, `guideline_glossary`, or `character_list`. Location of the stored document. Size of the document in bytes. May be `null` for documents attached without a size. Language of the document, when one was supplied at attach time. `null` otherwise. Identifier of the folder the document belongs to. Identifier of the account that owns the document. When the document was attached, in ISO 8601 format. When the document was last updated, in ISO 8601 format. ```json 200 theme={null} [ { "id": "60b8d6f1e1b9b1d8c6c0d8f1", "name": "Brand guideline v3", "type": "guideline", "url": "https://ollang-docs.s3.eu-central-1.amazonaws.com/60b8d6f1e1b9b1d8c6c0d8e5/brand-guideline-v3.pdf", "size": 481203, "sourceLanguage": "en", "folderId": "60b8d6f1e1b9b1d8c6c0d8e1", "clientId": "60b8d6f1e1b9b1d8c6c0d8e5", "createdAt": "2026-09-02T10:14:22.511Z", "updatedAt": "2026-09-02T10:14:22.511Z" }, { "id": "60b8d6f1e1b9b1d8c6c0d8f2", "name": "Product terminology", "type": "guideline_glossary", "url": "https://ollang-docs.s3.eu-central-1.amazonaws.com/60b8d6f1e1b9b1d8c6c0d8e5/product-terminology.xlsx", "size": 20418, "sourceLanguage": "en", "folderId": "60b8d6f1e1b9b1d8c6c0d8e1", "clientId": "60b8d6f1e1b9b1d8c6c0d8e5", "createdAt": "2026-09-02T10:16:03.882Z", "updatedAt": "2026-09-02T10:16:03.882Z" } ] ``` ```json 401 theme={null} { "error": "Unauthorized", "message": "Invalid or missing API key", "code": "UNAUTHORIZED" } ``` ```json 404 theme={null} { "statusCode": 404, "message": "Folder not found", "error": "Not Found" } ``` # List Memories Source: https://api-docs.ollang.com/apis/ollang-api-reference/list-memories GET https://api-integration.ollang.com/integration/memories Retrieve all translation memories on your account Retrieve every translation memory owned by your API key's account. Ids from this list can be passed as `selectedMemories` when creating an order, or used with the memory management endpoints for updates, deletes, and imports. ```bash cURL theme={null} curl -X GET "https://api-integration.ollang.com/integration/memories" \ -H "X-Api-Key: " ``` ```javascript JavaScript theme={null} const response = await fetch( "https://api-integration.ollang.com/integration/memories", { method: "GET", headers: { "X-Api-Key": "", }, }, ); const memories = await response.json(); ``` ```python Python theme={null} import requests headers = {"X-Api-Key": ""} response = requests.get( "https://api-integration.ollang.com/integration/memories", headers=headers, ) memories = response.json() ``` ## Authorizations This endpoint requires API key authentication. * **Header name**: `X-Api-Key` * **Header value**: Your API key from the [Ollang dashboard](https://lab.ollang.com) ## Response Returns an array of translation memory objects. Unique identifier of the translation memory. Human-readable name of the translation memory. Number of translation units stored in the memory. A memory can hold several language pairs; matches are resolved per target language at translation time. Creation timestamp (ISO 8601). Last update timestamp (ISO 8601). ```json 200 theme={null} [ { "id": "507f1f77bcf86cd799439011", "title": "Product documentation EN→FR", "memoryItemsCount": 12480, "createdAt": "2023-10-05T12:34:56.789Z", "updatedAt": "2023-10-05T12:34:56.789Z" } ] ``` ```json 401 theme={null} { "error": "Unauthorized", "message": "Invalid or missing API key" } ``` # Order Document Types Source: https://api-docs.ollang.com/apis/ollang-api-reference/order-doc-types Complete list of document types associated with orders in the Ollang API system Get information about all document types that can be associated with orders in the Ollang system. These document types represent different files and assets throughout the translation and production workflow. ## Document Type Categories The following table shows all available document types organized by category: | Index | Type | Category | Description | | - | - | - | - | | 1 | source\_video | Source | Original video file uploaded by the client | | 2 | source\_accompaniment\_audio | Source | Original background music/audio track | | 3 | source\_srt | Source | Original subtitle file provided by client | | 4 | source\_document | Source | Original document file for translation | | 5 | created\_source\_vocals\_only\_audio | Created | Extracted vocal track from original audio | | 6 | created\_waveform | Created | Audio waveform visualization file | | 7 | created\_accompaniment\_audio | Created | Processed background audio track | | 8 | created\_ai\_dub\_audio | Created | AI-generated dubbing audio file | | 9 | created\_ai\_dub\_vocals\_only\_audio | Created | AI dubbing vocals without background | | 10 | created\_embedded\_video | Created | Video with embedded subtitles/captions | | 11 | created\_subtitle\_embedded\_video | Created | Video with burned-in subtitles | | 12 | created\_compressed\_video | Created | Compressed version of processed video | | 13 | created\_thumbnail | Created | Generated thumbnail image for video | | 14 | vendor\_audio\_with\_background | Vendor | Voice actor recording with music | | 15 | vendor\_audio\_without\_background | Vendor | Clean voice actor recording | | 16 | vendor\_video | Vendor | Video content provided by vendor | | 17 | translator\_document | Translator | Translated document from translator | | 18 | guideline | Reference | Project guidelines and instructions | | 19 | character\_list | Reference | Character names and pronunciation guide | | 20 | guideline\_glossary | Reference | Terminology glossary for consistency | # Order Statuses Source: https://api-docs.ollang.com/apis/ollang-api-reference/order-statuses Complete list of order statuses and their meanings in the Ollang API Get information about all possible order statuses in the Ollang system. These statuses indicate the current state of your translation and transcription orders. ## Order Status Types The following table shows all possible order statuses and their descriptions: | Index | Status | Description | | - | - | - | | 1 | pending | Order has been created but processing has not yet started | | 2 | ongoing | Order is currently being processed by our translation team | | 3 | completed | Order has been successfully completed and is ready for download | | 4 | revision | Order is under revision based on feedback or quality review | | 5 | waitingForCC | Order is waiting for closed captions to be added | | 6 | waitingForSubtitle | Order is waiting for subtitle generation or approval | ## Tracking progress beyond the current status A status is a snapshot of where an order is right now — it does not tell you how it got there. To reconstruct an order's history, read the `deliveryEvents` array on [Get Order by ID](/apis/ollang-api-reference/get-order-by-id), which records each delivery milestone with a timestamp: when the AI output became available, when a translator delivered their work, when an LSP approved a member's delivery, and when the order was delivered to you. # Order Types Source: https://api-docs.ollang.com/apis/ollang-api-reference/order-types Complete list of order types available in the Ollang API for different content processing services Get information about all available order types in the Ollang system. Each order type represents a different service offering for content processing and localization. ## Order Type Categories The following table shows all available order types and their descriptions: | Index | Type | Description | | - | - | - | | 1 | cc | Closed Captions — generate accessible captions or timecoded transcription for video content. | | 2 | subtitle | Subtitle Translation — translate timed dialogue and subtitle assets, export to SRT / VTT / ASS / STL / SCC / DFXP / ITT / DOCX / XLSX. | | 3 | document | Document Translation — text documents (DOCX, PDF, PPTX, XLSX, HTML, JSON, DITA, XLIFF, mobile strings, AE projects) and SVG graphics, whose text is translated in place so the SVG keeps its paths and styles, **and Visual Translation** via JPEG / JPG / PNG (image-to-image) uploaded through [Direct File Upload](/apis/ollang-api-reference/direct-file-upload). | | 4 | aiDubbing | AI Dubbing — automated voice dubbing. Use the `dubbingStyle` field to pick `overdub`, `lipsync`, or `audioDescription`. | | 5 | studioDubbing | Studio Dubbing — coordinate professional dubbing through external studios (vocals, M\&E, final mix). | **Visual Translation** and **Website Translation** are product capabilities, not separate enum values. Visual Translation runs through `document` when the source is an image; Website Translation runs through `document` on extracted i18n strings, or via the [SDK Browser SDK](/sdk/features#browser-sdk) for live CMS capture. # Real-Time Text Translation Source: https://api-docs.ollang.com/apis/ollang-api-reference/real-time-text-translation POST https://api-integration.ollang.com/integration/real-time-text-translation Translate up to 500 characters in one JSON response with no credit charge during the preview Translate up to **500 characters** and receive the complete translation in a single JSON response. It does not create an order or save a translation deliverable. **No Ollang credits are charged during the temporary preview.** A valid Ollang API key is required. This offer applies only to this endpoint and is not a permanent pricing commitment. ## Authentication Send your Ollang API key in the `X-Api-Key` header. In the interactive playground, enter it once under **Authorization**; the header is added automatically. Keep the key on your server, not in public browser code. ## Request body Send `Content-Type: application/json`. Source text, from 1 to 500 characters. Empty or whitespace-only text is rejected. Longer input is rejected, not truncated. Target language. Use a BCP-47 language tag such as `tr`, `pt-BR`, or `zh-Hant` to specify the language and, optionally, its region or script. Must contain non-whitespace text and be 1 to 80 characters long. Optional source language. Use a BCP-47 language tag such as `en` or `en-GB`. Omit it to detect the source language automatically. When supplied as a string, it must contain non-whitespace text and be 1 to 80 characters long. BCP-47 tags are accepted for both fields; see [language codes and BCP-47 support](/apis/ollang-api-reference/supported-languages#bcp-47-support). Language names such as `English` and `Turkish` are also accepted, but tags are recommended for consistent integrations. These fields are not restricted to a fixed language list, and the API does not enforce BCP-47 syntax. Acceptance of a tag does not guarantee translation quality for every language, region, or script. Optional translation guidance, such as the subject, audience, preferred terminology, or tone. When supplied, it must contain non-whitespace text and be 1 to 500 characters long. This limit is separate from the 500-character limit on `text`. Omit it when no guidance is needed. Only `text` is translated. `context` guides the translation; it is not additional source text and does not change the response format. For example, use `"context": "A casual greeting between friends; use an informal tone."`. Extra request fields are rejected. Set `OLLANG_API_KEY` securely in your environment before running the cURL example. ```bash cURL wrap theme={null} BASE_URL='https://api-integration.ollang.com' curl --fail-with-body \ "${BASE_URL}/integration/real-time-text-translation" \ -H "X-Api-Key: ${OLLANG_API_KEY}" \ -H 'Content-Type: application/json' \ -d '{ "text": "Hello, how are you?", "targetLanguage": "tr", "sourceLanguage": "en", "context": "A casual greeting between friends; use an informal tone." }' ``` ## Response A successful response has HTTP status `200` and content type `application/json`. The request waits for the complete translation; no streaming or event parsing is needed. The complete translated text. Formatting and line breaks are preserved where possible. ```json 200 wrap theme={null} { "translatedText": "Merhaba, nasılsın?" } ``` Read `translatedText` directly from the response. Output quality and formatting are not guaranteed; validate the translation before using it in a production workflow. ## Preview limits and errors The preview has shared capacity limits. If you receive `429`, wait before retrying and reduce concurrent requests. A disconnect cancels the request. Failed or timed-out requests return an error instead of a partial translation. | Status | Meaning | | - | - | | `400` | Invalid request body, including text or context longer than 500 characters. | | `401` | Missing, expired, or unrecognized API key. | | `403` | Your account is not permitted to access this endpoint. | | `429` | Translation capacity or rate limit reached. Retry later. | | `502` | Translation failed. Try again later. | | `503` | Translation is temporarily unavailable. | | `504` | Translation timed out. Retry later. | Existing account access restrictions still apply during the no-credit-charge preview. # Request Human Review for an Order Source: https://api-docs.ollang.com/apis/ollang-api-reference/request-human-review POST https://api-integration.ollang.com/integration/orders/{orderId}/human-review Request a human review for an existing order to ensure quality and accuracy. This endpoint triggers a manual review by a professional linguist. Request a human review for an existing order. This endpoint is used when you want a professional linguist to manually review the delivered content for quality assurance or compliance reasons. Only eligible orders can be submitted for human review. ```bash cURL theme={null} curl -X POST "https://api-integration.ollang.com/integration/orders/60b8d6f1e1b9b1d8c6c0d8e1/human-review" \ -H "X-Api-Key: " ``` ```javascript JavaScript theme={null} const orderId = "60b8d6f1e1b9b1d8c6c0d8e1"; const response = await fetch( `https://api-integration.ollang.com/integration/orders/${orderId}/human-review`, { method: "POST", headers: { "X-Api-Key": "", }, } ); if (response.status === 204) { console.log("Human review requested successfully"); } ``` ```python Python theme={null} import requests order_id = "60b8d6f1e1b9b1d8c6c0d8e1" headers = { 'X-Api-Key': '' } response = requests.post( f'https://api-integration.ollang.com/integration/orders/{order_id}/human-review', headers=headers ) if response.status_code == 204: print("Human review requested successfully") ``` ```php PHP theme={null} $orderId = '60b8d6f1e1b9b1d8c6c0d8e1'; $curl = curl_init(); curl_setopt_array($curl, array( CURLOPT_URL => 'https://api-integration.ollang.com/integration/orders/' . $orderId . '/human-review', CURLOPT_RETURNTRANSFER => true, CURLOPT_POST => true, CURLOPT_HTTPHEADER => array( 'X-Api-Key: ' ), )); $response = curl_exec($curl); $httpCode = curl_getinfo($curl, CURLINFO_HTTP_CODE); curl_close($curl); if ($httpCode === 204) { echo "Human review requested successfully"; } ``` ```go Go theme={null} package main import ( "fmt" "net/http" ) func main() { orderId := "60b8d6f1e1b9b1d8c6c0d8e1" url := fmt.Sprintf("https://api-integration.ollang.com/integration/orders/%s/human-review", orderId) req, _ := http.NewRequest("POST", url, nil) req.Header.Set("X-Api-Key", "") client := &http.Client{} resp, _ := client.Do(req) if resp.StatusCode == 204 { fmt.Println("Human review requested successfully") } } ``` ```java Java theme={null} String orderId = "60b8d6f1e1b9b1d8c6c0d8e1"; HttpResponse response = Unirest.post("https://api-integration.ollang.com/integration/orders/" + orderId + "/human-review") .header("X-Api-Key", "") .asString(); if (response.getStatus() == 204) { System.out.println("Human review requested successfully"); } ``` ## Authorizations This endpoint requires API key authentication. Include your API key in the request header: * **Header name**: `X-Api-Key` * **Header value**: Your API key from the Ollang dashboard * **Format**: `X-Api-Key: your-api-key-here` You can obtain your API key from your [Ollang dashboard](https://lab.ollang.com). ## Path Parameters The unique identifier of the order for which you want to request a human review. This should be a completed or delivered order that you have access to and is eligible for human review. ## Response This endpoint returns no content on successful request (HTTP 204 status code). The absence of an error response indicates that the human review was successfully requested. ```json 204 theme={null} No content - Human review requested successfully ``` ```json 404 theme={null} { "error": "Order not found", "message": "No order found with the provided orderId", "code": "ORDER_NOT_FOUND" } ``` ```json 400 theme={null} { "error": "Order not eligible for human review", "message": "Only completed or delivered orders can be submitted for human review", "code": "ORDER_NOT_ELIGIBLE" } ``` ```json 403 theme={null} { "error": "Access denied", "message": "You don't have permission to request human review for this order", "code": "ACCESS_DENIED" } ``` ```json 401 theme={null} { "error": "Unauthorized", "message": "Invalid or missing API key", "code": "UNAUTHORIZED" } ``` # Request Subtitle Embedding Source: https://api-docs.ollang.com/apis/ollang-api-reference/request-subtitle-embedding POST https://api-integration.ollang.com/integration/orders/{orderId}/subtitle-embedding Request subtitle embedding for an order to burn subtitles directly into the video file Request subtitle embedding for an existing order. This endpoint triggers the process of burning (hardcoding) the translated subtitles directly into the video file. The resulting video will have the subtitles permanently embedded as part of the video stream. ```bash cURL theme={null} curl -X POST "https://api-integration.ollang.com/integration/orders/60b8d6f1e1b9b1d8c6c0d8e1/subtitle-embedding" \ -H "X-Api-Key: " ``` ```javascript JavaScript theme={null} const orderId = "60b8d6f1e1b9b1d8c6c0d8e1"; const response = await fetch( `https://api-integration.ollang.com/integration/orders/${orderId}/subtitle-embedding`, { method: "POST", headers: { "X-Api-Key": "", }, }, ); const result = await response.json(); console.log(result); ``` ```python Python theme={null} import requests order_id = "60b8d6f1e1b9b1d8c6c0d8e1" headers = { 'X-Api-Key': '' } response = requests.post( f'https://api-integration.ollang.com/integration/orders/{order_id}/subtitle-embedding', headers=headers ) print(response.json()) ``` ```php PHP theme={null} $orderId = '60b8d6f1e1b9b1d8c6c0d8e1'; $curl = curl_init(); curl_setopt_array($curl, array( CURLOPT_URL => 'https://api-integration.ollang.com/integration/orders/' . $orderId . '/subtitle-embedding', CURLOPT_RETURNTRANSFER => true, CURLOPT_POST => true, CURLOPT_HTTPHEADER => array( 'X-Api-Key: ' ), )); $response = curl_exec($curl); curl_close($curl); $result = json_decode($response, true); print_r($result); ``` ```go Go theme={null} package main import ( "fmt" "io" "net/http" ) func main() { orderId := "60b8d6f1e1b9b1d8c6c0d8e1" url := fmt.Sprintf("https://api-integration.ollang.com/integration/orders/%s/subtitle-embedding", orderId) req, _ := http.NewRequest("POST", url, nil) req.Header.Set("X-Api-Key", "") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) } ``` ```java Java theme={null} String orderId = "60b8d6f1e1b9b1d8c6c0d8e1"; HttpResponse response = Unirest.post("https://api-integration.ollang.com/integration/orders/" + orderId + "/subtitle-embedding") .header("X-Api-Key", "") .asString(); System.out.println(response.getBody()); ``` ## Authorizations This endpoint requires API key authentication. Include your API key in the request header: * **Header name**: `X-Api-Key` * **Header value**: Your API key from the Ollang dashboard * **Format**: `X-Api-Key: your-api-key-here` You can obtain your API key from your [Ollang dashboard](https://lab.ollang.com). ## Path Parameters The unique identifier of the order for which you want to embed subtitles. The order must be in a completed or delivered state with available subtitle files. ## Response Indicates whether the subtitle embedding request was initiated successfully. A message describing the result of the subtitle embedding request. The ID of the order for which subtitle embedding was requested. ```json 200 theme={null} { "success": true, "message": "Subtitle embedding initiated successfully", "orderId": "60b8d6f1e1b9b1d8c6c0d8e1" } ``` ```json 400 theme={null} { "error": "Order not eligible for subtitle embedding", "message": "Only completed video orders with subtitle files can have subtitles embedded", "code": "ORDER_NOT_ELIGIBLE" } ``` ```json 404 theme={null} { "error": "Order not found", "message": "No order found with the provided orderId", "code": "ORDER_NOT_FOUND" } ``` ```json 403 theme={null} { "error": "Feature not available", "message": "Subtitle embedding is not available in your current plan", "code": "FEATURE_NOT_AVAILABLE" } ``` ```json 401 theme={null} { "error": "Unauthorized", "message": "Invalid or missing API key", "code": "UNAUTHORIZED" } ``` # Rerun Order Source: https://api-docs.ollang.com/apis/ollang-api-reference/rerun-order POST https://api-integration.ollang.com/integration/orders/{orderId}/rerun Rerun an existing order to regenerate the translation using the latest AI models and settings Rerun an existing order to regenerate the translation. This endpoint triggers a new translation process using the current AI models and any updated settings. The original order will be processed again, and the results will replace the previous translation. By default only the selected order is reprocessed. Set `triggerFullChain: true` to also reset and rerun the order's connected dependency chain — see [Rerunning Connected Order Chains](/concepts/rerunning-connected-order-chains) for details. ```bash cURL — Standard theme={null} curl -X POST "https://api-integration.ollang.com/integration/orders/60b8d6f1e1b9b1d8c6c0d8e1/rerun" \ -H "X-Api-Key: $OLLANG_API_KEY" \ -H "Content-Type: application/json" \ -d '{}' ``` ```bash cURL — Full chain theme={null} curl -X POST "https://api-integration.ollang.com/integration/orders/60b8d6f1e1b9b1d8c6c0d8e1/rerun" \ -H "X-Api-Key: $OLLANG_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "triggerFullChain": true }' ``` ```javascript JavaScript theme={null} const orderId = "60b8d6f1e1b9b1d8c6c0d8e1"; const response = await fetch( `https://api-integration.ollang.com/integration/orders/${orderId}/rerun`, { method: "POST", headers: { "X-Api-Key": process.env.OLLANG_API_KEY, "Content-Type": "application/json", }, // set to true to rerun the complete connected order chain body: JSON.stringify({ triggerFullChain: false }), }, ); const result = await response.json(); console.log(result); ``` ```python Python theme={null} import os import requests order_id = "60b8d6f1e1b9b1d8c6c0d8e1" headers = { 'X-Api-Key': os.environ['OLLANG_API_KEY'], 'Content-Type': 'application/json' } response = requests.post( f'https://api-integration.ollang.com/integration/orders/{order_id}/rerun', headers=headers, # set to True to rerun the complete connected order chain json={'triggerFullChain': False} ) print(response.json()) ``` ```php PHP theme={null} $orderId = '60b8d6f1e1b9b1d8c6c0d8e1'; $curl = curl_init(); curl_setopt_array($curl, array( CURLOPT_URL => 'https://api-integration.ollang.com/integration/orders/' . $orderId . '/rerun', CURLOPT_RETURNTRANSFER => true, CURLOPT_POST => true, // set to true to rerun the complete connected order chain CURLOPT_POSTFIELDS => '{"triggerFullChain": false}', CURLOPT_HTTPHEADER => array( 'X-Api-Key: ' . getenv('OLLANG_API_KEY'), 'Content-Type: application/json' ), )); $response = curl_exec($curl); curl_close($curl); $result = json_decode($response, true); print_r($result); ``` ```go Go theme={null} package main import ( "bytes" "fmt" "io" "net/http" "os" ) func main() { orderId := "60b8d6f1e1b9b1d8c6c0d8e1" url := fmt.Sprintf("https://api-integration.ollang.com/integration/orders/%s/rerun", orderId) // set triggerFullChain to true to rerun the complete connected order chain req, _ := http.NewRequest("POST", url, bytes.NewBuffer([]byte(`{"triggerFullChain": false}`))) req.Header.Set("X-Api-Key", os.Getenv("OLLANG_API_KEY")) req.Header.Set("Content-Type", "application/json") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) } ``` ```java Java theme={null} String orderId = "60b8d6f1e1b9b1d8c6c0d8e1"; // set triggerFullChain to true to rerun the complete connected order chain HttpResponse response = Unirest.post("https://api-integration.ollang.com/integration/orders/" + orderId + "/rerun") .header("X-Api-Key", System.getenv("OLLANG_API_KEY")) .header("Content-Type", "application/json") .body("{\"triggerFullChain\": false}") .asString(); System.out.println(response.getBody()); ``` ## Authorizations This endpoint requires API key authentication. Include your API key in the request header: * **Header name**: `X-Api-Key` * **Header value**: Your API key from the Ollang dashboard * **Format**: `X-Api-Key: your-api-key-here` You can obtain your API key from your [Ollang dashboard](https://lab.ollang.com). ## Path Parameters The unique identifier of the order you want to rerun. The order must be a completed (or stalled) Level 0 order of an eligible type — `cc`, `subtitle`, `aiDubbing`, or `document`. ## Request Body The request body is optional. You can send an empty object `{}` to rerun the order with default settings. When `true`, the order's connected dependency chain is reset and reprocessed in dependency order — the deepest dependency regenerates first and the requested order regenerates last using the fresh results. When `false` or omitted, only the selected order is rerun and existing dependency results are reused. See [Rerunning Connected Order Chains](/concepts/rerunning-connected-order-chains). ## Response Indicates whether the rerun was initiated successfully. A message describing the result of the rerun request. The ID of the order being rerun. This is the same as the input orderId. `true` when a full-chain rerun was initiated, `false` for a standard single-order rerun. Every order that was triggered, from the requested order down to its deepest dependency. Contains a single ID for standard reruns. ```json 200 — Standard rerun theme={null} { "success": true, "message": "Order is being reprocessed. This may take a few minutes.", "orderId": "60b8d6f1e1b9b1d8c6c0d8e1", "triggerFullChain": false, "triggeredOrderIds": ["60b8d6f1e1b9b1d8c6c0d8e1"] } ``` ```json 200 — Full-chain rerun theme={null} { "success": true, "message": "Full order chain rerun initiated successfully", "orderId": "60b8d6f1e1b9b1d8c6c0d8e1", "triggerFullChain": true, "triggeredOrderIds": [ "60b8d6f1e1b9b1d8c6c0d8e1", "60b8d6f1e1b9b1d8c6c0d8e2", "60b8d6f1e1b9b1d8c6c0d8e3" ] } ``` ```json 400 theme={null} { "microservice": "V3-Client", "error": "MicroserviceError", "message": "Order must be completed" } ``` ```json 404 theme={null} { "error": "Order not found", "message": "No order found with the provided orderId", "code": "ORDER_NOT_FOUND" } ``` ```json 403 theme={null} { "error": "Access denied", "message": "You don't have permission to rerun this order", "code": "ACCESS_DENIED" } ``` ```json 401 theme={null} { "error": "Unauthorized", "message": "Invalid or missing API key", "code": "UNAUTHORIZED" } ``` ## Full-chain specific errors Requests with `triggerFullChain: true` can additionally fail with: | Status | Message | Cause | | - | - | - | | 400 | `Full-chain rerun is not supported for order type: ...` | A chain member has an unsupported order type | | 400 | `Connected dependency chain is incomplete: no CC order found for this order` | A required dependent order is missing | | 400 | `Order chain is already being processed — wait for it to finish before rerunning` | A chain member is in flight | | 400 | `Insufficient AI credits to rerun the full order chain` / `Insufficient USD credits to rerun the full order chain` / `Monthly AI credits spending limit exceeded` | The chain's total rerun cost exceeds the available balance or monthly limit | | 400 | `Order chain contains an order that does not belong to this client` | A connected order belongs to another client | All chain validation runs before any order is reset or charged — a rejected request never leaves the chain partially processed. # Retrieve All Folders Source: https://api-docs.ollang.com/apis/ollang-api-reference/retrieve-all-folders GET https://api-integration.ollang.com/integration/folder Get a paginated list of all folders with optional search and sorting functionality Retrieve a paginated list of all folders associated with your account. Folders are used to organize your projects. You can use folder IDs when uploading files to place projects into specific folders. ```bash cURL theme={null} curl -X GET "https://api-integration.ollang.com/integration/folder?page=1&take=10&orderBy=createdAt&orderDirection=desc&search=marketing" \ -H "X-Api-Key: " ``` ```javascript JavaScript theme={null} const queryParams = new URLSearchParams({ page: "1", take: "10", orderBy: "createdAt", orderDirection: "desc", search: "marketing", }); const response = await fetch( `https://api-integration.ollang.com/integration/folder?${queryParams}`, { method: "GET", headers: { "X-Api-Key": "", }, } ); const folders = await response.json(); console.log("Folders:", folders); ``` ```python Python theme={null} import requests params = { 'page': 1, 'take': 10, 'orderBy': 'createdAt', 'orderDirection': 'desc', 'search': 'marketing' } headers = { 'X-Api-Key': '' } response = requests.get( 'https://api-integration.ollang.com/integration/folder', headers=headers, params=params ) folders = response.json() print("Folders:", folders) ``` ```php PHP theme={null} $queryParams = http_build_query([ 'page' => 1, 'take' => 10, 'orderBy' => 'createdAt', 'orderDirection' => 'desc', 'search' => 'marketing' ]); $curl = curl_init(); curl_setopt_array($curl, array( CURLOPT_URL => 'https://api-integration.ollang.com/integration/folder?' . $queryParams, CURLOPT_RETURNTRANSFER => true, CURLOPT_HTTPHEADER => array( 'X-Api-Key: ' ), )); $response = curl_exec($curl); $folders = json_decode($response, true); curl_close($curl); echo "Folders: " . json_encode($folders); ``` ```go Go theme={null} package main import ( "encoding/json" "fmt" "io" "net/http" "net/url" ) func main() { baseURL := "https://api-integration.ollang.com/integration/folder" params := url.Values{} params.Add("page", "1") params.Add("take", "10") params.Add("orderBy", "createdAt") params.Add("orderDirection", "desc") params.Add("search", "marketing") fullURL := baseURL + "?" + params.Encode() req, _ := http.NewRequest("GET", fullURL, nil) req.Header.Set("X-Api-Key", "") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) var folders map[string]interface{} json.Unmarshal(body, &folders) fmt.Println("Folders:", folders) } ``` ```java Java theme={null} String baseUrl = "https://api-integration.ollang.com/integration/folder"; String queryParams = "?page=1&take=10&orderBy=createdAt&orderDirection=desc&search=marketing"; HttpResponse response = Unirest.get(baseUrl + queryParams) .header("X-Api-Key", "") .asString(); JSONObject folders = new JSONObject(response.getBody()); System.out.println("Folders: " + folders.toString()); ``` ## Authorizations This endpoint requires API key authentication. Include your API key in the request header: * **Header name**: `X-Api-Key` * **Header value**: Your API key from the Ollang dashboard * **Format**: `X-Api-Key: your-api-key-here` You can obtain your API key from your [Ollang dashboard](https://lab.ollang.com). ## Query Parameters The page number to retrieve. Must be a positive integer starting from 1. The number of items per page. Must be between 1 and 50. The field to sort the results by. Common values include `id`, `name`, `createdAt`. The direction to sort the results. Must be either `asc` (ascending) or `desc` (descending). A search term to filter folders by name. The search is case-insensitive and supports partial matches. ## Response The response contains a paginated list of folders with metadata about the pagination. Array of folder objects containing detailed information about each folder. Unique identifier of the folder. Use this ID when uploading files to place projects into this folder. Name of the folder. Hex color code associated with the folder for visual identification (e.g., "#B6B6B6"). Type of the folder. Common values include `default` and `api`. The date and time when the folder was created in ISO 8601 format. The number of projects contained in this folder. Pagination metadata providing information about the current page and total results. The current page number of the pagination. The number of items per page. The total number of items across all pages. The total number of pages available. Boolean flag indicating if there is a previous page relative to the current page. Boolean flag indicating if there is a next page relative to the current page. ```json 200 theme={null} { "data": [ { "id": "60b8d6f1e1b9b1d8c6c0d8e2", "name": "Marketing Videos", "hexColor": "#6148f9", "type": "default", "createdAt": "2024-01-10T08:15:30.511Z", "projectCount": 12 }, { "id": "60b8d6f1e1b9b1d8c6c0d8e5", "name": "API Uploads", "hexColor": "#B6B6B6", "type": "api", "createdAt": "2024-01-05T14:22:10.211Z", "projectCount": 45 }, { "id": "60b8d6f1e1b9b1d8c6c0d8e7", "name": "Training Materials", "hexColor": "#34D399", "type": "default", "createdAt": "2024-01-03T11:45:22.847Z", "projectCount": 8 } ], "meta": { "page": 1, "take": 10, "itemCount": 3, "pageCount": 1, "hasPreviousPage": false, "hasNextPage": false } } ``` ```json 400 theme={null} { "error": "Invalid query parameters", "message": "The 'take' parameter must be between 1 and 50", "code": "INVALID_PAGINATION" } ``` ```json 401 theme={null} { "error": "Unauthorized", "message": "Invalid or missing API key", "code": "UNAUTHORIZED" } ``` ```json 500 theme={null} { "error": "Internal server error", "message": "An unexpected error occurred while retrieving folders", "code": "INTERNAL_ERROR" } ``` # Retrieve All Projects Source: https://api-docs.ollang.com/apis/ollang-api-reference/retrieve-all-projects GET https://api-integration.ollang.com/integration/project Get a paginated list of all projects with optional search and sorting functionality Retrieve a paginated list of all projects associated with your account. This endpoint supports various query parameters for pagination, sorting, and searching through your projects. ```bash cURL theme={null} curl -X GET "https://api-integration.ollang.com/integration/project?page=1&take=10&orderBy=createdAt&orderDirection=desc&search=video" \ -H "X-Api-Key: " ``` ```javascript JavaScript theme={null} const queryParams = new URLSearchParams({ page: "1", take: "10", orderBy: "createdAt", orderDirection: "desc", search: "project", }); const response = await fetch( `https://api-integration.ollang.com/integration/project?${queryParams}`, { method: "GET", headers: { "X-Api-Key": "", }, } ); const projects = await response.json(); console.log("Projects:", projects); ``` ```python Python theme={null} import requests params = { 'page': 1, 'take': 10, 'orderBy': 'createdAt', 'orderDirection': 'desc', 'search': 'project' } headers = { 'X-Api-Key': '' } response = requests.get( 'https://api-integration.ollang.com/integration/project', headers=headers, params=params ) projects = response.json() print("Projects:", projects) ``` ```php PHP theme={null} $queryParams = http_build_query([ 'page' => 1, 'take' => 10, 'orderBy' => 'createdAt', 'orderDirection' => 'desc', 'search' => 'project' ]); $curl = curl_init(); curl_setopt_array($curl, array( CURLOPT_URL => 'https://api-integration.ollang.com/integration/project?' . $queryParams, CURLOPT_RETURNTRANSFER => true, CURLOPT_HTTPHEADER => array( 'X-Api-Key: ' ), )); $response = curl_exec($curl); $projects = json_decode($response, true); curl_close($curl); echo "Projects: " . json_encode($projects); ``` ```go Go theme={null} package main import ( "encoding/json" "fmt" "io" "net/http" "net/url" ) func main() { baseURL := "https://api-integration.ollang.com/integration/project" params := url.Values{} params.Add("page", "1") params.Add("take", "10") params.Add("orderBy", "createdAt") params.Add("orderDirection", "desc") params.Add("search", "project") fullURL := baseURL + "?" + params.Encode() req, _ := http.NewRequest("GET", fullURL, nil) req.Header.Set("X-Api-Key", "") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) var projects map[string]interface{} json.Unmarshal(body, &projects) fmt.Println("Projects:", projects) } ``` ```java Java theme={null} String baseUrl = "https://api-integration.ollang.com/integration/project"; String queryParams = "?page=1&take=10&orderBy=createdAt&orderDirection=desc&search=project"; HttpResponse response = Unirest.get(baseUrl + queryParams) .header("X-Api-Key", "") .asString(); JSONObject projects = new JSONObject(response.getBody()); System.out.println("Projects: " + projects.toString()); ``` ## Authorizations This endpoint requires API key authentication. Include your API key in the request header: * **Header name**: `X-Api-Key` * **Header value**: Your API key from the Ollang dashboard * **Format**: `X-Api-Key: your-api-key-here` You can obtain your API key from your [Ollang dashboard](https://lab.ollang.com). ## Query Parameters The page number to retrieve. Must be a positive integer starting from 1. The number of items per page. Must be between 1 and 50. The field to sort the results by. Common values include `id`, `name`, `createdAt`, `sourceLanguage`. The direction to sort the results. Must be either `asc` (ascending) or `desc` (descending). A search term to filter projects by name or other searchable fields. The search is case-insensitive and supports partial matches. ## Response The response contains a paginated list of projects with metadata about the pagination. Array of project objects containing detailed information about each project. Unique identifier of the project. Name of the project as provided during upload. Source language of the project using ISO 639-1 language codes (e.g., "en", "tr", "fr"). The date and time when the project was created in ISO 8601 format. Identifier of the folder associated with the project for organization purposes. The number of orders related to this project. This field may not be present in all responses. Pagination metadata providing information about the current page and total results. The current page number of the pagination. The number of items per page. The total number of items across all pages. The total number of pages available. Boolean flag indicating if there is a previous page relative to the current page. Boolean flag indicating if there is a next page relative to the current page. ```json 200 theme={null} { "data": [ { "id": "60b8d6f1e1b9b1d8c6c0d8e1", "name": "Marketing Video Q4", "sourceLanguage": "en", "createdAt": "2024-01-15T10:30:45.511Z", "folderId": "60b8d6f1e1b9b1d8c6c0d8e2", "ordersCount": 3 }, { "id": "60b8d6f1e1b9b1d8c6c0d8e3", "name": "Product Demo Turkish", "sourceLanguage": "tr", "createdAt": "2024-01-14T14:22:33.211Z", "folderId": "60b8d6f1e1b9b1d8c6c0d8e2", "ordersCount": 1 }, { "id": "60b8d6f1e1b9b1d8c6c0d8e4", "name": "Training Material", "sourceLanguage": "fr", "createdAt": "2024-01-13T09:15:22.847Z", "folderId": "60b8d6f1e1b9b1d8c6c0d8e5" } ], "meta": { "page": 1, "take": 10, "itemCount": 25, "pageCount": 3, "hasPreviousPage": false, "hasNextPage": true } } ``` ```json 400 theme={null} { "error": "Invalid query parameters", "message": "The 'take' parameter must be between 1 and 50", "code": "INVALID_PAGINATION" } ``` ```json 401 theme={null} { "error": "Unauthorized", "message": "Invalid or missing API key", "code": "UNAUTHORIZED" } ``` ```json 500 theme={null} { "error": "Internal server error", "message": "An unexpected error occurred while retrieving projects", "code": "INTERNAL_ERROR" } ``` # Run QC Evaluation Source: https://api-docs.ollang.com/apis/ollang-api-reference/run-qc-evaluation POST https://api-integration.ollang.com/integration/orders/{orderId}/qc Run a standalone AI-powered QC evaluation on an order to assess translation quality across multiple criteria including accuracy, fluency, tone, and cultural fit. Run a standalone QC (Quality Control) evaluation on an existing order. This endpoint triggers an AI-powered assessment of the translation quality, evaluating criteria such as accuracy, fluency, tone, and cultural fit. The evaluation runs asynchronously and you will be notified when it's completed. ```bash cURL theme={null} curl -X POST "https://api-integration.ollang.com/integration/orders/60b8d6f1e1b9b1d8c6c0d8e1/qc" \ -H "X-Api-Key: " \ -H "Content-Type: application/json" \ -d '{ "accuracy": true, "fluency": true, "tone": true, "culturalFit": true, "customPrompt": "Please focus on technical terminology accuracy", "callbackUrl": "https://example.com/webhooks/qc-completed" }' ``` ```javascript JavaScript theme={null} const orderId = "60b8d6f1e1b9b1d8c6c0d8e1"; const response = await fetch( `https://api-integration.ollang.com/integration/orders/${orderId}/qc`, { method: "POST", headers: { "X-Api-Key": "", "Content-Type": "application/json", }, body: JSON.stringify({ accuracy: true, fluency: true, tone: true, culturalFit: true, customPrompt: "Please focus on technical terminology accuracy", callbackUrl: "https://example.com/webhooks/qc-completed", }), }, ); const result = await response.json(); console.log(result); ``` ```python Python theme={null} import requests order_id = "60b8d6f1e1b9b1d8c6c0d8e1" headers = { 'X-Api-Key': '', 'Content-Type': 'application/json' } payload = { 'accuracy': True, 'fluency': True, 'tone': True, 'culturalFit': True, 'customPrompt': 'Please focus on technical terminology accuracy', 'callbackUrl': 'https://example.com/webhooks/qc-completed' } response = requests.post( f'https://api-integration.ollang.com/integration/orders/{order_id}/qc', headers=headers, json=payload ) print(response.json()) ``` ```php PHP theme={null} $orderId = '60b8d6f1e1b9b1d8c6c0d8e1'; $curl = curl_init(); $payload = json_encode([ 'accuracy' => true, 'fluency' => true, 'tone' => true, 'culturalFit' => true, 'customPrompt' => 'Please focus on technical terminology accuracy', 'callbackUrl' => 'https://example.com/webhooks/qc-completed' ]); curl_setopt_array($curl, array( CURLOPT_URL => 'https://api-integration.ollang.com/integration/orders/' . $orderId . '/qc', CURLOPT_RETURNTRANSFER => true, CURLOPT_POST => true, CURLOPT_POSTFIELDS => $payload, CURLOPT_HTTPHEADER => array( 'X-Api-Key: ', 'Content-Type: application/json' ), )); $response = curl_exec($curl); curl_close($curl); $result = json_decode($response, true); print_r($result); ``` ```go Go theme={null} package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { orderId := "60b8d6f1e1b9b1d8c6c0d8e1" url := fmt.Sprintf("https://api-integration.ollang.com/integration/orders/%s/qc", orderId) payload := map[string]interface{}{ "accuracy": true, "fluency": true, "tone": true, "culturalFit": true, "customPrompt": "Please focus on technical terminology accuracy", "callbackUrl": "https://example.com/webhooks/qc-completed", } jsonPayload, _ := json.Marshal(payload) req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonPayload)) req.Header.Set("X-Api-Key", "") req.Header.Set("Content-Type", "application/json") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) } ``` ```java Java theme={null} String orderId = "60b8d6f1e1b9b1d8c6c0d8e1"; String payload = "{" + "\"accuracy\": true," + "\"fluency\": true," + "\"tone\": true," + "\"culturalFit\": true," + "\"customPrompt\": \"Please focus on technical terminology accuracy\"," + "\"callbackUrl\": \"https://example.com/webhooks/qc-completed\"" + "}"; HttpResponse response = Unirest.post("https://api-integration.ollang.com/integration/orders/" + orderId + "/qc") .header("X-Api-Key", "") .header("Content-Type", "application/json") .body(payload) .asString(); System.out.println(response.getBody()); ``` ## Authorizations This endpoint requires API key authentication. Include your API key in the request header: * **Header name**: `X-Api-Key` * **Header value**: Your API key from the Ollang dashboard * **Format**: `X-Api-Key: your-api-key-here` You can obtain your API key from your [Ollang dashboard](https://lab.ollang.com). ## Path Parameters The unique identifier of the order for which you want to run the QC evaluation. The order must be in a completed or delivered state to be eligible for evaluation. ## Request Body Include accuracy evaluation in the QC assessment. This evaluates how accurately the translation conveys the meaning of the source content. Include fluency evaluation in the QC assessment. This evaluates how naturally the translation reads in the target language. Include tone evaluation in the QC assessment. This evaluates whether the translation maintains the appropriate tone and style of the original content. Include cultural fit evaluation in the QC assessment. This evaluates whether the translation is culturally appropriate for the target audience. Optional custom prompt to guide the QC evaluation. Use this to provide specific instructions or focus areas for the AI evaluator, such as "Please focus on technical terminology accuracy" or "Pay attention to formal register consistency". Optional HTTPS URL to receive a POST request when the QC evaluation completes. Must be a valid HTTPS URL pointing to a publicly accessible host (private IPs and `localhost` are rejected). When provided, the evaluation results are sent to this URL as a JSON payload once processing finishes. See [Callback Payload](#callback-payload) below for the response format. ## Response Indicates whether the QC evaluation was started successfully. A message describing the result of the request. The unique identifier of the created evaluation. Use this ID to track the evaluation status and retrieve results. The number of AI credits consumed for this evaluation. Indicates whether the evaluation is still being processed. When `true`, the evaluation is running asynchronously and results will be available later. A text summary of the evaluation results. This field is populated once the evaluation is complete. An array of evaluation scores for each criterion. Each score object contains: * `name`: The name of the evaluation criterion (e.g., "accuracy", "fluency") - `score`: The numerical score value - `details`: Additional details about the score Segment-by-segment evaluation results. Each segment evaluation contains: - `segmentId`: The identifier of the evaluated segment - `scores`: Array of scores for this specific segment - `comments`: Evaluator comments about this segment ```json 200 theme={null} { "success": true, "message": "QC evaluation started. You will be notified when it's completed.", "evalId": "eval_abc123def456", "creditsUsed": 5, "isProcessing": true } ``` ```json 400 theme={null} { "error": "Order not eligible for QC evaluation", "message": "Only completed or delivered orders can be evaluated", "code": "ORDER_NOT_ELIGIBLE" } ``` ```json 404 theme={null} { "error": "Order not found", "message": "No order found with the provided orderId", "code": "ORDER_NOT_FOUND" } ``` ```json 403 theme={null} { "error": "Access denied", "message": "You don't have permission to run QC evaluation for this order", "code": "ACCESS_DENIED" } ``` ```json 401 theme={null} { "error": "Unauthorized", "message": "Invalid or missing API key", "code": "UNAUTHORIZED" } ``` ## Callback Payload When a `callbackUrl` is provided, Ollang sends a `POST` request to the URL once the QC evaluation completes. The request has a `Content-Type: application/json` header and the following body: The identifier of the order that was evaluated. The unique identifier of the evaluation run. The evaluation status. Will be `"completed"` on success. A human-readable summary of the evaluation results. An array of evaluation scores for each criterion. Each score object contains: * `name`: The name of the criterion (e.g., `"accuracy"`, `"fluency"`) * `score`: The numerical score value * `details`: Additional details about the score Segment-by-segment evaluation results. Each segment evaluation contains: * `segmentId`: The identifier of the evaluated segment * `scores`: Array of scores for this specific segment * `comments`: Evaluator comments about this segment **Example callback payload:** ```json theme={null} { "orderId": "60b8d6f1e1b9b1d8c6c0d8e1", "evalId": "eval_abc123def456", "status": "completed", "textSummary": "Overall translation quality is high with minor fluency issues in segments 3 and 7.", "scores": [ { "name": "accuracy", "score": 92, "details": "..." }, { "name": "fluency", "score": 85, "details": "..." }, { "name": "tone", "score": 90, "details": "..." }, { "name": "culturalFit", "score": 88, "details": "..." } ], "segmentEvals": [ { "segmentId": "seg_001", "scores": [{ "name": "accuracy", "score": 95 }], "comments": "Accurate translation with natural phrasing." } ] } ``` The callback request has a **10-second timeout**. If your server does not respond within 10 seconds, the request is considered failed. Callback failures do not affect the evaluation itself — results are still available via the [Get Order by ID](/apis/ollang-api-reference/get-order-by-id) endpoint. # Supported Languages Source: https://api-docs.ollang.com/apis/ollang-api-reference/supported-languages Complete list of supported languages and their language codes for the Ollang API Get the complete list of languages supported by the Ollang translation and transcription services. Use these language codes when making API requests. Codes here are mostly **ISO 639-1** (two-letter, e.g. `en`, `fr`) with some ISO 639-3 / regional and Ollang-specific variants for locales that need them (for example `pt-PT`, `es-MX`, `ar-EG`, `zh-Hant`, `fr-CA`, `en-UK`). A few codes are platform-specific historical assignments — pass the exact string shown in the table when constructing `sourceLanguage` or `language` values. This catalogue isn't the outer limit of what the API accepts, though — see [BCP-47 support](#bcp-47-support) below. If you see a code returned by the API that isn't in this table, treat the API response as authoritative and let us know via [support](mailto:info@ollang.com). ## Supported Languages | Code | Language | | - | - | | ab | Abkhaz | | ace | Acehnese | | ach | Acholi | | af | Afrikaans | | ak | Twi (Akan) | | alz | Alur | | am | Amharic | | ar | Arabic (MSA) | | ar-AE | Arabic (UAE) | | ar-BH | Arabic (Bahrain) | | ar-DZ | Arabic (Algeria) | | ar-EG | Arabic (Egypt) | | ar-IQ | Arabic (Iraq) | | ar-JO | Arabic (Jordan) | | ar-KW | Arabic (Kuwait) | | ar-LB | Arabic (Lebanon) | | ar-LY | Arabic (Libya) | | ar-MA | Arabic (Morocco) | | ar-OM | Arabic (Oman) | | ar-PS | Arabic (Palestine) | | ar-QA | Arabic (Qatar) | | ar-SY | Arabic (Syria) | | ar-TN | Arabic (Tunisia) | | ar-YE | Arabic (Yemen) | | as | Assamese | | awa | Awadhi | | ay | Aymara | | az | Azerbaijani | | ba | Bashkir | | ban | Balinese | | bbc | Batak Toba | | be | Belarusian | | bem | Bemba | | bew | Betawi | | bg | Bulgarian | | bho | Bhojpuri | | bik | Bikol | | bm | Bambara | | bn | Bengali | | bo | Tibetan | | br | Breton | | brx | Bodo | | bs | Bosnian | | bts | Batak Simalungun | | btx | Batak Karo | | bua | Buryat | | ca | Catalan | | ceb | Cebuano | | cgg | Kiga | | chm | Meadow Mari | | ckb | Kurdish (Sorani) | | cnh | Hakha Chin | | co | Corsican | | crh | Crimean Tatar | | crs | Seychellois Creole | | cs | Czech | | cv | Chuvash | | cy | Welsh | | da | Danish | | de | German | | din | Dinka | | doi | Dogri | | dov | Dombe | | dv | Divehi | | dz | Dzongkha | | ee | Ewe | | el | Greek | | en | English | | en-UK | English (United Kingdom) | | eo | Esperanto | | es | Spanish (Spain) | | es-MX | Spanish (LATAM) | | es-US | Spanish (United States) | | et | Estonian | | eu | Basque | | fa | Persian | | ff | Fulfulde | | fi | Finnish | | fj | Fijian | | fr | French | | fr-CA | French (Canadian) | | fy | Frisian | | ga | Irish | | gaa | Ga | | gd | Scots Gaelic | | gl | Galician | | gn | Guarani | | gu | Gujarati | | ha | Hausa | | haw | Hawaiian | | he | Hebrew | | hi | Hindi | | hil | Hiligaynon | | hmn | Hmong | | hr | Croatian | | hrx | Hunsrik | | ht | Haitian Creole | | hu | Hungarian | | hy | Armenian | | id | Indonesian | | ig | Igbo | | ilo | Iloko | | is | Icelandic | | it | Italian | | ja | Japanese | | jw | Javanese | | ka | Georgian | | kg | Kyrgyz | | khm | Khmer | | kk | Kazakh | | kn | Kannada | | ko | Korean | | kok | Konkani | | kri | Krio | | ks | Kashmiri | | ktu | Kituba | | ku | Kurdish (Kurmanji) | | la | Latin | | lb | Luxembourgish | | lg | Ganda (Luganda) | | li | Limburgan | | lij | Ligurian | | lmo | Lombard | | ln | Lingala | | lo | Lao | | lt | Lithuanian | | ltg | Latgalian | | luo | Luo | | lus | Mizo | | lv | Latvian | | mai | Maithili | | mak | Makassar | | md | Moldavian | | mg | Malagasy | | mi | Maori | | min | Minang | | mk | Macedonian | | ml | Malayalam | | mn | Mongolian | | mni | Manipuri | | mr | Marathi | | ms | Malay | | ms-Arab | Malay (Jawi) | | mt | Maltese | | my | Burmese | | ne | Nepali | | new | Nepalbhasa (Newari) | | nl | Dutch | | no | Norwegian | | nr | Ndebele (South) | | nso | Northern Sotho (Sepedi) | | nus | Nuer | | ny | Chichewa (Nyanja) | | oc | Occitan | | om | Oromo | | or | Odia (Oriya) | | pa | Punjabi | | pa-Arab | Punjabi (Shahmukhi) | | pag | Pangasinan | | pam | Kapampangan | | pap | Papiamento | | pl | Polish | | ps | Pashto | | pt | Portuguese (Brazil) | | pt-PT | Portuguese (Portugal) | | qu | Quechua | | rn | Rundi | | ro | Romanian | | rom | Romani | | ru | Russian | | rw | Kinyarwanda | | sa | Sanskrit | | sat | Santali | | scn | Sicilian | | sd | Sindhi | | sg | Sango | | sg-ma | Singaporean Mandarin | | sg-ms | Singaporean Malay | | shn | Shan | | si | Sinhala (Sinhalese) | | sk | Slovak | | sl | Slovenian | | sm | Samoan | | sn | Shona | | so | Somali | | sq | Albanian | | sr | Serbian | | ss | Swati | | st | Sesotho | | su | Sundanese | | sv | Swedish | | sw | Swahili | | szl | Silesian | | ta-IN | Tamil | | te | Telugu | | tet | Tetum | | th | Thai | | ti | Tigrinya | | tj | Tajik | | tk | Turkmen | | tl | Filipino | | tn | Tswana | | to | Tongan | | tr | Turkish | | ts | Tsonga | | tt | Tatar | | tw | Akan (Twi) | | ug | Uyghur | | uk | Ukrainian | | ur | Urdu | | ur-LT | Urdu Latin | | uz | Uzbek | | vi | Vietnamese | | wo | Wolof | | xh | Xhosa | | yi | Yiddish | | yo | Yoruba | | yua | Yucatec Maya | | yue | Cantonese | | zh | Chinese (Simplified) | | zh-Hant | Chinese (Traditional) | | zh-TW | Chinese (Taiwan) | | zu | Zulu | ## BCP-47 support The table above is Ollang's verified catalogue: every code in it has confirmed transcription, translation, and/or AI-dubbing provider coverage, and it's what `getSupportedLanguages`/`ollang.locales.search()` return and what `validateLanguageTag`/`ollang.locales.validate()` check against. Beyond that catalogue, `sourceLanguage`, `targetLanguage`, `language` (in `targetLanguageConfigs`), `supportedLanguages`, and folder language presets are all validated as plain strings, not restricted to an enum. In practice this means Ollang accepts **any well-formed [BCP-47](https://www.rfc-editor.org/rfc/bcp/bcp47.txt) language tag** as input — a primary language subtag optionally combined with a script and/or region subtag (for example `nb`, `sr-Latn`, `zh-Hans-SG`) — not only the codes listed above. A tag outside the catalogue keeps moving through the pipeline rather than being rejected: when a specific regional or script variant isn't directly recognized by a downstream provider, processing falls back to the closest supported match — typically the primary language subtag (for example, an unrecognized `fr-CH` still resolves to French). The catalogue above is where each code is confirmed to have at least one core service (transcription, translation, or AI-dubbing) available — it isn't a promise that every catalogued language has full coverage across every service or every AI-dubbing/TTS engine. Voice-level coverage in particular varies by engine (Gemini TTS, for example, covers 99 languages — see the [Text-to-Speech catalog](/providers/text-to-speech) for per-engine language lists), so check the relevant provider page as well as the catalogue above when a language needs dubbing or TTS specifically. Resolve or validate a code first with `ollang.locales.search()` / `ollang.locales.validate()` (or the `getSupportedLanguages` / `validateLanguageTag` MCP tools) so you know which match to expect, and check with [support](mailto:info@ollang.com) if you need dedicated coverage for a language you don't see in the table. ### Known non-standard or duplicate entries A few codes in the table are historical or Ollang-specific rather than strict ISO/BCP-47 forms. They're kept as-is for backward compatibility — pass the exact string shown, not a "corrected" equivalent: * `en-UK` — Ollang's tag for English (United Kingdom). The standard BCP-47 region tag is `en-GB`; `en-UK` is what this catalogue uses. * `md` — used here for Moldavian; not a valid ISO 639-1 code (Moldovan is usually represented under `ro`, Romanian). * `ak` and `tw` both resolve to Twi (Akan); either is accepted. * `sg` is Sango (ISO 639-1). `sg-ma` and `sg-ms` are Ollang-specific tags for Singaporean Mandarin and Singaporean Malay — they are not regional variants of Sango. * `ta-IN` (Tamil) is the only entry with an `-IN` region suffix; other South Asian languages in this table (`hi`, `bn`, `gu`, etc.) use the bare code. # Unassign Translator from Folder Orders Source: https://api-docs.ollang.com/apis/ollang-api-reference/unassign-translator-from-folder-orders POST https://api-integration.ollang.com/integration/folder/{folderId}/unassign-translator-from-orders Batch unassign a translator from eligible orders in a folder with optional language filters Unassigns the translator from all eligible (assigned, ongoing) orders in the specified folder. Optionally filter by `sourceLanguage` and/or `targetLanguage` to only unassign orders matching a specific language pair. When no language filters are provided, all eligible orders in the folder are unassigned. ```bash cURL (all orders) theme={null} curl -X POST "https://api-integration.ollang.com/integration/folder/60b8d6f1e1b9b1d8c6c0d8e1/unassign-translator-from-orders" \ -H "X-Api-Key: " \ -H "Content-Type: application/json" \ -d '{}' ``` ```bash cURL (filtered by language pair) theme={null} curl -X POST "https://api-integration.ollang.com/integration/folder/60b8d6f1e1b9b1d8c6c0d8e1/unassign-translator-from-orders" \ -H "X-Api-Key: " \ -H "Content-Type: application/json" \ -d '{ "sourceLanguage": "en", "targetLanguage": "fr" }' ``` ```javascript JavaScript theme={null} const folderId = "60b8d6f1e1b9b1d8c6c0d8e1"; const response = await fetch( `https://api-integration.ollang.com/integration/folder/${folderId}/unassign-translator-from-orders`, { method: "POST", headers: { "X-Api-Key": "", "Content-Type": "application/json", }, body: JSON.stringify({ sourceLanguage: "en", targetLanguage: "fr", }), }, ); const data = await response.json(); console.log(`Unassigned ${data.unassignedCount} orders`); ``` ```python Python theme={null} import requests folder_id = "60b8d6f1e1b9b1d8c6c0d8e1" response = requests.post( f"https://api-integration.ollang.com/integration/folder/{folder_id}/unassign-translator-from-orders", headers={ "X-Api-Key": "", "Content-Type": "application/json", }, json={ "sourceLanguage": "en", "targetLanguage": "fr", }, ) data = response.json() print(f"Unassigned {data['unassignedCount']} orders") ``` ## Authorizations This endpoint requires API key authentication. Include your API key in the request header: * **Header name**: `X-Api-Key` * **Header value**: Your API key from the Ollang dashboard ## Path Parameters The unique identifier of the folder containing the orders. ## Body Parameters Filter by source language code (e.g., `en`). Only orders with this source language will be unassigned. Filter by target language code (e.g., `fr`). Only orders with this target language will be unassigned. ## Response The number of orders that were successfully unassigned. ```json 200 theme={null} { "unassignedCount": 8 } ``` ```json 401 theme={null} { "error": "Unauthorized", "message": "Invalid or missing API key", "code": "UNAUTHORIZED" } ``` # Update Custom Instruction Source: https://api-docs.ollang.com/apis/ollang-api-reference/update-custom-instruction PATCH https://api-integration.ollang.com/integration/custom-instructions/{instructionId} Update an existing custom translation instruction Update any combination of fields on a custom instruction. Send only the properties you want to change. ```bash cURL theme={null} curl -X PATCH "https://api-integration.ollang.com/integration/custom-instructions/507f1f77bcf86cd799439011" \ -H "X-Api-Key: " \ -H "Content-Type: application/json" \ -d '{ "value": "Use informal tone for marketing copy only.", "active": true }' ``` ```javascript JavaScript theme={null} const instructionId = "507f1f77bcf86cd799439011"; const response = await fetch( `https://api-integration.ollang.com/integration/custom-instructions/${instructionId}`, { method: "PATCH", headers: { "X-Api-Key": "", "Content-Type": "application/json", }, body: JSON.stringify({ value: "Use informal tone for marketing copy only.", active: true, }), } ); const updated = await response.json(); ``` ```python Python theme={null} import requests instruction_id = "507f1f77bcf86cd799439011" data = { "value": "Use informal tone for marketing copy only.", "active": True, } headers = { "X-Api-Key": "", "Content-Type": "application/json", } response = requests.patch( f"https://api-integration.ollang.com/integration/custom-instructions/{instruction_id}", headers=headers, json=data, ) updated = response.json() ``` ## Authorizations This endpoint requires API key authentication. * **Header name**: `X-Api-Key` * **Header value**: Your API key from the [Ollang dashboard](https://lab.ollang.com) ## Path Parameters The custom instruction’s unique identifier (from [List Custom Instructions](/apis/ollang-api-reference/list-custom-instructions) or create response). ## Body Parameters All fields are optional; include at least one. New machine-friendly name for the instruction. New instruction text. Enable or disable this instruction without deleting it. Updated description. ## Response Returns the updated custom instruction object (same shape as [List Custom Instructions](/apis/ollang-api-reference/list-custom-instructions)). ```json 200 theme={null} { "id": "507f1f77bcf86cd799439011", "key": "tone_and_register", "value": "Use informal tone for marketing copy only.", "active": true, "description": "Instructions for maintaining appropriate tone and register", "scopeRefId": "507f1f77bcf86cd799439012", "createdAt": "2023-10-05T12:34:56.789Z", "updatedAt": "2023-10-06T09:15:00.000Z" } ``` ```json 404 theme={null} { "statusCode": 404, "message": "Custom instruction not found" } ``` ```json 401 theme={null} { "error": "Unauthorized", "message": "Invalid or missing API key" } ``` # Update Memory Source: https://api-docs.ollang.com/apis/ollang-api-reference/update-memory PATCH https://api-integration.ollang.com/integration/memories/{memoryId} Rename a translation memory Rename a translation memory. The stored translation units are not affected. ```bash cURL theme={null} curl -X PATCH "https://api-integration.ollang.com/integration/memories/507f1f77bcf86cd799439011" \ -H "X-Api-Key: " \ -H "Content-Type: application/json" \ -d '{ "title": "Product documentation EN→FR (v2)" }' ``` ```javascript JavaScript theme={null} const memoryId = "507f1f77bcf86cd799439011"; const response = await fetch( `https://api-integration.ollang.com/integration/memories/${memoryId}`, { method: "PATCH", headers: { "X-Api-Key": "", "Content-Type": "application/json", }, body: JSON.stringify({ title: "Product documentation EN→FR (v2)", }), } ); const memory = await response.json(); ``` ```python Python theme={null} import requests memory_id = "507f1f77bcf86cd799439011" data = {"title": "Product documentation EN→FR (v2)"} headers = { "X-Api-Key": "", "Content-Type": "application/json", } response = requests.patch( f"https://api-integration.ollang.com/integration/memories/{memory_id}", json=data, headers=headers, ) memory = response.json() ``` ## Authorizations This endpoint requires API key authentication. * **Header name**: `X-Api-Key` * **Header value**: Your API key from the [Ollang dashboard](https://lab.ollang.com) ## Path Parameters The translation memory's unique identifier. ## Body Parameters New human-readable name of the translation memory. ## Response Returns the updated translation memory object. ```json 200 theme={null} { "id": "507f1f77bcf86cd799439011", "title": "Product documentation EN→FR (v2)", "memoryItemsCount": 12480, "createdAt": "2023-10-05T12:34:56.789Z", "updatedAt": "2026-08-11T09:15:00.000Z" } ``` ```json 404 theme={null} { "statusCode": 404, "message": "Memory not found" } ``` ```json 401 theme={null} { "error": "Unauthorized", "message": "Invalid or missing API key" } ``` # Upload VTT File Source: https://api-docs.ollang.com/apis/ollang-api-reference/upload-a-vtt POST https://api-integration.ollang.com/integration/upload/vtt Upload VTT subtitle files to associate with existing video projects Upload VTT (WebVTT) subtitle files to associate with your existing video projects for enhanced accessibility and translation workflows. ```bash cURL theme={null} curl -X POST "https://api-integration.ollang.com/integration/upload/vtt" \ -H "X-Api-Key: " \ -H "Content-Type: multipart/form-data" \ -F "file=@/path/to/your/subtitles.vtt" \ -F "projectId=60b8d6f1e1b9b1d8c6c0d8e1" \ -F "name=sample_subtitles" ``` ```javascript JavaScript theme={null} const formData = new FormData(); formData.append("file", vttFile); formData.append("projectId", "60b8d6f1e1b9b1d8c6c0d8e1"); formData.append("name", "sample_subtitles"); const response = await fetch( "https://api-integration.ollang.com/integration/upload/vtt", { method: "POST", headers: { "X-Api-Key": "", }, body: formData, }, ); ``` ```python Python theme={null} import requests files = {'file': open('path/to/your/subtitles.vtt', 'rb')} data = { 'projectId': '60b8d6f1e1b9b1d8c6c0d8e1', 'name': 'sample_subtitles' } headers = {'X-Api-Key': ''} response = requests.post( 'https://api-integration.ollang.com/integration/upload/vtt', files=files, data=data, headers=headers ) ``` ```php PHP theme={null} $curl = curl_init(); curl_setopt_array($curl, array( CURLOPT_URL => 'https://api-integration.ollang.com/integration/upload/vtt', CURLOPT_RETURNTRANSFER => true, CURLOPT_POST => true, CURLOPT_HTTPHEADER => array( 'X-Api-Key: ' ), CURLOPT_POSTFIELDS => array( 'file' => new CURLFile('path/to/your/subtitles.vtt'), 'projectId' => '60b8d6f1e1b9b1d8c6c0d8e1', 'name' => 'sample_subtitles' ), )); $response = curl_exec($curl); curl_close($curl); ``` ```go Go theme={null} package main import ( "bytes" "io" "mime/multipart" "net/http" "os" ) func main() { file, _ := os.Open("path/to/your/subtitles.vtt") defer file.Close() body := &bytes.Buffer{} writer := multipart.NewWriter(body) part, _ := writer.CreateFormFile("file", "subtitles.vtt") io.Copy(part, file) writer.WriteField("projectId", "60b8d6f1e1b9b1d8c6c0d8e1") writer.WriteField("name", "sample_subtitles") writer.Close() req, _ := http.NewRequest("POST", "https://api-integration.ollang.com/integration/upload/vtt", body) req.Header.Set("X-Api-Key", "") req.Header.Set("Content-Type", writer.FormDataContentType()) client := &http.Client{} resp, _ := client.Do(req) } ``` ```java Java theme={null} HttpResponse response = Unirest.post("https://api-integration.ollang.com/integration/upload/vtt") .header("X-Api-Key", "") .field("file", new File("path/to/your/subtitles.vtt")) .field("projectId", "60b8d6f1e1b9b1d8c6c0d8e1") .field("name", "sample_subtitles") .asString(); ``` ## Authorizations This endpoint requires API key authentication. Include your API key in the request header: * **Header name**: `X-Api-Key` * **Header value**: Your API key from the Ollang dashboard * **Format**: `X-Api-Key: your-api-key-here` You can obtain your API key from your [Ollang dashboard](https://lab.ollang.com). ## Body Parameters The VTT (WebVTT) subtitle file to upload. Only .vtt format is supported. Maximum file size: 1GB. **Note: For testing in the API playground, the upload limit is 5MB.** Unique identifier for the project to associate this VTT file with. This should be an existing project ID from a previous video upload. Name of the file being uploaded. This will be used as the identifier for your uploaded subtitle content. The source language of the content in the uploaded file. Use one of the codes listed in [Supported Languages](/apis/ollang-api-reference/supported-languages). The special value `all` is also accepted for auto-detection workflows. ## Response Unique identifier for the project associated with the uploaded VTT file. This confirms the successful association of the subtitle file with the project. ```json 201 theme={null} { "projectId": "60b8d6f1e1b9b1d8c6c0d8e1" } ``` ```json 400 theme={null} { "error": "Invalid file format", "message": "Only VTT files are supported", "code": "INVALID_FILE_FORMAT" } ``` ```json 404 theme={null} { "error": "Project not found", "message": "No project found with the provided projectId", "code": "PROJECT_NOT_FOUND" } ``` ```json 413 theme={null} { "error": "File too large", "message": "Maximum file size is 1GB", "code": "FILE_TOO_LARGE" } ``` ```json 401 theme={null} { "error": "Unauthorized", "message": "Invalid or missing API key", "code": "UNAUTHORIZED" } ``` # Upload Folder Document Source: https://api-docs.ollang.com/apis/ollang-api-reference/upload-folder-document POST https://api-integration.ollang.com/integration/folder/{folderId}/docs/upload Upload a guideline, glossary, or character list to a folder as a file, without hosting it yourself Attaches a folder-level document by sending the file itself as `multipart/form-data`. Use this when you have the file locally and do not want to host it or generate a pre-signed URL first. This is the same operation as [Attach Folder Document](/apis/ollang-api-reference/attach-folder-document); only the way you supply the file differs. The document is applied to every project that already exists in the folder **and** to projects created in it afterwards, including projects created through [Direct File Upload](/apis/ollang-api-reference/direct-file-upload). Send the file in a form field named `file`. The file must be smaller than 50 MiB (52,428,800 bytes). Files at or above this limit return `413`. ```bash cURL theme={null} curl -X POST "https://api-integration.ollang.com/integration/folder/60b8d6f1e1b9b1d8c6c0d8e1/docs/upload" \ -H "X-Api-Key: " \ -H "Content-Type: multipart/form-data" \ -F "file=@/path/to/brand-guideline-v3.pdf" \ -F "type=guideline" \ -F "name=Brand guideline v3" \ -F "language=en" ``` ```javascript JavaScript theme={null} const folderId = "60b8d6f1e1b9b1d8c6c0d8e1"; const formData = new FormData(); formData.append("file", guidelineFile); formData.append("type", "guideline"); formData.append("name", "Brand guideline v3"); formData.append("language", "en"); const response = await fetch( `https://api-integration.ollang.com/integration/folder/${folderId}/docs/upload`, { method: "POST", headers: { "X-Api-Key": "", }, body: formData, }, ); const doc = await response.json(); console.log("Attached document:", doc.id); ``` ```python Python theme={null} import requests folder_id = "60b8d6f1e1b9b1d8c6c0d8e1" files = {'file': open('brand-guideline-v3.pdf', 'rb')} data = { 'type': 'guideline', 'name': 'Brand guideline v3', 'language': 'en', } headers = {'X-Api-Key': ''} response = requests.post( f'https://api-integration.ollang.com/integration/folder/{folder_id}/docs/upload', files=files, data=data, headers=headers, ) doc = response.json() print("Attached document:", doc["id"]) ``` ```php PHP theme={null} $folderId = '60b8d6f1e1b9b1d8c6c0d8e1'; $curl = curl_init(); curl_setopt_array($curl, array( CURLOPT_URL => "https://api-integration.ollang.com/integration/folder/{$folderId}/docs/upload", CURLOPT_RETURNTRANSFER => true, CURLOPT_POST => true, CURLOPT_POSTFIELDS => array( 'file' => new CURLFile('/path/to/brand-guideline-v3.pdf'), 'type' => 'guideline', 'name' => 'Brand guideline v3', 'language' => 'en', ), CURLOPT_HTTPHEADER => array( 'X-Api-Key: ' ), )); $response = curl_exec($curl); $doc = json_decode($response, true); curl_close($curl); echo "Attached document: " . $doc['id']; ``` ```go Go theme={null} package main import ( "bytes" "encoding/json" "fmt" "io" "mime/multipart" "net/http" "os" ) func main() { folderID := "60b8d6f1e1b9b1d8c6c0d8e1" url := "https://api-integration.ollang.com/integration/folder/" + folderID + "/docs/upload" body := &bytes.Buffer{} writer := multipart.NewWriter(body) file, _ := os.Open("brand-guideline-v3.pdf") defer file.Close() part, _ := writer.CreateFormFile("file", "brand-guideline-v3.pdf") io.Copy(part, file) writer.WriteField("type", "guideline") writer.WriteField("name", "Brand guideline v3") writer.WriteField("language", "en") writer.Close() req, _ := http.NewRequest("POST", url, body) req.Header.Set("X-Api-Key", "") req.Header.Set("Content-Type", writer.FormDataContentType()) client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() respBody, _ := io.ReadAll(resp.Body) var doc map[string]interface{} json.Unmarshal(respBody, &doc) fmt.Println("Attached document:", doc["id"]) } ``` ```java Java theme={null} String folderId = "60b8d6f1e1b9b1d8c6c0d8e1"; HttpResponse response = Unirest .post("https://api-integration.ollang.com/integration/folder/" + folderId + "/docs/upload") .header("X-Api-Key", "") .field("file", new File("brand-guideline-v3.pdf")) .field("type", "guideline") .field("name", "Brand guideline v3") .field("language", "en") .asString(); JSONObject doc = new JSONObject(response.getBody()); System.out.println("Attached document: " + doc.getString("id")); ``` ## Authorizations This endpoint requires API key authentication. Include your API key in the request header: * **Header name**: `X-Api-Key` * **Header value**: Your API key from the Ollang dashboard * **Format**: `X-Api-Key: your-api-key-here` The API key user needs write access to the folder. Keys without a folder-write role receive a `403`. ## Path Parameters The unique identifier of the folder to attach the document to. Retrieve folder IDs with [Retrieve All Folders](/apis/ollang-api-reference/retrieve-all-folders). ## Body Parameters Send the request as `multipart/form-data`. The document to upload, smaller than 50 MiB (52,428,800 bytes). The kind of folder document. One of: * `guideline` — style and tone guidance * `guideline_glossary` — terminology list * `character_list` — character names and notes Display name of the document. Defaults to the uploaded file's own name. BCP-47 language tag of the document (e.g. `en`). When omitted, each project copy uses that project's source language. ## Response Returns the created folder document, identical to [Attach Folder Document](/apis/ollang-api-reference/attach-folder-document). Unique identifier of the folder document. Pass this to [Remove Folder Document](/apis/ollang-api-reference/delete-folder-document). Display name of the document. One of `guideline`, `guideline_glossary`, or `character_list`. Location of the stored copy Ollang created. Size of the stored document in bytes. The `language` supplied with the request, or `null`. Identifier of the folder the document is attached to. When the document was attached, in ISO 8601 format. ```json 201 theme={null} { "id": "60b8d6f1e1b9b1d8c6c0d8f1", "name": "Brand guideline v3", "type": "guideline", "url": "https://ollang-docs.s3.eu-central-1.amazonaws.com/60b8d6f1e1b9b1d8c6c0d8e5/brand-guideline-v3.pdf", "size": 481203, "sourceLanguage": "en", "folderId": "60b8d6f1e1b9b1d8c6c0d8e1", "clientId": "60b8d6f1e1b9b1d8c6c0d8e5", "createdAt": "2026-09-04T09:11:02.310Z", "updatedAt": "2026-09-04T09:11:02.310Z" } ``` ```json 413 theme={null} { "code": -1, "error": "UnknownError", "message": "unknown error", "detail": "File too large" } ``` ```json 401 theme={null} { "error": "Unauthorized", "message": "Invalid or missing API key", "code": "UNAUTHORIZED" } ``` ```json 403 theme={null} { "statusCode": 403, "message": "You do not have permission to modify this folder", "error": "Forbidden" } ``` ```json 404 theme={null} { "statusCode": 404, "message": "Folder not found", "error": "Not Found" } ``` # AssemblyAI Source: https://api-docs.ollang.com/apis/stt-apis/assemblyai AssemblyAI Universal speech-to-text — 99-language transcription with speech intelligence, plus a higher-accuracy code-switching tier. **AssemblyAI** is a speech AI platform whose Universal model line pairs broad language coverage with built-in speech intelligence — diarization, sentiment, topic detection, and PII redaction produced in the same pass as the transcript. **Available in Ollang Workflows** as `assemblyai` — Closed Captions, Subtitle Translation, and AI Dubbing. See the [Speech-to-Text catalog](/providers/speech-to-text). ## Models The model line splits along a breadth-versus-accuracy axis: | Model | Languages | Positioned for | | - | - | - | | **Universal-2** | 99 | Broad coverage for general transcription | | **Universal-3.5 Pro** | 21 (18 base languages plus regional variants) | Highest accuracy AssemblyAI has released, with native code-switching | Universal-3.5 Pro handles speakers who slip between languages mid-sentence — English–Spanish code-mixing is called out explicitly — without breaking the transcript into separate language segments. ## Key capabilities * **99 languages** on Universal-2 — the highest published language count in this catalog. AWS Transcribe lists more entries, but many are locale variants of the same language. * **Custom vocabulary** — measurably improves handling of product names, people names, and domain jargon, which is where generic transcription most often fails a localization workflow. * **Speaker diarization** in the same pass, so speaker turns arrive with the transcript rather than needing a second alignment step. * **Speech intelligence** — sentiment analysis, topic detection, and PII redaction for regulated or sensitive content. * **Automatic language detection** for mixed or unknown-language source material. ## Where it fits in a workflow This is the default choice for **volume on reasonable audio**: podcasts, meetings, interviews, broadcast content, and back catalogs. On clean single-speaker material its transcripts are comparable to [Agentic STT](/apis/stt-apis/ollang-agentic-stt) without the multi-agent pass. It sits alongside [ElevenLabs Scribe v2](/apis/stt-apis/elevenlabs-scribe) as the other single-model workhorse. The split between them is straightforward: AssemblyAI for mainstream languages and speech intelligence, Scribe for under-resourced languages, high speaker counts, and audio-event tagging. ## Trade-offs * **The highest-accuracy tier covers 21 languages, not 99.** Confirm which tier serves your language before assuming top-tier accuracy. * Accuracy drops on heavily accented speech, noisy environments, and messy conversational audio — as it does for every single-pass model. That is where [Agentic STT](/apis/stt-apis/ollang-agentic-stt) or [Speechmatics](/apis/stt-apis/speechmatics) earn their premium. ## Reference * [Speech-to-Text provider catalog](/providers/speech-to-text) * [AssemblyAI supported languages](https://www.assemblyai.com/docs/speech-to-text/pre-recorded-audio/supported-languages) # Amazon Transcribe Source: https://api-docs.ollang.com/apis/stt-apis/aws-transcribe Amazon Transcribe speech-to-text — 100+ languages and locales with nine English variants, automatic language identification, and AWS-native compliance controls. **Amazon Transcribe** is AWS's managed automatic speech recognition service. Its strongest argument is fit rather than accuracy: for organizations already standardized on AWS, transcription stays inside an existing security, IAM, and data-residency perimeter. It covers **more than 100 languages and locale variants** across batch and streaming, though feature support varies sharply by language — worth checking before a Workflow depends on it. **Available in Ollang Workflows** as `aws` — Closed Captions, Subtitle Translation, and AI Dubbing. See the [Speech-to-Text catalog](/providers/speech-to-text). ## Locale depth Amazon Transcribe's real differentiator is how finely it splits major languages: | Language | Locales | | - | - | | English | US, British, Australian, Indian, Irish, New Zealand, Scottish, South African, Welsh | | Spanish | Spain, Mexican, US | | Arabic | Gulf, Modern Standard | | Chinese | Simplified, Traditional, Cantonese | | Portuguese | Portugal, Brazilian | | Swahili | Kenya, Burundi, Rwanda, Tanzania, Uganda | For English- and Spanish-dominant programs, that granularity means the recognizer is matched to the accent rather than approximating it. ## Feature availability by language This is the part worth reading before committing: | Feature | Coverage | | - | - | | Batch transcription | All supported languages | | Streaming transcription | Most, but not all — and unavailable for some languages in certain AWS regions | | Custom vocabulary and acronyms | Most supported languages | | **Custom language models** | Only `en-AU`, `en-GB`, `en-US`, `es-US`, `de-DE`, `ja-JP`, and `hi-IN` (batch only) | | **PII redaction** | English dialects, French, Italian, Portuguese, Spanish | | Call Analytics | Selected languages; some insights are English-only | ## Key capabilities * **Automatic language identification** across both batch and streaming, including audio containing more than one language. * **Custom vocabularies** to raise accuracy on domain terms, and custom language models on the seven locales that support them. * **Content filtering and PII redaction** for regulated material. * **Word-level timestamps** for alignment and indexing. * **AWS-native integration** — IAM, VPC, KMS, and regional controls apply without additional plumbing, and Transcribe chains directly into [Amazon Translate](/apis/translation-apis/amazon-translate) and Amazon Polly. ## Where it fits in a workflow Select Amazon Transcribe when the AWS alignment is the requirement — compliance posture, data residency, or an existing media pipeline built on AWS services — and your working languages are English or Spanish variants. ## Trade-offs * **No general accuracy advantage** over [AssemblyAI](/apis/stt-apis/assemblyai) or [ElevenLabs Scribe v2](/apis/stt-apis/elevenlabs-scribe) on ordinary media content — its case rests on AWS alignment and locale depth. * **Customization is narrower than it appears** — custom language models reach only seven locales, and redaction only five language groups. * Streaming availability varies by language and by AWS region. ## Reference * [Speech-to-Text provider catalog](/providers/speech-to-text) * [Amazon Transcribe supported languages](https://docs.aws.amazon.com/transcribe/latest/dg/supported-languages.html) # Deepgram Source: https://api-docs.ollang.com/apis/stt-apis/deepgram Deepgram speech recognition — the Nova model line for fast, high-throughput transcription, with flexible cloud, on-premises, and hybrid deployment. **Deepgram** builds voice AI models for both directions of the pipeline: speech recognition through its **Nova** line and speech synthesis through **Aura**. The company's emphasis throughout is throughput and latency rather than maximum accuracy on difficult audio. In Ollang Workflows, Deepgram is available as a **text-to-speech** provider (`deepgram`). See [Deepgram Aura Text-to-Speech](/apis/tts-apis/deepgram-aura). This page documents the speech recognition side for reference; Ollang's transcription providers are listed in the [Speech-to-Text catalog](/providers/speech-to-text). ## Model and coverage | | | | - | - | | **STT model line** | Nova (Nova-2, Nova-3) | | **Languages** | 30+ languages and dialects | | **Modes** | Batch and real-time streaming | | **Deployment** | Cloud, on-premises, or hybrid | Deepgram's advantage is throughput and latency rather than accuracy on mixed-language audio, where AssemblyAI's Universal-3.5 Pro and ElevenLabs Scribe v2 are the stronger documented options. ## Key capabilities * **Real-time processing** with low latency, built for live captioning and voice agents. * **Custom model training** on domain vocabularies where standard models under-perform. * **Flexible deployment** across cloud, on-premises, and hybrid, for privacy and residency requirements. * **GPU-based inference** enabling high parallelism relative to CPU-bound alternatives. ## Reference * [Deepgram Aura Text-to-Speech](/apis/tts-apis/deepgram-aura) * [Speech-to-Text provider catalog](/providers/speech-to-text) * [Deepgram documentation](https://developers.deepgram.com/) # ElevenLabs Scribe Source: https://api-docs.ollang.com/apis/stt-apis/elevenlabs-scribe ElevenLabs Scribe v2 speech-to-text — 90+ languages with published per-language accuracy tiers, 32-speaker diarization, entity detection, and audio-event tagging. **ElevenLabs Scribe** is ElevenLabs' automatic speech recognition model. Scribe v2 transcribes **90+ languages**, and it is the most transparent provider in the catalog about where it is and is not accurate: ElevenLabs publishes a per-language accuracy tier for every supported language. **Available in Ollang Workflows** as `elevenlabs-scribe-v2` — Closed Captions, Subtitle Translation, and AI Dubbing. See the [Speech-to-Text catalog](/providers/speech-to-text). ## Models | Model | Languages | Latency | Notable | | - | - | - | - | | **Scribe v2** | 90+ | Batch | Diarization up to 32 speakers, entity detection, dynamic audio tagging | | **Scribe v2 Realtime** | 90+ | \~150 ms | Streaming, voice activity detection, manual commit control | ## Published accuracy tiers Rather than quoting a single headline accuracy figure, ElevenLabs classifies each supported language into a word error rate band, from **Excellent** (5% WER or below) down to **Moderate** (25–50% WER). This is the single most useful thing about the provider from a workflow-planning perspective: you can check the tier for your specific language before committing a Workflow, instead of discovering the answer in review. Treat the language list as a set of tiers, not as a flat 90. ## Key capabilities * **Speaker diarization up to 32 speakers** — the highest documented ceiling in the catalog, which matters for panels, roundtables, town halls, and large meetings where other providers collapse speakers together. * **Dynamic audio tagging** — non-speech events such as laughter and applause are captured as `audio_event` entries rather than dropped, which feeds accessibility caption requirements directly. * **Entity detection across 65 types**, for structured extraction alongside the transcript. * **Keyterm prompting with up to 1,000 terms** — a large vocabulary budget for enforcing product names, character names, and domain terminology. * **Precise word-level timestamps**, giving subtitle segmentation more to work with, which shows up in reading-rate compliance. ## Where it fits in a workflow Reach for Scribe v2 when the source is in a language outside the mainstream 30, when the recording has many speakers, or when non-speech audio events need to appear in the captions. For monolingual, mainstream-language content it and [AssemblyAI](/apis/stt-apis/assemblyai) are close substitutes, so the choice comes down to which one benchmarks better on your material — and AssemblyAI's Universal-3.5 Pro tier is the stronger documented option for English–Spanish code-switching specifically. ## Trade-offs * **Accuracy varies widely by language.** The published tiers span under 5% WER to over 25%; a language in the lower bands will need review time budgeted accordingly. * On unclear or silent passages, transcription models of this class can emit fluent text that was never spoken. That failure mode does not look like an error in the transcript, so validate anything going straight to a deliverable. ## Reference * [Speech-to-Text provider catalog](/providers/speech-to-text) * [ElevenLabs speech-to-text capabilities](https://elevenlabs.io/docs/capabilities/speech-to-text) # Google Cloud Speech-to-Text Source: https://api-docs.ollang.com/apis/stt-apis/google-cloud-stt **Google Cloud Speech-to-Text** is a powerful and flexible API service that enables developers to convert audio to text using Google's advanced machine learning models. ## Key Features * **High Accuracy**: Utilizes advanced neural network models to provide highly accurate speech recognition. * **Real-Time and Batch Processing**: Supports both real-time streaming and batch processing of audio files. * **Multilingual Support**: Transcribes audio in over 120 languages and variants, making it suitable for global applications. * **Customization**: Allows customization of speech models to improve accuracy for specific use cases and environments. ## Advanced Technologies * **Auto-Punctuation**: Automatically adds punctuation to the transcribed text, improving readability without requiring manual editing. * **Speaker Diarization**: Identifies and labels different speakers in multi-speaker audio, making it easier to follow conversations. * **Profanity Filtering**: Detects and filters out inappropriate language in the transcriptions. * **Noise Robustness**: Effectively transcribes audio even in noisy environments, thanks to advanced noise handling capabilities. ## Use Cases 1. **Customer Service**: Enhances call center operations by providing accurate transcriptions of customer interactions, enabling better analysis and training. 2. **Content Creation**: Assists content creators by transcribing audio and video files, making it easier to create subtitles and searchable archives. 3. **Accessibility**: Improves accessibility by providing real-time transcriptions for individuals with hearing impairments. # IBM Watson Speech to Text Source: https://api-docs.ollang.com/apis/stt-apis/ibm-watson-stt **IBM Watson Speech to Text** is a robust and flexible AI-powered service designed to convert human speech into written text with high accuracy. This service is ideal for a range of applications, including customer care, call analytics, and voice-automated chatbots. ## Key Features * **High Accuracy**: Leverages deep learning AI to understand grammar, language structure, and the composition of audio and voice signals, providing highly accurate transcriptions. * **Customization**: Supports language and acoustic model customization to improve accuracy for specific domains and audio characteristics. Users can also create custom dictionaries and grammars. * **Multilingual Support**: Supports numerous languages and dialects, including English, French, German, Spanish, Italian, Japanese, Korean, Brazilian Portuguese, and more. * **Deployment Flexibility**: Available as a managed cloud service, on-premises, or in hybrid environments, offering flexibility to meet various security and operational requirements. ## Advanced Technologies * **Smart Formatting**: Converts dates, times, numbers, currency values, email addresses, and other entities into conventional written forms in final transcripts. * **Speaker Diarization**: Identifies and differentiates between multiple speakers in a conversation, currently optimized for two-way call center conversations but can detect up to six speakers. * **Low Latency**: Optimized for low-latency real-time speech applications, making it suitable for live interactions and immediate transcriptions. * **Audio Diagnostics**: Analyzes and corrects weak audio signals before transcription begins, ensuring higher quality outputs. ## Use Cases 1. **Customer Self-Service**: Enhances virtual assistants to handle common call center queries using Watson's advanced AI capabilities. 2. **Call Analytics**: Analyzes conversation logs to identify patterns, customer complaints, sentiment, and compliance issues, improving call center performance. 3. **Agent Assistance**: Provides real-time transcription and search capabilities to assist call center agents during live interactions, enhancing productivity and customer satisfaction. # Ollang Agentic STT Source: https://api-docs.ollang.com/apis/stt-apis/ollang-agentic-stt Ollang's multi-agent transcription workflow — Agentic STT, Agentic STT-1.2, and Visual STT — for complex multimedia, noisy audio, and on-screen text. **Ollang Agentic STT** is Ollang's own transcription workflow and the default provider for every `transcribe` step. Unlike a single-model ASR service, it runs a collaborative multi-agent pass: several interpretations of the same audio are produced and reconciled, speaker attribution is resolved across the whole timeline, and surrounding context — including non-speech audio cues — is used to choose between readings that a single model would have to guess at. **Available in Ollang Workflows** — Closed Captions, Subtitle Translation, and AI Dubbing. See the [Speech-to-Text catalog](/providers/speech-to-text) for the full comparison. ## Models | Model | Provider tag | Status | | - | - | - | | Agentic STT | `ollangAITranscribe` | **Default** | | Agentic STT-1.2 | `ollang-stt-1.2-exp` | Experimental | | Visual STT | `agentic-visual-transcription` | Experimental | ## Key capabilities * **Multi-agent reconciliation** — competing transcription hypotheses are compared rather than accepted, which is what produces the accuracy gain on ambiguous audio. * **Noise and accent robustness** — built for real-world source material: field recordings, conference audio, overlapping speakers, and wide accent diversity. * **Multi-language streams** — handles video and audio where more than one language is present, without forcing a single language assumption across the file. * **Contextual audio cues** — non-speech information is treated as signal, which matters when the transcript becomes a dubbing script rather than a reading transcript. * **Stable speaker attribution** — speaker identity holds across long-form content instead of drifting between segments. ## Visual STT Visual STT is a different modality in the same family. Instead of transcribing speech, it reads **on-screen text** from video frames and converts it into editable, timecoded text content. It is the right provider when the message lives in the picture rather than the audio: * silent video and sound-off social content, * burned-in captions and subtitles, * title cards, lower thirds, and kinetic typography, * product and UI demos where the interface text carries the meaning. Because it transcribes what is displayed rather than what is said, content with meaningful speech *and* meaningful on-screen text usually needs both an audio pass and a visual pass. ## Where it fits in a workflow Agentic STT is the default because transcription errors do the most damage of any in the pipeline — everything downstream inherits them. A mistranscribed name becomes a mistranslated name and then a mispronounced one in the dub. Choose it when the source audio is genuinely difficult. On clean, single-speaker studio narration, [AssemblyAI](/apis/stt-apis/assemblyai) or [ElevenLabs Scribe v2](/apis/stt-apis/elevenlabs-scribe) deliver comparable transcripts in a single pass. ## Trade-offs * **Throughput** — a multi-agent pass does more work than a single model call, so it is slower on large batches. What it buys is robustness, not speed. * **Experimental tiers** — Agentic STT-1.2 and Visual STT may change between releases. Run them in a benchmarking Folder alongside your production provider rather than switching a Global Workflow to them. ## Reference * [Speech-to-Text provider catalog](/providers/speech-to-text) * [Workflows and provider architecture](/workflows-provider-architecture) * [Order types](/apis/ollang-api-reference/order-types) # Rev.ai Source: https://api-docs.ollang.com/apis/stt-apis/rev-ai **Rev.ai** provides a suite of speech recognition and transcription services powered by advanced machine learning models, making it one of the most accurate speech-to-text APIs available. ## Key Features * **High Accuracy**: Utilizes state-of-the-art neural network models to deliver highly accurate speech-to-text transcriptions. * **Real-Time and Batch Processing**: Supports both real-time streaming and asynchronous batch processing of audio files. * **Multilingual Support**: Offers transcription services in multiple languages, suitable for diverse global applications. * **Customization**: Allows users to create custom vocabularies to enhance accuracy for specific terminologies and industries. ## Advanced Technologies * **Auto-Punctuation and ITN**: Automatically adds punctuation and performs inverse text normalization, converting spoken-form text into written-form text, including dates, times, and phone numbers. * **Speaker Diarization**: Identifies and labels different speakers in multi-speaker audio, making it easier to follow conversations. * **Profanity Filtering**: Detects and filters out inappropriate language in the transcriptions. * **Disfluency Removal**: Filters out disfluencies like "ums" and "uhs" to produce cleaner transcriptions. ## Use Cases 1. **Customer Service**: Enhances call center operations by providing accurate transcriptions of customer interactions for better analysis and training. 2. **Content Creation**: Assists content creators by transcribing podcasts, videos, and meetings, making it easier to create searchable archives and subtitles. 3. **Accessibility**: Improves accessibility by providing real-time transcriptions for individuals with hearing impairments. For more details and to access the API, visit [Rev.ai](https://www.rev.ai). # Speechmatics Source: https://api-docs.ollang.com/apis/stt-apis/speechmatics Speechmatics speech-to-text — 70+ languages across the Enhanced, Standard, and Melia 1 models, with automatic language switching and rule-based smart formatting. **Speechmatics** is a speech recognition specialist whose long-standing focus is accent and dialect coverage rather than benchmark position on clean, standard-accent English. That focus is why it holds up on the audio that degrades generic models most. It covers **70+ individual languages**, plus **7 bilingual language packs** for media where two languages appear in the same file or stream. **Available in Ollang Workflows** as `speechmatics` and `speechmatics-llm` — Closed Captions, Subtitle Translation, and AI Dubbing. See the [Speech-to-Text catalog](/providers/speech-to-text). ## Models | Model | Language handling | Translation | Positioned for | | - | - | - | - | | **Enhanced** | Declared source language | Yes | Highest accuracy operating point | | **Standard** | Declared source language | Yes | Faster transcription | | **Melia 1** | Switches automatically, no language selection | No | Genuinely multilingual speakers and spontaneous code-switching | **Melia 1** is the distinctive one. It transcribes without being told the source language and follows speakers who switch language spontaneously — the cleanest answer in the catalog for content where you cannot predict, per file, what will be spoken. Its trade-off is that it does not support translation, so it is a transcription-only choice. Bilingual packs cover fixed language combinations and are the alternative when you know in advance which two languages appear. ## Key capabilities * **Accent and dialect robustness** — consistently strong where regional accents and lesser-resourced dialects appear, which is the most common cause of unexplained quality drops in localization pipelines. * **Speaker diarization** and a **custom dictionary** for improving recognition of specific words and phrases. * **Smart formatting applied by default** — spoken numbers, dates, currencies, and measurements converted into conventional written forms, which is a real saving on subtitle cleanup. * **Profanity tagging, disfluency removal, and regex-based word replacement** for house formatting conventions. * **Translation** on Enhanced and Standard, with English translating to and from 34 target languages, plus Norwegian Bokmål to and from Nynorsk. * **Flexible deployment** — cloud, on-premises, or hybrid, for data-residency-constrained content. ## Speechmatics with LLM The `speechmatics-llm` variant adds an LLM post-processing pass that accepts **custom guidelines and instructions**. Speechmatics' built-in formatting is rule-based; this variant adds instruction-driven judgment on top of it. Instead of correcting the same things in review every week, you state them once: speaker label conventions, fixed product terminology, number and date formatting, or client-mandated caption style. It earns its place when the alternative is making the same corrections by hand in review every week. ## Where it fits in a workflow Choose Speechmatics when the source has strong regional accents, when lesser-resourced dialects appear, or when speakers move between languages unpredictably and Melia 1's automatic switching is the feature you need. ## Trade-offs * Little advantage over [AssemblyAI](/apis/stt-apis/assemblyai) or [ElevenLabs Scribe v2](/apis/stt-apis/elevenlabs-scribe) on clean, standard-accent audio — its strengths show up on the material that defeats generic models. * **Automatic language switching and translation are mutually exclusive** — Melia 1 does one, Enhanced and Standard do the other. * 70+ languages is narrower than AssemblyAI's 99 or Scribe's 90+. ## Reference * [Speech-to-Text provider catalog](/providers/speech-to-text) * [Speechmatics supported languages](https://docs.speechmatics.com/introduction/supported-languages) # Whisper Source: https://api-docs.ollang.com/apis/stt-apis/whisper OpenAI Whisper — the open-source ASR baseline most transcription comparisons are measured against, and its well-documented hallucination failure mode. Whisper is **not currently selectable** in Ollang Workflows. It remains documented because it is the open-source reference baseline that most comparisons in this catalog are measured against, and because self-hosted Whisper deployments are common in customer-side pipelines. For providers you can select today, see the [Speech-to-Text catalog](/providers/speech-to-text). **Whisper** is OpenAI's open-source automatic speech recognition model, trained on **680,000 hours** of multilingual and multitask supervised audio. Its breadth of training data is why it handles noisy environments, varied accents, and poor-quality recordings better than most openly available alternatives, and why it became the default self-hosted choice. ## Model and coverage | | | | - | - | | **Training data** | 680,000 hours, multilingual and multitask | | **Languages** | 90+, with usable quality across roughly 50 | | **Language detection** | Automatic | | **License** | Open source, self-hostable | ## Key capabilities * **Robust across acoustic conditions** — background noise, varied recording quality, and accent diversity. * **Automatic language detection** without a specified language code. * **Self-hostable**, which is the deciding factor for data-residency-constrained workloads. * **Open ecosystem** — WhisperX and Whisper-JAX add alignment, diarization, and throughput improvements on top of the base model. ## Trade-offs * **Hallucination on silence and low-quality segments** is the documented failure mode. Whisper will confidently emit fluent text for audio containing none, and the output does not look like an error in the transcript. This is the primary reason hosted providers are preferred for deliverable-grade output. * No managed diarization, speech intelligence, or SLA in the base model — those come from the surrounding tooling you build or buy. ## Reference * [Speech-to-Text provider catalog](/providers/speech-to-text) * [WhisperX](/apis/stt-apis/whisperx) and [Whisper-JAX](/apis/stt-apis/whisper-jax) # Whisper JAX Source: https://api-docs.ollang.com/apis/stt-apis/whisper-jax **Whisper JAX** is a JAX/Flax implementation of OpenAI's Whisper model that provides significant performance improvements through GPU acceleration and optimized inference. It's designed for high-throughput speech recognition applications requiring fast processing speeds. ## Key Capabilities * **High Performance**: Leverages JAX's just-in-time compilation and GPU acceleration for significantly faster inference compared to PyTorch implementations. * **Batch Processing**: Efficiently processes multiple audio files simultaneously, making it ideal for large-scale transcription tasks. * **Memory Efficient**: Optimized memory usage allows for processing longer audio files and larger batch sizes. * **Multilingual Support**: Maintains Whisper's multilingual capabilities with improved processing speed. * **Open Source**: Available as an open-source implementation with active community support. ## Advanced Features * **Parallel Processing**: Utilizes JAX's parallel computing capabilities for efficient multi-GPU processing. * **Customizable Models**: Supports all Whisper model variants with optimized performance for each size. * **Real-time Processing**: Capable of near real-time transcription for streaming applications. * **Cloud Integration**: Designed to work seamlessly with cloud computing platforms and TPU accelerators. ## Use Cases 1. **Large-Scale Transcription**: Ideal for processing large volumes of audio files in batch operations. 2. **Real-time Applications**: Suitable for live transcription services requiring low latency. 3. **Research and Development**: Supports AI research requiring fast iteration and experimentation with speech models. 4. **Enterprise Solutions**: Provides the performance needed for enterprise-scale transcription services. For more details and to access the implementation, visit [Whisper JAX GitHub](https://github.com/sanchit-gandhi/whisper-jax). # WhisperX Source: https://api-docs.ollang.com/apis/stt-apis/whisperx **WhisperX** is an enhanced version of OpenAI's Whisper model that provides additional capabilities including speaker diarization, word-level timestamps, and improved accuracy. It's designed for more advanced speech recognition tasks that require detailed audio analysis. ## Key Capabilities * **Speaker Diarization**: Automatically identifies and separates different speakers in multi-speaker audio recordings. * **Word-Level Timestamps**: Provides precise timing information for each word, enabling accurate subtitle generation and audio synchronization. * **Enhanced Accuracy**: Builds upon Whisper's foundation with improved performance on challenging audio conditions. * **Multilingual Support**: Inherits Whisper's multilingual capabilities while adding speaker identification features. * **Open Source**: Available as an open-source project, allowing for customization and community contributions. ## Advanced Features * **Forced Alignment**: Uses forced alignment techniques to improve word-level timestamp accuracy. * **Speaker Segmentation**: Automatically segments audio by speaker without requiring pre-training on specific voices. * **Batch Processing**: Efficiently processes multiple audio files with consistent speaker identification. * **Customizable Models**: Supports various Whisper model sizes for different accuracy and speed requirements. ## Use Cases 1. **Meeting Transcription**: Ideal for transcribing business meetings with multiple participants, automatically identifying who said what. 2. **Podcast Production**: Helps create detailed transcripts with speaker identification for podcast editing and accessibility. 3. **Academic Research**: Supports research requiring detailed analysis of multi-speaker conversations and interviews. 4. **Content Creation**: Enables automatic generation of captions and subtitles with speaker labels for video content. For more details and to access the implementation, visit [WhisperX GitHub](https://github.com/m-bain/whisperX). # Amazon Translate Source: https://api-docs.ollang.com/apis/translation-apis/amazon-translate Amazon Translate in Ollang — neural machine translation across 75 languages with Custom Terminology, Active Custom Translation, Formality, and Brevity controls. **Amazon Translate** is AWS's neural machine translation service, covering **75 languages and variants** — including languages that are thinly supported elsewhere, such as Afrikaans, Armenian, Azerbaijani, Dari, Hausa, Haitian Creole, Pashto, Sinhala, Somali, Uzbek, and Welsh. Its distinguishing value in this catalog is **output control** rather than raw model capability. **Available in Ollang Workflows** as `aws` — Document Translation, Subtitle Translation, and AI Dubbing. See the [Translation catalog](/providers/translation). ## Customization controls | Control | What it does | | - | - | | **Custom Terminology** | Upload CSV or TMX files to force specific renderings of brand, product, and industry terms. Recent versions generate contextually appropriate grammatical forms of matched terms rather than substituting them verbatim. | | **Active Custom Translation** | Adapts the engine using your own parallel data, without training a bespoke model. | | **Formality** | Selects register in the languages that support it. | | **Brevity** | Constrains output length — genuinely useful for subtitle work, where character limits bind and expansion into a longer target language breaks reading rates. | | **Profanity masking** | Masks profane words and phrases where content standards require it. | Brevity is the underrated one for localization: most engines will happily produce a target string 40% longer than the source, which then has to be cut by hand to fit the subtitle. ## Key capabilities * **75 languages** with real-time document translation supported from English into any supported language and back. * **Real-time and batch** processing from the same service. * **AWS-native security** — encryption in transit, with IAM, VPC, and regional controls applying as they do across AWS. * **Direct chaining** with [Amazon Transcribe](/apis/stt-apis/aws-transcribe) and Amazon Polly, and with S3, Lambda, and Comprehend for pipeline work. ## Where it fits in a workflow For organizations with a mature translation memory and hard terminology requirements, the Custom Terminology and Active Custom Translation combination is often worth more than a higher-capability general model that has to be re-steered on every Order. It is also a natural fit where the wider pipeline already runs on AWS, alongside Amazon Transcribe in the `transcribe` step. ## Trade-offs * **NMT, not an LLM.** No nuanced instruction-following, cultural adaptation, or reasoning about ambiguous source text. * No general quality advantage over [DeepL](/apis/translation-apis/deepl) or [Agentic Turbo](/apis/translation-apis/ollang-agentic-localization) — its case rests entirely on terminology control, Brevity, and AWS alignment. ## Reference * [Translation provider catalog](/providers/translation) * [Amazon Translate supported languages](https://docs.aws.amazon.com/translate/latest/dg/what-is-languages.html) * [Amazon Transcribe](/apis/stt-apis/aws-transcribe) # Anthropic Claude for Translation Source: https://api-docs.ollang.com/apis/translation-apis/anthropic-claude Claude models in Ollang — Claude 5 Fable, Opus, and Sonnet with 1M-token context, plus the legacy 4.x tiers — for long-form coherence and terminology consistency. **Claude** is Anthropic's language model family, and consistently the strongest option in this catalog for **long-form coherence**: holding register, terminology, and voice steady across an entire document rather than segment by segment. Those qualities show up in human review rather than in automatic scores, which is why Claude tends to reduce edit distance more than its benchmark position predicts. Every current Claude model carries a **1M-token context window with 128K maximum output** and adaptive thinking, and supports text and image input. On Anthropic's current tokenizer, 1M tokens is roughly **555,000 words** — enough to hold most book-length source material in a single pass. **Available in Ollang Workflows** — all Claude tiers serve Document Translation, Subtitle Translation, and AI Dubbing. See the [Translation catalog](/providers/translation). ## Models | Model | Provider tag | Anthropic positioning | Status | | - | - | - | - | | Claude 5 Fable | `anthropic/claude-fable-5` | Highest available capability | **New** | | Claude 5 Opus | `anthropic/claude-opus-5` | Complex agentic and enterprise work | **New** | | Claude 5 Sonnet | `anthropic/claude-sonnet-5` | Best combination of speed and intelligence | **New** | | Claude 4.7 Opus | `anthropic/claude-opus-4.7` | Legacy | Available | | Claude 4.5 Opus | `anthropic/claude-opus-4.5` | Legacy | Available | | Claude 4.5 Sonnet | `anthropic/claude-4.5-sonnet` | Legacy | Available | | Claude 4 Sonnet | `claude` | Superseded | Available | ## Choosing a tier **Claude 5 Fable** is Anthropic's highest-capability model, described as next-generation intelligence for long-running agents. Its thinking is adaptive and always on, and its comparative latency is the slowest in the lineup. Reserve it for genuinely hard source material — dense technical or legal text, structurally ambiguous documents, or work that would otherwise need a second human pass. **Claude 5 Opus** offers the same 1M context and 128K output, and carries the most recent knowledge cutoff in the family. For quality-critical localization it is the sensible default within Claude. **Claude 5 Sonnet** is positioned by Anthropic as the best combination of speed and intelligence, and is the throughput-oriented tier of the current family. If a Workflow currently runs Claude 4 or 4.5 Sonnet, this is a straight upgrade. **Claude 4.7 Opus**, **4.5 Opus**, **4.5 Sonnet**, and **4 Sonnet** remain selectable for Workflows with an existing benchmark. Each is now matched or beaten by its Claude 5 equivalent. ## Where it fits in a workflow Claude is the family to reach for when a translation has to read as though one person wrote it: books, courses, help centers, brand-critical marketing, and any document set where terminology drift across sections is the failure mode you are trying to prevent. The 1M-token window means an entire set can be translated in one context rather than chunked, which is what actually produces the consistency. Pair it with [Memory and custom instructions](/memory-guidelines-custom-instructions) — Claude follows detailed style and terminology guidance reliably, so the steering investment compounds across Orders. ## Trade-offs * Fable's latency is the slowest in the lineup. Use it deliberately on hard material, not as a default. * The 4.x tiers are superseded on capability by their Claude 5 equivalents. ## Reference * [Translation provider catalog](/providers/translation) * [Claude models overview](https://platform.claude.com/docs/en/about-claude/models/overview) # Cohere for Translation Source: https://api-docs.ollang.com/apis/translation-apis/cohere Cohere Command A in Ollang — 256K-context enterprise translation across 23 business languages, with best-in-class grounding for cross-lingual RAG. **Cohere** builds models for enterprise deployment: secure, fast, and predictable rather than maximally capable. **Command A** (`command-a-03-2025`) is its agent-optimized flagship, carrying a **256K-token context window** and built for tool use, agents, retrieval-augmented generation, and multilingual work. **Available in Ollang Workflows** as `cohere/command-a` — Document Translation, Subtitle Translation, and AI Dubbing. See the [Translation catalog](/providers/translation). ## Coverage Command A covers the **23 languages of global business**: English, French, Spanish, Italian, German, Portuguese, Japanese, Korean, Arabic, Chinese, Russian, Polish, Turkish, Vietnamese, Dutch, Czech, Indonesian, Ukrainian, Romanian, Greek, Hindi, Hebrew, and Persian. That list is narrow next to the 100+ language providers, but its composition is unusual: Arabic, Hebrew, Persian, Ukrainian, Romanian, Czech, and Vietnamese are all first-class rather than long-tail. ## Key capabilities * **256K-token context window** — large enough for whole document sets in a single pass. * **Best-in-class retrieval-augmented generation** with grounding and tool use. This is the strongest fit in the catalog for **cross-lingual RAG**, where a translation must be traceable to an internal source of truth rather than generated freely. * **Efficient deployment footprint**, which is what makes private and VPC deployment realistic for regulated industries. * **Predictable, low-latency inference** for pipelines with throughput commitments. ## Where it fits in a workflow Command A suits enterprise localization where the constraint is **governance rather than capability**: regulated industries, secure environments, or pipelines where translated output must cite internal documentation. Its Middle Eastern and Central/Eastern European coverage is a genuine strength relative to models that treat those languages as an afterthought. ## Trade-offs * **23 languages.** Confirm coverage before committing a Workflow — this is the narrowest language list of any LLM in the translation catalog. * Its maximum output is 8K tokens, shorter than the frontier tiers, which matters for very long single-response Orders. * Tuning favors correctness and groundedness over voice, so it is not the strongest choice for expressive or narrative content. Cohere also publishes **Command A Translate** (`command-a-translate-08-2025`), a dedicated machine translation model covering the same 23 languages, and **Command A+** (`command-a-plus-05-2026`) with text and image input. Ollang's `cohere/command-a` provider runs the general Command A model. ## Reference * [Translation provider catalog](/providers/translation) * [Cohere models](https://docs.cohere.com/docs/models) # DeepL Source: https://api-docs.ollang.com/apis/translation-apis/deepl DeepL neural machine translation in Ollang — 240+ languages with glossaries, translation memory, custom instructions, and an image-in-document variant. **DeepL** is purpose-built neural machine translation rather than a general-purpose LLM. It does one job, does it fast, and does it across **240+ languages and variants** — the widest language coverage in the catalog. It is also considerably more steerable than "machine translation" suggests, which is the part most comparisons miss. **Available in Ollang Workflows** as `deepl` and `deepl_extended` — Document Translation and Subtitle Translation. See the [Translation catalog](/providers/translation). ## Models | Model | Provider tag | Order types | Status | | - | - | - | - | | DeepL | `deepl` | Document, Subtitle | Available | | DeepL Extended | `deepl_extended` | Document, Subtitle | Experimental | DeepL is the one family in this catalog that does **not** serve AI Dubbing Orders. Dubbing scripts need timing-aware, speakable output, which is outside what a pure NMT engine produces. Select a different provider for the `translate` step of a dubbing Workflow. ## Steering controls | Control | What it does | | - | - | | **Glossaries** | Up to five applied per request, for enforced terminology | | **Translation memory** | Applied with an adjustable match threshold | | **Custom instructions** | Up to ten per request, 300 characters each | | **Style rules** | House style applied consistently across a document set | | **Formality** | More or less formal register, in the languages that support it | | **Context** | Text that influences the translation without itself being translated | | **Tag handling** | XML and HTML, with v1 and v2 algorithms | | **`model_type`** | Selects quality-optimized or latency-optimized behavior | The combination of glossaries, translation memory, and custom instructions is what makes DeepL viable for professional document work rather than only for bulk gisting. ## Document translation Formatting is preserved across **docx, pptx, xlsx, pdf, html, txt, xliff, srt, idml, xml, json, dita,** and **mif**. Output can optionally be converted to a different format, and a "Translated by DeepL" watermark can be applied to docx and pdf. **DeepL Extended** adds translation of **images embedded inside documents** — the difference between a translated PDF whose diagrams, charts, and screenshots are still in the source language and one that is genuinely localized. It is marked experimental, so review output before it reaches a deliverable. ## Where it fits in a workflow DeepL is the right answer for **high-volume professional document translation** where the content is functional rather than expressive: manuals, policies, specifications, internal documentation, and knowledge bases. A common configuration overrides DeepL at Folder level for bulk documentation while leaving [Agentic Localization](/apis/translation-apis/ollang-agentic-localization) in place as the Global Workflow default for customer-facing content. ## Trade-offs * **No AI Dubbing support.** * **NMT, not an LLM.** Custom instructions are capped at 300 characters each and it will not reason about ambiguous source text or adapt cultural references the way the frontier models do. For marketing, narrative, or brand-voice content, that gap is visible. * Image translation inside documents is a beta capability upstream. ## Reference * [Translation provider catalog](/providers/translation) * [DeepL supported languages](https://developers.deepl.com/docs/getting-started/supported-languages) * [DeepL document translation](https://developers.deepl.com/docs/api-reference/document) # Gemini API for Translation Source: https://api-docs.ollang.com/apis/translation-apis/gemini Google Gemini models in Ollang — Gemini 3.7 Flash, 3.1 Pro, 3 Pro, and 2.5 Pro — with native multimodal input and million-token context windows. **Gemini** is Google's model family and the most natively **multimodal** option in the translation catalog: text, images, audio, video, and PDF are all first-class inputs. For Document Orders containing diagrams, screenshots, or scanned pages, that is the difference between localizing the whole document and localizing only the parts that were already text. **Available in Ollang Workflows** — all Gemini tiers serve Document Translation, Subtitle Translation, and AI Dubbing. See the [Translation catalog](/providers/translation). ## Models | Model | Provider tag | Google model ID | Status at Google | | - | - | - | - | | Gemini 3.7 Flash | `google/gemini-3.7-flash` | `gemini-3.7-flash` | Stable | | Gemini 3.1 Pro Preview | `google/gemini-3.1-pro-preview` | `gemini-3.1-pro-preview` | Preview | | Gemini 3 Pro Preview | `google/gemini-3-pro-preview` | — | Superseded | | Gemini 2.5 Pro | `gemini` | `gemini-2.5-pro` | Stable | ## Choosing a tier **Gemini 3.7 Flash** is now a **stable** release rather than a preview. It carries a **1M-token input context with 64K output**, accepts text, images, audio, and video, and has a **knowledge cutoff of March 2026** — the most recent of any model in this catalog. Google highlights production code quality and long video understanding among its strengths. It carries the same context window as the Pro tiers on a throughput-oriented model, which makes it the default recommendation within Gemini for most localization work. **Gemini 3.1 Pro Preview** is the reasoning flagship, with a 1M-token input window and a three-tier thinking control (low, medium, high) that trades latency against reasoning depth. Select it for very large documents, whole content sets, and mixed-media source material that needs reasoning rather than throughput. **Gemini 2.5 Pro** remains stable and available, with broad multilingual coverage drawn from Google's data. **Gemini 3 Pro Preview** has been superseded in Google's current model list by the 3.1 Pro and 3.x Flash releases. It is retained here for Workflows already benchmarked against it; new Workflows should start from 3.7 Flash or 3.1 Pro. ## Where it fits in a workflow Three situations make Gemini the right call: 1. **Mixed-media documents.** Diagrams, embedded screenshots, scanned pages, and image-heavy PDFs. Text-only models silently skip what they cannot read. 2. **Very long single-context Orders.** Whole books, complete documentation sets, or full season subtitle runs where consistency across the entire body is the goal. 3. **Recency-sensitive content.** Gemini 3.7 Flash's March 2026 cutoff makes it the best-informed model here on recent terminology, product names, and events. ## Trade-offs * Gemini 3.1 Pro is still a preview release, so its behavior can change between versions. * Preview model IDs change as releases ship — Gemini 3 Pro Preview is already superseded. Re-check model status before standardizing a long-lived Workflow on a preview tier. ## Reference * [Translation provider catalog](/providers/translation) * [Gemini API models](https://ai.google.dev/gemini-api/docs/models) * [Gemini Text-to-Speech](/apis/tts-apis/gemini-2-5-tts) # Google Cloud Translation API Source: https://api-docs.ollang.com/apis/translation-apis/google-translate **Google Cloud Translation API** enables your websites and applications to dynamically translate text using Google's pre-trained or custom machine learning models. This API supports a wide range of languages and provides high-quality translations for various use cases. ## Key Features * **High Accuracy**: Leverages Google's Neural Machine Translation (NMT) model to deliver accurate translations. * **Customization**: Supports custom models with AutoML Translation for domain-specific terminology and style-sensitive translations. * **Real-Time and Batch Processing**: Offers both real-time translation for immediate needs and batch processing for large volumes of text. * **Language Detection**: Automatically detects the source language of the text, simplifying the translation process. ## Advanced Technologies * **AutoML Translation**: Allows users to create custom models to improve translation accuracy for specific domains. * **Glossary Management**: Enables the use of custom glossaries to ensure consistent terminology across translations. * **Content Filtering**: Provides mechanisms to filter out sensitive content to ensure privacy and compliance. ## Use Cases 1. **Website Localization**: Localize websites to expand your reach into new markets, ensuring the content is accurately translated and culturally relevant. 2. **Mobile Applications**: Integrate real-time translation capabilities into mobile apps to provide a seamless user experience for global users. 3. **Customer Support**: Enhance customer support by enabling multilingual communication, allowing support teams to assist customers in their native languages. For more details and to access the API, visit [Google Cloud Translation API](https://cloud.google.com/translate/docs/overview). # Groq for Translation Source: https://api-docs.ollang.com/apis/translation-apis/groq **Groq** provides ultra-fast inference for large language models, making it ideal for real-time translation applications. Their platform offers access to open-weight and open-source models—including **LLaMA 4** and **LLaMA 3.3**, **Mixtral**, and other leading families—optimized for speed and low latency. Check **[Groq’s documentation](https://console.groq.com/docs/models)** for the current model list; available endpoints change as new weights are added. ## Key Features * **Ultra-fast inference**: Sub-second response times for many workloads, suitable for interactive translation. * **Multiple model support**: Access to modern Llama generations, Mixtral-class models, and other options Groq hosts. * **Low latency**: Infrastructure tuned for minimal delay on translation and chat-style requests. * **Scalable architecture**: Built for high-volume, bursty traffic. * **Cost-effective**: Competitive pricing for high-throughput inference. ## Advanced Technologies * **LPU (Language Processing Unit)**: Custom inference hardware designed for transformer workloads. * **Model optimization**: Serving stack tuned for large language models at scale. * **Real-time processing**: Fits live captioning, assistants, and synchronous localization tools. * **Cloud infrastructure**: Managed APIs with broad client SDK support. ## Use Cases 1. **Real-time translation**: Meetings, live chat, and customer support with tight latency budgets. 2. **High-volume processing**: Batches of segments or documents where throughput matters. 3. **Interactive applications**: Chatbots and copilots that translate on the fly. 4. **Content creation**: Fast draft-and-review loops for creators and publishers. For more details and to access the API, visit [Groq](https://groq.com/). # Llama for Translation Source: https://api-docs.ollang.com/apis/translation-apis/llama Meta Llama 4 in Ollang — natively multimodal mixture-of-experts models with a 10M-token context window and 12 officially supported languages. **Llama 4** is Meta's first natively multimodal, mixture-of-experts open-weight generation. Both variants run **17 billion active parameters** and accept multilingual text and images, producing multilingual text and code. **Available in Ollang Workflows** as `llama` — Document Translation and Subtitle Translation. See the [Translation catalog](/providers/translation). Llama 4 does not serve AI Dubbing Orders. Select a different provider for the `translate` step of a dubbing Workflow. ## Models | | Llama 4 Scout | Llama 4 Maverick | | - | - | - | | **Active parameters** | 17B | 17B | | **Total parameters** | 109B | 400B | | **Experts** | 16 | 128 | | **Context window** | 10M tokens | 1M tokens | | **Training tokens** | \~40 trillion | \~22 trillion | | **Positioned for** | Single-GPU efficiency, extreme context | Image and text understanding, fast responses | Knowledge cutoff for both is **August 2024** — the oldest in this catalog, which matters for content containing recent product names, terminology, or events. ## Supported languages Meta officially supports **12 languages**: Arabic, English, French, German, Hindi, Indonesian, Italian, Portuguese, Spanish, Tagalog, Thai, and Vietnamese. This is the single most important constraint to design around. Outside those 12, quality falls off sharply compared with the 100+ language providers. ## Key capabilities * **Extreme context length** — Scout's 10M-token window is by a wide margin the largest here, enough for entire books, full documentation sets, or complete season subtitle runs in a single pass. * **Native multimodality** for documents combining text and images. * **Open weights**, relevant for organizations running parallel self-hosted evaluation or fine-tuning for domain-specific glossaries. ## Where it fits in a workflow Llama 4 is the right choice for **high-volume work inside its 12 supported languages** — bulk subtitle backlogs, internal documentation, and draft passes destined for human review. For the same content in an unsupported language, [Agentic Turbo](/apis/translation-apis/ollang-agentic-localization) or [DeepL](/apis/translation-apis/deepl) will produce better output. ## Trade-offs * **Narrow official language coverage** — 12 languages. * **Oldest knowledge cutoff in the catalog** at August 2024. * **No AI Dubbing support.** * Draft-grade rather than deliverable-grade on nuance-heavy content; budget for review. ## Reference * [Translation provider catalog](/providers/translation) * [Llama 4 Scout model card](https://huggingface.co/meta-llama/Llama-4-Scout-17B-16E-Instruct) # Microsoft Translator API Source: https://api-docs.ollang.com/apis/translation-apis/microsoft-translator **Microsoft Translator API** is a cloud-based machine translation service that enables developers to add multi-language support to their applications, websites, and tools. It supports a wide range of languages and offers high-quality translations powered by AI. ## Key Features * **High Accuracy**: Utilizes advanced neural machine translation models to deliver accurate translations across multiple languages. * **Customization**: Supports custom models and glossaries to improve translation accuracy for specific terminologies and contexts. * **Real-Time and Batch Processing**: Offers both real-time translation for instant needs and batch processing for large volumes of text. * **Language Detection**: Automatically detects the source language of the text, simplifying the translation process. ## Advanced Technologies * **Custom Translator**: Allows users to train custom models tailored to their specific needs, ensuring higher accuracy for industry-specific terminology. * **Document Translation**: Translates entire documents, preserving the formatting and layout, making it ideal for business and legal use cases. * **Content Filtering**: Provides mechanisms to filter out sensitive or unwanted content to ensure privacy and compliance. ## Use Cases 1. **Website Localization**: Localize websites to reach new markets, ensuring content is accurately translated and culturally appropriate. 2. **Mobile Applications**: Integrate real-time translation capabilities into mobile apps to provide a seamless experience for global users. 3. **Customer Support**: Enhance customer support by enabling multilingual communication, allowing support teams to assist customers in their native languages. For more details and to access the API, visit [Microsoft Translator API](https://azure.microsoft.com/en-us/services/cognitive-services/translator/). # Mistral AI for Translation Source: https://api-docs.ollang.com/apis/translation-apis/mistral-ai Mistral Medium 3.1 in Ollang — 50+ language translation with a 130K context window and multimodal input, with a migration note to Medium 3.5. **Mistral AI** builds models tuned for efficiency: frontier-adjacent capability on a throughput-oriented tier. **Mistral Medium 3.1** delivers translation and content generation across **50+ languages**, with a 130K-token context window and multimodal text-plus-image input. **Available in Ollang Workflows** as `mistralai/mistral-medium-3.1` — Document Translation, Subtitle Translation, and AI Dubbing. See the [Translation catalog](/providers/translation). **Migration notice.** Mistral has deprecated Medium 3.1 and Medium 3.2 in favor of **Mistral Medium 3.5** (`mistral-medium-3505`), released April 2026 and described as a frontier-class multimodal model optimized for agentic and coding use cases. Retirement dates for the 3.x series run through mid-2026. Plan a provider change for Workflows that depend on this tier. ## Model and coverage | | | | - | - | | **Model** | Mistral Medium 3.1 (`mistral-medium-2508`) | | **Languages** | 50+ | | **Context window** | 130K tokens | | **Input** | Text and image | | **Successor** | Mistral Medium 3.5 (`mistral-medium-3505`) | ## Key capabilities * **Contextual and idiomatic fidelity** across dozens of languages, with particular strength on European pairs. * **Efficiency** — engineered to deliver frontier-adjacent results on a model tier tuned for throughput rather than maximum capability. * **Multimodal input** for documents that mix text and images. * **130K context** — enough for most single documents and full subtitle files in one pass. ## Where it fits in a workflow Mistral Medium 3.1 is a strong **subtitle translation workhorse** for European language pairs. Its advantage over the pure NMT engines is that it is an instruction-following LLM: it will apply style guidance and reason about ambiguous source text in a way [DeepL](/apis/translation-apis/deepl) and [Amazon](/apis/translation-apis/amazon-translate) will not. ## Trade-offs * **Deprecated upstream.** See the migration notice above. * 50+ languages is solid but well short of the 100+ providers; verify coverage for non-European pairs. * Not a frontier reasoning tier. For quality-critical, nuance-heavy content the Claude 5, GPT-5.6, and Gemini Pro tiers pull clearly ahead. ## Reference * [Translation provider catalog](/providers/translation) * [Mistral models overview](https://docs.mistral.ai/getting-started/models/models_overview/) # ModernMT Source: https://api-docs.ollang.com/apis/translation-apis/modernmt **ModernMT** is a dynamic, adaptive machine translation service designed to provide high-quality translations by learning from user interactions in real-time. It is ideal for businesses looking to integrate translation capabilities that improve continuously with use. ## Key Features * **Dynamic Adaptation**: ModernMT adapts in real-time to the content it translates, providing highly customized translations without the need for extensive pre-training. * **High Accuracy**: Utilizes advanced neural machine translation models, offering quality comparable to professional human translation by considering the context of the entire document. * **Customization**: Supports the creation of custom glossaries and models to maintain consistent terminology and style specific to different domains. * **Document-Level Translation**: Unlike many translation systems, ModernMT translates by considering the context of the entire document, improving coherence and relevance. ## Advanced Technologies * **Human-in-the-Loop**: Continuously improves translation quality by learning from human corrections in real-time, ensuring the system adapts and evolves with each interaction. * **Low Latency**: Offers high-speed, low-latency translation services suitable for large enterprises and real-time applications. * **Glossary Management**: Allows for the use of both unidirectional and equivalent terms glossaries, ensuring consistent and accurate translations across multiple languages. ## Use Cases 1. **Localization**: Ideal for businesses needing to localize websites, software, and documentation to meet the linguistic and cultural preferences of different markets. 2. **Customer Support**: Enhances customer support operations by providing accurate, real-time translations, allowing for effective communication in multiple languages. 3. **Content Creation**: Assists content creators by providing high-quality translations that preserve the original intent and context, suitable for media, marketing, and documentation. For more details and to access the API, visit [ModernMT](https://www.modernmt.com). # NeuralSpace API for Translation Source: https://api-docs.ollang.com/apis/translation-apis/neuralspace **NeuralSpace API** offers advanced translation services powered by state-of-the-art neural machine translation (NMT) models. This platform is designed to support text and voice Natural Language Processing (NLP) tasks across a wide range of languages, making it particularly effective for applications involving multilingual content. ## Key Features * **High Accuracy**: Utilizes cutting-edge neural machine translation models to provide accurate and context-aware translations. * **Multilingual Support**: Supports over 100 languages, including many low-resource languages from regions such as South Asia, Africa, and the Middle East, which are often underrepresented in other translation tools. * **Customizable Entity Preservation**: Allows users to preserve specific entities (e.g., names, dates) during translation, ensuring that these important elements remain consistent across languages. * **Real-Time and Batch Processing**: Offers flexible translation options that cater to both real-time needs and large-scale batch processing. ## Advanced Technologies * **Neural Machine Translation (NMT)**: Employs deep learning techniques to enhance translation quality, particularly for complex sentence structures and nuanced language use. * **Entity Annotation Preservation**: Allows for the preservation of key entities within text during the translation process, ensuring that critical information is accurately translated and maintained. * **Language Agnostic**: Built to handle a diverse set of languages, including those with complex grammatical structures and unique syntactical rules. ## Use Cases 1. **Business Localization**: Ideal for translating marketing materials, websites, and other business content to engage effectively with global audiences. 2. **Customer Support**: Enhances customer service by translating support tickets, emails, and live chat messages in real-time, facilitating communication with international customers. 3. **Content Creation**: Supports the translation of e-learning content, media, and publications, maintaining the integrity of the original message across different languages. For more details and to access the API, visit [NeuralSpace](https://neuralspace.ai). # Ollang Agentic Localization Source: https://api-docs.ollang.com/apis/translation-apis/ollang-agentic-localization Ollang's multi-agent localization workflow — Agentic Localization and Agentic Turbo — for culturally aware translation across 100+ languages. **Ollang Agentic Localization** is Ollang's own translation workflow and the default provider for every `translate` step. It is the only entry in the translation catalog that is a *pipeline* rather than a single model: agents are selected dynamically per segment based on content type, domain, and structural complexity, then their output is reconciled. That design targets the gap between translation and localization. A frontier LLM will translate a marketing line accurately; a localization workflow decides whether the line should be translated at all, or replaced with something that lands the same way for a different audience. **Available in Ollang Workflows** — Document Translation, Subtitle Translation, and AI Dubbing. See the [Translation catalog](/providers/translation) for the full comparison against 25 other engines. ## Models | Model | Provider tag | Order types | Status | | - | - | - | - | | Agentic Localization | `ollangAITranslate` | Document, Subtitle, AI Dubbing | **Default** | | Agentic Turbo | `agentic-turbo` | Document, Subtitle, AI Dubbing | Experimental | ## Key capabilities * **End-to-end localization** across text, documents, subtitles, and dubbing scripts in **100+ languages**, from a single provider selection. * **Dynamic multi-agent selection** — different agents handle different content, which is what carries quality through domain-specific and structurally complex material that a single prompt would flatten. * **Culturally aware output** — idiom, register, and cultural reference are adapted rather than transliterated. * **Format and structure preservation** across the document types Ollang ingests. * **Steerable** through [Memory, glossaries, and custom instructions](/memory-guidelines-custom-instructions), which apply to the whole workflow rather than to one model call. ## Agentic Turbo Agentic Turbo is the same shape of workflow tuned for throughput, while retaining contextual quality that pure machine translation does not reach. It suits high-volume work — large subtitle backlogs, bulk document sets, and any pipeline where turnaround determines scope. Agentic Turbo is experimental. Benchmark it against your current provider in a separate Folder before moving a production Global Workflow onto it. ## Where it fits in a workflow Agentic Localization is the default because most Orders are judged on localization quality rather than translation accuracy alone. It earns its place on content where the output is customer-facing and the phrasing carries value. A common configuration is Agentic Localization as the Global Workflow default, with Agentic Turbo or [DeepL](/apis/translation-apis/deepl) overridden at Folder level for bulk content. ## Trade-offs * **Latency** — a multi-agent pass does more work than a single model call, which shows up in turnaround on large batches. ## Reference * [Translation provider catalog](/providers/translation) * [Memory, guidelines, and custom instructions](/memory-guidelines-custom-instructions) * [Workflows and provider architecture](/workflows-provider-architecture) # OpenAI Models for Translation Source: https://api-docs.ollang.com/apis/translation-apis/openai OpenAI's translation tiers in Ollang — GPT-5.6 Sol and Luna with 1.05M-token context, plus the earlier GPT-5.4, GPT-5.2, GPT-5, GPT-4.1, and o4-mini tiers. **OpenAI** provides the widest model ladder in the translation catalog: seven selectable tiers. Within this family the tier choice matters far more than the family choice. The current generation is **GPT-5.6**, which ships as **Luna, Terra,** and **Sol** in ascending capability. All three carry the same **1.05M-token context window and 128K maximum output** — the tiers differ in capability, not in how much text they can hold. Ollang exposes the two ends of that range. **Available in Ollang Workflows** — all OpenAI tiers serve Document Translation, Subtitle Translation, and AI Dubbing. See the [Translation catalog](/providers/translation). ## Models | Model | Provider tag | Context | Max output | Status | | - | - | - | - | - | | GPT-5.6-Sol | `openai/gpt-5.6-sol` | 1.05M | 128K | **New** | | GPT-5.6-Luna | `openai/gpt-5.6-luna` | 1.05M | 128K | **New** | | GPT-5.4 | `openai/gpt-5.4` | \~1M | — | **New** | | GPT-5.2 | `openai/gpt-5.2` | 400K | — | Available | | GPT-5 | `openai/gpt-5` | — | — | Available | | GPT-4.1 | `openai` | 1M | — | Available | | o4-mini | `openai/o4-mini` | — | — | Available | ## Choosing a tier **GPT-5.6-Sol** is OpenAI's most capable model, for complex translation and localization where nuance, terminology accuracy, consistency, and reliable instruction-following all have to hold simultaneously. It supersedes both GPT-5.2 and GPT-5.4 on capability, which makes the older 5.x tiers hard to justify for new Workflows. **GPT-5.6-Luna** is the efficiency tier of the same generation, while carrying the identical 1.05M-token context window. That combination is unusual: whole-document context on a throughput-oriented tier. It is the right default for high-volume, quick-turnaround content. **GPT-5.4** brought a roughly 1M-token context window — more than double GPT-5.2's 400K — along with configurable reasoning effort. Worth keeping selected only where an existing benchmark depends on it. **GPT-5.2**, **GPT-5**, **GPT-4.1**, and **o4-mini** are earlier tiers. GPT-4.1 remains a sensible mid-tier workhorse with 1M-token context; o4-mini is the compact reasoning option, with an efficient tokenizer that keeps non-English text economical to process. ## Where it fits in a workflow A common two-tier configuration pairs **GPT-5.6-Luna** as the Global Workflow default with **GPT-5.6-Sol** overridden at Folder level for customer-facing or regulated content. Because both tiers share a context window, the throughput tier gives up nothing on document length. ## Trade-offs * The tiers between GPT-5 and GPT-5.4 are now largely superseded by GPT-5.6-Sol. * Model names and defaults change frequently; confirm current behavior against OpenAI's model documentation before standardizing a Workflow on a specific tier. ## Reference * [Translation provider catalog](/providers/translation) * [OpenAI models](https://developers.openai.com/api/docs/models) * [OpenAI Text-to-Speech](/apis/tts-apis/openai-tts) # Perplexity AI for Translation Source: https://api-docs.ollang.com/apis/translation-apis/perplexity **Perplexity AI** provides advanced language models that excel in translation tasks through their sophisticated understanding of context and real-time information retrieval capabilities. Their models combine traditional translation approaches with up-to-date knowledge for more accurate and relevant translations. ## Key Features * **Real-time Information**: Leverages live web search capabilities to provide contextually relevant translations with current information. * **High Accuracy**: Utilizes advanced language models to deliver accurate translations while maintaining context and nuance. * **Multilingual Support**: Supports translation across a wide range of languages with consistent quality. * **Contextual Understanding**: Maintains context across conversations and documents for coherent translations. * **Research Integration**: Can incorporate real-time research and information into translation tasks. ## Advanced Technologies * **Hybrid AI Architecture**: Combines language model capabilities with real-time information retrieval for enhanced accuracy. * **Live Web Search**: Integrates current information from the web to provide contextually relevant translations. * **Conversational AI**: Designed for interactive translation sessions with memory of previous context. * **Source Attribution**: Provides transparency by citing sources when incorporating external information. * **Customizable Responses**: Allows fine-tuning of translation style and approach based on specific requirements. ## Use Cases 1. **Dynamic Content Translation**: Ideal for translating content that requires current information or context from recent events. 2. **Research Translation**: Helps translate research papers and academic content with access to current terminology and references. 3. **Business Communication**: Assists in translating business documents and communications with up-to-date industry terminology. 4. **Educational Content**: Supports translation of educational materials with current examples and references. For more details and to access the API, visit [Perplexity AI](https://www.perplexity.ai/). # Qwen for Translation Source: https://api-docs.ollang.com/apis/translation-apis/qwen Qwen3-235B-A22B in Ollang — a sparse mixture-of-experts model with a 262K native context window, 119-language training coverage, and strength on Chinese-English. **Qwen** is Alibaba's model family. The tier available in Ollang, **Qwen3-235B-A22B**, is a mixture-of-experts model: **235 billion total parameters with only 22 billion active per token**, routed across 128 experts with 8 activated at a time. That sparsity is what lets a model of this scale run at practical throughput. **Available in Ollang Workflows** as `qwen/qwen3-235b-a22b` — Document Translation, Subtitle Translation, and AI Dubbing. See the [Translation catalog](/providers/translation). ## Model and coverage | | | | - | - | | **Model** | Qwen3-235B-A22B | | **Architecture** | Mixture of experts — 235B total, 22B active, 128 experts with 8 activated per token | | **Attention** | Grouped-query attention, 64 query heads and 4 key-value heads across 94 layers | | **Native context** | 262,144 tokens, extensible toward 1M with Dual Chunk Attention and sparse-attention techniques | | **Language coverage** | 119 languages and dialects across the Qwen3 family | The 262K figure is a **native** context window rather than an extended one, so long-document behavior is what the model was trained for rather than a configuration applied on top of it. Claude and Gemini reach 1M tokens; Qwen's distinction is that its long-context behavior is native to the architecture. ## Key capabilities * **Widest training language coverage in the catalog** at 119 languages and dialects, including many that Western-centric models treat as long tail. * **Long-tail knowledge coverage across multiple languages** is where Qwen reports its largest gains — the characteristic that actually matters for translation outside the top 20 languages. * **Chinese–English strength**, the clearest single reason to select it over another provider for that pair. * **262K native context** for complex documents and full subtitle runs in one pass. * **Strong instruction following and text comprehension**, which translate directly into glossary and style-guide adherence. ## Where it fits in a workflow Qwen3 is the default recommendation for **Chinese–English** localization and for programs whose language list runs into the long tail — Central Asian, South Asian, and Southeast Asian languages where the mainstream providers thin out. ## Trade-offs * Language *coverage* at 119 does not mean uniform *quality* at 119. Benchmark your specific pairs rather than assuming parity with the headline number. * The Instruct variant operates in non-thinking mode and does not produce reasoning blocks, so it will not deliberate over genuinely ambiguous source the way the frontier reasoning tiers do. * Less consistent on Western European nuance than the Claude 5 and GPT-5.6 tiers. ## Reference * [Translation provider catalog](/providers/translation) * [Qwen3-235B-A22B model card](https://huggingface.co/Qwen/Qwen3-235B-A22B-Instruct-2507) # Tarjama MT Source: https://api-docs.ollang.com/apis/translation-apis/tarjama-mt **Tarjama Machine Translation (MT)** is a sophisticated AI-driven translation service designed to deliver high-quality, accurate translations. It leverages advanced neural machine translation models to cater to diverse business needs, particularly excelling in translating Arabic. ## Key Features * **High Accuracy**: Utilizes neural machine translation (NMT) technology built on high-quality business data pre-approved by human linguists, ensuring precise and contextually appropriate translations. * **Custom Models**: Offers tailored MT models that can be custom-trained using your specific data, resulting in even higher accuracy for specialized terminology and industry-specific content. * **Multilingual Support**: While specializing in Arabic, Tarjama MT supports multiple languages, making it suitable for global applications. * **Data Security**: Ensures maximum data protection with ISO 27001 certification, encrypting data in a secured cloud environment to maintain confidentiality and compliance. ## Advanced Technologies * **Human-in-the-Loop**: Integrates human expertise with AI, where in-house linguists collaborate with AI to refine translations, correct errors, and ensure cultural and contextual relevance. * **CleverSo Integration**: Seamlessly integrates with CleverSo, Tarjama’s Translation Management System (TMS), enhancing productivity by up to 60% through automated workflows and advanced AI features. * **AI-Powered Terminology Assistant**: Utilizes generative AI to assist in understanding specific meanings of words and finding the best terms for translations. ## Use Cases 1. **Business Localization**: Ideal for translating business documents, marketing materials, and websites to engage effectively with global audiences. 2. **Customer Support**: Enhances customer support by translating support tickets, emails, and live chat messages, ensuring clear communication in multiple languages. 3. **Content Creation**: Suitable for creating multilingual content for e-learning, media, and publications, providing high-quality translations that maintain the original message and tone. For more details and to access the API, visit [Tarjama](https://www.tarjama.com). # XL8 API Source: https://api-docs.ollang.com/apis/translation-apis/xl8 **XL8** is a neural machine translation engine purpose-built for the media and entertainment industry, founded by former Google Translate engineers. Unlike general-purpose MT services, XL8's models are trained on subtitle, dubbing, and entertainment-content corpora, making it well suited for localizing video, film, episodic content, and live captions. ## Key Features * **Media-First Models**: Engines are trained on professionally translated subtitles and dubbing scripts, producing output that respects on-screen reading speed, line-break conventions, and dialogue register. * **Caption-Aware Translation**: Handles SRT, VTT, TTML, and SCC inputs natively, preserving timing cues, speaker labels, and formatting tags. * **Subtitle-Length Constraints**: Generates translations that fit reading-rate and character-per-line limits — critical for OTT and broadcast delivery. * **Live Captioning**: Real-time MT pipeline for live events, news, and streaming. * **Custom Glossary & Term Bases**: Supports show-specific glossaries to keep character names, franchise terms, and on-screen text consistent across episodes. * **Wide Language Coverage**: Bidirectional engines across 100+ language pairs, with deep coverage of European, East Asian, and Latin American markets. ## Advanced Technologies * **Domain-Adapted NMT**: Models specialized for entertainment outperform general-purpose MT on dialogue, idiom, and culturally bound references. * **Length & Reading-Rate Control**: Built-in constraints keep target subtitles within CPS (characters-per-second) and CPL (characters-per-line) thresholds. * **Format Round-Tripping**: Maintains source-file structure on output so files can flow directly into downstream subtitle and dubbing tools. * **Adaptive Glossaries**: Glossaries can be scoped per project or per series, with automatic enforcement during translation. ## Use Cases 1. **Subtitle Translation at Scale**: Localize VOD catalogs, news feeds, and episodic content with subtitle-ready output that meets broadcaster QC standards. 2. **AI Dubbing Pre-Translation**: Generate first-pass scripts for dubbing studios with media-appropriate phrasing and length-controlled lines. 3. **Live Event Captions**: Real-time multilingual captions for sports, conferences, and live entertainment. 4. **Trailer & Promotional Content**: Fast-turnaround localization of marketing assets where tone and reading speed matter. ## Integration with Ollang Within Ollang, XL8 can be selected as a translation provider for **Subtitle**, **AI Dubbing**, and **Closed Captioning** orders. When a project is configured with XL8 as the MT engine, Ollang routes subtitle units through XL8's caption-aware pipeline and applies show-level glossaries automatically. For more details and to access the API, visit [XL8](https://xl8.ai). # Youdao Translate API Source: https://api-docs.ollang.com/apis/translation-apis/youdao-translate **Youdao Translate API** is a powerful translation service provided by Youdao, utilizing advanced neural machine translation (NMT) technology to offer accurate and context-aware translations. It is designed to handle both text and voice translation tasks, making it versatile for various applications. ## Key Features * **High Accuracy**: Leverages neural machine translation models to deliver precise translations that consider the full context of the text, ensuring natural and coherent results. * **Multilingual Support**: Supports translation across a wide range of languages, including major languages like English, Chinese, Spanish, French, and many others, with over 100 language pairs available. * **Customization**: Offers customizable terminology options, allowing users to maintain consistency with specific terms across translations, which is particularly useful in specialized fields. * **Real-Time and Batch Processing**: Provides real-time translation capabilities as well as batch processing for handling large volumes of text efficiently. ## Advanced Technologies * **Neural Machine Translation (NMT)**: Utilizes deep learning models to improve translation quality by understanding and translating sentences in their entirety, rather than word by word. * **Speech Synthesis Integration**: Supports the generation of speech from translated text, enabling voice applications to deliver natural-sounding audio in multiple languages. * **Domain-Specific Translation**: Allows for domain-specific translations, enhancing accuracy in fields such as medicine, finance, and technology by using specialized language models. ## Use Cases 1. **Website Localization**: Ideal for translating website content, ensuring that the translated material is culturally and contextually appropriate for international users. 2. **E-commerce**: Assists in translating product descriptions, customer reviews, and other user-generated content to reach a broader global market. 3. **Customer Support**: Enhances customer service by providing real-time translation of support tickets, emails, and live chat messages, improving communication with international customers. For more details and to access the API, visit [Youdao Translate API](https://ai.youdao.com/). # Amazon Polly Text-to-Speech API Source: https://api-docs.ollang.com/apis/tts-apis/amazon-polly **Amazon Polly** is a cloud-based service by AWS that converts text into lifelike speech, enabling the creation of applications that talk and the development of new categories of speech-activated applications. ## Key Features * **High-Quality Voices**: Provides a wide selection of natural-sounding male, female, and child voices in multiple languages. * **Low Latency**: Delivers fast responses, making it suitable for real-time applications. * **Flexible Audio Formats**: Supports various audio formats, including MP3, Ogg Vorbis, and PCM, allowing for diverse use cases. * **Customization**: Offers customization options through SSML (Speech Synthesis Markup Language) to control speech output, such as pronunciation, volume, pitch, and speed. ## Advanced Technologies * **Neural Text-to-Speech (NTTS)**: Utilizes neural network-based models to generate more natural and expressive speech. This includes specific speaking styles like the Newscaster style. * **Speech Synthesis Markup Language (SSML)**: Supports SSML to fine-tune speech synthesis, enabling control over aspects such as emphasis, breaks, and intonation. * **Lexicons**: Allows the creation of custom pronunciation lexicons to ensure that specific words and names are pronounced correctly. ## Use Cases 1. **Content Creation**: Converts articles, e-learning materials, and other content into speech to enhance accessibility and engagement. 2. **Customer Support**: Enhances interactive voice response (IVR) systems with natural-sounding speech, improving user experience. 3. **IoT Devices**: Enables IoT devices to interact with users via voice, providing a more natural interface for home automation, vehicles, and more. For more details and to access the API, visit [Amazon Polly](https://aws.amazon.com/polly/). # Azure + ElevenLabs Source: https://api-docs.ollang.com/apis/tts-apis/azure-elevenlabs A combined voice route pairing Microsoft Azure neural text-to-speech with ElevenLabs — the largest voice catalog and the finest delivery control available in Ollang Workflows. **Azure + ElevenLabs** is a combined provider option that pairs Microsoft Azure neural text-to-speech with ElevenLabs in a single selection. Azure's contribution is **catalog depth and control**: over 200 neural voices across 90+ locales, spread across several quality tiers, with full SSML — the finest delivery control of any engine in this catalog. **Available in Ollang Workflows** as `azureElevenlabs` — AI Dubbing. See the [Text-to-Speech catalog](/providers/text-to-speech). ## Voice tiers | Tier | Model suffix | What it adds | | - | - | - | | Standard Neural | `Neural` | Baseline natural speech across the full locale range | | Neural HD | `DragonHDLatestNeural` | Higher naturalness and expressiveness on major languages | | Neural HD Omni | `DragonHDOmniLatestNeural` | Multilingual with contextual awareness, on select locales | | Neural HD Flash | `DragonHDFlashLatestNeural` | Fast HD inference variant | | MAI Voice | `MAI-Voice-1`, `MAI-Voice-2`, `MAI-Voice-2-Flash` | 18+ emotional styles including angry, confused, determined, excited, fearful, and whispering | | Multilingual | `MultilingualNeural`, Turbo Multilingual | One voice speaking across languages, with automatic emotional-cue detection | ## Key capabilities * **The largest individual voice catalog in the Ollang catalog** — 200+ neural voices, with named speaking styles (newscast, customer service, chat, empathetic, whispering) and role variants including child voices. * **Full SSML control** over pronunciation, intonation, pauses, and pacing. For dubbing this is the practical mechanism for fitting a line to picture within a fixed timing budget, rather than regenerating it until the duration happens to land. * **Custom Neural Voice and Personal Voice** for a consistent brand or character voice across an entire catalog. * **Multilingual voices** that carry one speaker identity across languages while detecting emotional cues and adjusting style to match sentiment. * **Enterprise compliance posture** inherited from Azure. ## Where it fits in a workflow Select this route when the **voice specification** drives the decision rather than the language count: a specific locale variant, a specific age or gender profile, or a named speaking style that single-vendor engines do not offer — or when lines must be timed precisely to picture and SSML is the tool that gets you there. If raw language reach is the constraint, [Gemini TTS](/apis/tts-apis/gemini-2-5-tts) covers 99 languages. On the major languages every provider serves, [Cartesia](/apis/tts-apis/cartesia) and [ElevenLabs](/apis/tts-apis/elevenlabs) sound better. ## Trade-offs * **Baseline neural voices are reliable rather than expressive.** They are excellent at being clear and consistent, and they are not the right choice when voice performance is the deliverable. The HD and MAI tiers close much of that gap where they are available. ## Reference * [Text-to-Speech provider catalog](/providers/text-to-speech) * [Azure Neural Voices](/apis/tts-apis/azure-neural-voices) * [ElevenLabs](/apis/tts-apis/elevenlabs) * [Azure AI Speech language and voice support](https://learn.microsoft.com/en-us/azure/ai-services/speech-service/language-support) # Azure Neural Voices Text-to-Speech API Source: https://api-docs.ollang.com/apis/tts-apis/azure-neural-voices Microsoft Azure neural text-to-speech — 200+ neural voices across 90+ locales, with Neural HD and MAI voice tiers, full SSML, and Custom Neural Voice. **Azure Neural Voices** is Microsoft's text-to-speech service, and the largest voice catalog available to Ollang Workflows: **over 200 neural voices across 90+ language locales**, organized into several quality and capability tiers. In Ollang Workflows, Azure is selectable through the combined [Azure + ElevenLabs](/apis/tts-apis/azure-elevenlabs) route (`azureElevenlabs`). See the [Text-to-Speech catalog](/providers/text-to-speech). ## Voice tiers | Tier | Example voice | Characteristics | | - | - | - | | Standard Neural | `en-US-AriaNeural` | Baseline natural speech, broadest locale coverage | | Neural HD | `en-US-Ava:DragonHDLatestNeural` | Enhanced naturalness on major languages | | Neural HD Omni | `en-US-Andrew:DragonHDOmniLatestNeural` | Multilingual with contextual awareness, select locales | | Neural HD Flash | `en-US-Jimmie:DragonHDFlashLatestNeural` | Fast HD variant | | MAI Voice | `en-US-Harper:MAI-Voice-2` | 18+ emotional styles on the Voice-2 generation | | Multilingual | `en-US-AvaMultilingualNeural` | Cross-language synthesis from a single voice identity | ## Key capabilities * **Full SSML** — precise control over pronunciation, intonation, pauses, and pacing. For dubbing this is how a line gets fitted to a timing budget rather than regenerated until it happens to fit. * **Named speaking styles** — cheerful, sad, angry, excited, friendly, newscast, chat, whispering, empathetic — selectable per segment, plus role variants including child voices. * **Multilingual voices** that carry one speaker identity across languages, detecting emotional cues and adjusting speaking style to match sentiment. * **Custom Neural Voice and Personal Voice** for brand-specific narration trained on your own data. * **Automatic language detection** with SSML `lang` tag support on the Dragon HD Omni tier, for passages that mix languages. ## Trade-offs * **Baseline neural voices are reliable rather than expressive.** They are excellent at being clear and consistent, and they are not the right choice when voice performance is the deliverable. * On the major languages that every provider covers, [Cartesia](/apis/tts-apis/cartesia) and [ElevenLabs](/apis/tts-apis/elevenlabs) sound better for less. Azure's case rests on voice variety, SSML control, and custom voices. ## Reference * [Text-to-Speech provider catalog](/providers/text-to-speech) * [Azure + ElevenLabs route](/apis/tts-apis/azure-elevenlabs) * [Azure AI Speech language and voice support](https://learn.microsoft.com/en-us/azure/ai-services/speech-service/language-support) # Cartesia Sonic Text-to-Speech API Source: https://api-docs.ollang.com/apis/tts-apis/cartesia Cartesia Sonic 3.6 — 44-language streaming text-to-speech with inline non-verbal expression, automatic emotional calibration, and 10-second voice cloning. **Cartesia Sonic** is a real-time speech synthesis model built around streaming from the ground up. The current generation, **Sonic-3.6**, is what Cartesia describes as its most natural and human-sounding model, and the company reports it at **number one on Artificial Analysis's Speech Arena leaderboard**. **Available in Ollang Workflows** as `cartesia` — AI Dubbing. See the [Text-to-Speech catalog](/providers/text-to-speech). ## Model versions | Model ID | Description | | - | - | | `sonic-3.6` | Current generation, continuously updated | | `sonic-3.6-2026-08-27` | Pinned dated snapshot of the same generation | | `sonic-preview` | Beta channel for upcoming changes | Earlier generations — `sonic-3`, `sonic-3.5`, `sonic-2`, `sonic-turbo`, and `sonic` — remain documented by Cartesia. ## Coverage **44 languages**, with Odia and Urdu added in 3.6 and Hinglish explicitly supported: `en` `de` `es` `fr` `ja` `pt` `zh` `hi` `ko` `it` `nl` `pl` `ru` `sv` `tr` `tl` `bg` `ro` `ar` `cs` `el` `fi` `hr` `ms` `sk` `da` `ta` `uk` `hu` `no` `vi` `bn` `th` `he` `ka` `id` `te` `gu` `kn` `ml` `mr` `pa` `or` `ur` That is 15 more than [ElevenLabs Multilingual V2](/apis/tts-apis/elevenlabs), and it includes South Asian languages — Telugu, Gujarati, Kannada, Malayalam, Marathi, Punjabi, Odia — that most premium engines do not serve. ## Key capabilities * **Automatic emotional calibration** — Sonic reads the emotional subtext of the transcript and adjusts delivery without explicit direction, so an undirected line still lands with appropriate affect. * **Inline non-verbal expression** — laughter, sighs, and disfluencies are written directly into the transcript rather than requiring separate markup or a second pass. * **Contextual pacing**, correct alphanumeric read-out, and heteronym disambiguation — the three places synthesized narration most often gives itself away. * **Instant voice cloning** from roughly 10 seconds of reference audio, which keeps speaker similarity high enough for brand consistency across a catalog. * **Streaming-first architecture** with sub-90 ms stated latency, which translates into fast batch throughput for dubbing volume. ## Where it fits in a workflow Reach for Cartesia on conversational and dialogue-heavy content, on high-volume dubbing where turnaround matters, and whenever your language list runs past ElevenLabs' 29 without needing the full 99 that [Gemini TTS](/apis/tts-apis/gemini-2-5-tts) reaches. ## Trade-offs * Newer model line, so there is less accumulated production history behind it than ElevenLabs at studio-narration quality. * Published latency is model latency, not an end-to-end round trip. Benchmark against your own pipeline if latency is a hard requirement. The in-product description for this provider still references an earlier Sonic generation with 15 languages. Sonic 3.6 supports 44. ## Reference * [Text-to-Speech provider catalog](/providers/text-to-speech) * [Cartesia Sonic](https://www.cartesia.ai/sonic) * [Sonic 3.6 documentation](https://docs.cartesia.ai/build-with-cartesia/tts-models/latest) # Coqui TTS Text-to-Speech API Source: https://api-docs.ollang.com/apis/tts-apis/coqui-tts **Coqui TTS** is an open-source text-to-speech toolkit that provides high-quality speech synthesis capabilities with extensive customization options. It offers both pre-trained models and tools for training custom TTS models. ## Key Features * **Open Source**: Completely open-source solution with active community development and support. * **High-Quality Models**: Provides access to state-of-the-art TTS models including Tacotron, FastSpeech, and YourTTS. * **Custom Training**: Allows users to train custom TTS models on their own datasets for domain-specific applications. * **Multilingual Support**: Supports multiple languages with pre-trained models and training capabilities. ## Advanced Technologies * **Neural TTS Models**: Implements various neural network architectures for speech synthesis including transformer-based models. * **Voice Cloning**: Supports voice cloning and adaptation techniques for creating custom voices. * **Real-time Synthesis**: Optimized for real-time applications with low-latency speech generation. * **Modular Architecture**: Flexible architecture allows for easy integration and customization of different components. * **Research-Friendly**: Designed to support research and experimentation with TTS technologies. ## Use Cases 1. **Research and Development**: Ideal for researchers and developers experimenting with TTS technologies and custom model training. 2. **Custom Applications**: Suitable for applications requiring domain-specific voices or specialized speech synthesis. 3. **Educational Projects**: Provides learning resources and tools for understanding TTS technology and implementation. 4. **Open Source Projects**: Perfect for open-source applications requiring high-quality speech synthesis without licensing costs. For more details and to access the toolkit, visit [Coqui TTS GitHub](https://github.com/coqui-ai/TTS). # Deepgram Aura Text-to-Speech Source: https://api-docs.ollang.com/apis/tts-apis/deepgram-aura Deepgram Aura-2 text-to-speech — 88 voices across 7 languages with deep English and Spanish accent coverage. **Deepgram Aura** is Deepgram's text-to-speech line, engineered for low-latency, high-throughput voice. Aura-2 is the current generation, aimed at enterprise applications — customer service, healthcare, sales, interviews, and IVR — where clarity and consistency matter more than expressive range. Its voice catalog is unusual in shape: **deep rather than wide**. Seven languages, but more voices inside English and Spanish than any other engine in this catalog offers. **Available in Ollang Workflows** as `deepgram` — AI Dubbing. See the [Text-to-Speech catalog](/providers/text-to-speech). Deepgram's speech recognition side is documented separately under [Deepgram](/apis/stt-apis/deepgram). ## Voices and languages Aura-2 provides **88 voices across 7 languages**: | Language | Aura-2 voices | Accents | | - | - | - | | English | 38 | American, British, Australian, Irish, Filipino | | Spanish | 17 | Mexican, Peninsular, Colombian, Latin American | | Italian | 10 | — | | Dutch | 9 | — | | German | 7 | — | | Japanese | 5 | — | | French | 2 | — | Voices are addressed as `[model]-[voice]-[language]`, for example `aura-2-thalia-en`. Aura 1 remains available as a legacy generation with 12 English voices. ## Key capabilities * **Accent depth within languages** — five English accents and four Spanish accents mean regional variants can be cast properly rather than approximated. For an English-to-Spanish program targeting several Latin American markets, this is a genuine advantage over engines with one Spanish voice. * **Range of speaking styles** across genders, age groups, and delivery — warm conversational, confident professional, and characterful storytelling. * **Low latency at scale** — the architecture is built for real-time voice agents, which translates into fast batch throughput for dubbing. * **Efficient batch throughput**, which suits large instructional and corporate libraries. ## Where it fits in a workflow Deepgram is a good fit when your target languages sit inside its seven and the content is instructional, corporate, or informational. For an English-to-Spanish training library the accent depth is a real product advantage rather than a rounding difference. ## Trade-offs * **Seven languages is the narrowest coverage in the catalog.** Confirm your language pair before selecting it — this is the most common reason a Deepgram Workflow has to be reconfigured. French in particular has only two voices. * **Built for voice agents, not narration.** On emotionally driven or performed content it reads accurately but does not act. * No voice cloning. ## Reference * [Text-to-Speech provider catalog](/providers/text-to-speech) * [Deepgram voices and languages](https://developers.deepgram.com/docs/tts-models) # ElevenLabs Text-to-Speech API Source: https://api-docs.ollang.com/apis/tts-apis/elevenlabs ElevenLabs Multilingual V2 — emotionally aware speech synthesis across 29 languages with voice cloning and cross-language voice identity, the default voice engine in Ollang. **ElevenLabs Text-to-Speech** produces some of the most natural-sounding synthetic voices available. **Eleven Multilingual v2** is its model for content work, and the property that matters most for localization is not raw naturalness but **voice consistency**: a voice keeps its identity, personality, and accent across every language it speaks, which is what lets one character sound like the same person in eight dubs. **Available in Ollang Workflows** as `elevenlabs` — AI Dubbing · **Default** voice engine. See the [Text-to-Speech catalog](/providers/text-to-speech). ## The current ElevenLabs model line | Model | Languages | Latency | Character limit | Positioned for | | - | - | - | - | - | | **Eleven Multilingual v2** | 29 | Standard | 10,000 | Character voiceovers, professional content, multilingual projects needing consistent voice quality | | Eleven v3 | 70+ | Standard | 5,000 | Audiobook production and emotional dialogue with multiple speakers | | Eleven v3 Conversational | 70+ | \~280 ms | — | Support agents, assistants, and interactive characters | | Eleven Flash v2.5 | 32 | \~75 ms | 40,000 | Real-time applications and bulk processing | | Eleven Flash v2 | English only | \~75 ms | 30,000 | English-only real-time applications | Ollang's `elevenlabs` provider runs **Multilingual v2**. Eleven Turbo v2.5 and Turbo v2 are deprecated in favor of the Flash models. ## Coverage Multilingual v2's 29 languages: English (US, UK, Australian, Canadian), Spanish (Spain, Mexico), Portuguese (Brazil, Portugal), French (France, Canada), Arabic (Saudi Arabia, UAE), German, Italian, Dutch, Polish, Swedish, Danish, Finnish, Czech, Slovak, Croatian, Romanian, Bulgarian, Greek, Ukrainian, Russian, Turkish, Hindi, Tamil, Japanese, Korean, Chinese, Indonesian, Malay, and Filipino. ## Key capabilities * **Cross-language voice identity** — the property that makes multi-language character work coherent, and the main reason this remains the default. * **Voice cloning**, so a specific character or brand voice can be carried across an entire catalog rather than recast per language. * **Emotional range** in its main languages, with intonation drawn from the surrounding text. * **Stability and similarity settings** to trade consistency against expressiveness per project. * **Pronunciation dictionaries** to enforce correct rendering of brand names, product names, and technical terms. ## Where it fits in a workflow ElevenLabs is the default because it is the safest choice across the widest range of narrative content. It earns its place on voiceover, audiobook, and character-driven material in widely spoken languages, particularly where the same voice has to appear across several target languages. It is over-specified for instructional and corporate content, where [OpenAI TTS](/apis/tts-apis/openai-tts) or [Deepgram](/apis/tts-apis/deepgram-aura) will not be perceptibly worse to most audiences. ## Trade-offs * **29 languages is the second-narrowest coverage in the catalog**, ahead of only Deepgram. [Cartesia](/apis/tts-apis/cartesia) covers 44 and [Gemini TTS](/apis/tts-apis/gemini-2-5-tts) reaches 99. * **Quality falls off outside the main languages**, where the model loses subtlety and reviewers report tonal drift within a single render. ## Reference * [Text-to-Speech provider catalog](/providers/text-to-speech) * [ElevenLabs models](https://elevenlabs.io/docs/models) * [ElevenLabs Scribe (speech-to-text)](/apis/stt-apis/elevenlabs-scribe) # Gemini Text-to-Speech API Source: https://api-docs.ollang.com/apis/tts-apis/gemini-2-5-tts Google Gemini TTS — 99-language, prompt-controlled speech generation with multi-speaker dialogue, across the Gemini 3.1 Flash and Gemini 2.5 TTS model versions. **Gemini TTS** is Google's speech generation family, and the broadest-reaching voice engine in the Ollang catalog. Two things distinguish it: **99 supported languages**, more than any other engine here, and **multi-speaker synthesis** — two distinct speaker voices rendered into a single generation, each preserving its own tone, pitch, and style across the exchange. Delivery is controlled with natural-language prompts covering style, accent, pace, tone, and emotion, rather than with parameter sets. **Available in Ollang Workflows** as `geminiElevenlabs` — AI Dubbing. See the [Text-to-Speech catalog](/providers/text-to-speech). ## Model versions Google documents three Gemini TTS models on the Gemini API, all currently in preview: | Model ID | Single speaker | Multi-speaker | Streaming | Notes | | - | - | - | - | - | | `gemini-3.1-flash-tts-preview` | Yes | Yes | Yes | Newest version; the only one supporting streaming audio | | `gemini-2.5-pro-preview-tts` | Yes | Yes | No | High control for structured workflows such as podcasts and audiobooks | | `gemini-2.5-flash-preview-tts` | Yes | Yes | No | Efficient generation for everyday volume | On Google Cloud Text-to-Speech the same family is published as `gemini-3.1-flash-tts-preview`, `gemini-2.5-pro-tts`, `gemini-2.5-flash-tts`, and a single-speaker-only `gemini-2.5-flash-lite-preview-tts`. ## Coverage and limits | | | | - | - | | **Languages** | 99 on the Gemini API; 90+ on Google Cloud TTS, of which 22 are GA and the remainder preview | | **Voices** | 30 on the Gemini API; 28 on Google Cloud TTS | | **Speakers per generation** | Up to 2 | | **Session context** | 32k tokens | | **Cloud TTS request limits** | Input text up to 4,000 bytes, style prompt up to 4,000 bytes, 8,000 bytes combined; output up to roughly 655 seconds | ## Key capabilities * **Multi-speaker in one pass** — a two-hander is generated as a conversation rather than as separate lines stitched together, which is what keeps turn-taking and interruption sounding natural. * **Prompt-directed delivery** — style, accent, pace, tone, and emotion are written in natural language, closer to how a voice director works than to how a TTS parameter set works. * **Widest language reach in the catalog** at 99 languages, covering many locales that Cartesia, ElevenLabs, and Deepgram do not serve at all. * **Code-switching within sentences**, with intonation appropriate to each language. * **Streaming** on the 3.1 Flash version, for pipelines that consume audio before generation completes. ## Where it fits in a workflow Two situations make Gemini TTS the right call: 1. **Language reach.** If a program has to ship in locales that the 29-language and 44-language engines do not cover, this is the option that makes it possible without falling back to a second provider. 2. **Performed dialogue.** Scripted two-character scenes, dramatized narrative, and immersive content where the exchange between speakers is the point. For single-speaker informational content in major languages, [Cartesia](/apis/tts-apis/cartesia) or [OpenAI TTS](/apis/tts-apis/openai-tts) will serve just as well with less setup. ## Trade-offs * **All TTS versions are in preview**, so behavior may change between releases. Re-benchmark after a version change rather than assuming parity. * **Two speakers maximum** per generation, and a 32k-token session context — long multi-character scenes have to be segmented. * **Expressiveness depends on prompting.** Undirected output sits much closer to the field than the ceiling suggests, so budget effort for direction. ## Reference * [Text-to-Speech provider catalog](/providers/text-to-speech) * [Gemini API speech generation](https://ai.google.dev/gemini-api/docs/speech-generation) * [Gemini-TTS on Google Cloud](https://docs.cloud.google.com/text-to-speech/docs/gemini-tts) # Microsoft Text-to-Speech API Source: https://api-docs.ollang.com/apis/tts-apis/microsoft-azure-tts **Microsoft Text-to-Speech (TTS) API** is part of Azure Cognitive Services, providing advanced speech synthesis capabilities to convert text into lifelike speech using AI. This service is ideal for creating engaging and natural-sounding voice applications. This page covers the Azure Cognitive Services speech synthesis surface generally. For the voice and locale catalog, see [Azure Neural Voices](/apis/tts-apis/azure-neural-voices); for the provider option selectable in Ollang Workflows, see [Azure + ElevenLabs](/apis/tts-apis/azure-elevenlabs). ## Key Features * **High-Quality Voices**: Offers a wide selection of natural-sounding voices in multiple languages and styles, including neural voices that provide high-fidelity audio output. * **Neural Text-to-Speech (NTTS)**: Utilizes advanced neural network models to produce highly natural and expressive speech, with support for different emotions and speaking styles. * **Customization**: Allows for the creation of custom voices tailored to specific needs, ensuring brand consistency and unique voice identities. * **Real-Time and Batch Processing**: Supports both real-time speech synthesis for immediate needs and batch processing for large volumes of text. ## Advanced Technologies * **Speech Synthesis Markup Language (SSML)**: Supports SSML to fine-tune speech output, enabling control over aspects like pronunciation, intonation, and pacing. * **Emotional Tones**: Provides various emotional tones and speaking styles to make speech more engaging and suitable for different contexts. * **Scalability and Flexibility**: Designed to scale with demand, making it suitable for applications ranging from small-scale projects to large enterprise solutions. ## Use Cases 1. **Content Creation**: Ideal for generating voiceovers for videos, audiobooks, and podcasts, enhancing accessibility and user engagement. 2. **Customer Support**: Enhances interactive voice response (IVR) systems with natural-sounding voices, improving the customer service experience. 3. **Accessibility**: Improves accessibility by converting text content into speech for visually impaired users, making websites and applications more inclusive. For more details and to access the API, visit [Microsoft Text-to-Speech API](https://azure.microsoft.com/en-us/services/cognitive-services/text-to-speech/). # OpenAI Text-to-Speech API Source: https://api-docs.ollang.com/apis/tts-apis/openai-tts OpenAI's steerable text-to-speech — instruction-controlled delivery and 13 built-in voices, available for AI Dubbing in Ollang. **OpenAI Text-to-Speech** converts text into spoken audio using OpenAI's audio model line. Its defining feature is **steerability**: alongside the text you supply an instruction describing *how* it should be delivered, and the model adjusts accordingly. This was the first mainstream TTS API to expose delivery as an instruction rather than as a per-voice parameter set. **Available in Ollang Workflows** as `openaiTts` — AI Dubbing. See the [Text-to-Speech catalog](/providers/text-to-speech). ## Models and voices | Model | Description | Voices | | - | - | - | | `gpt-4o-mini-tts` | Newest and most reliable; the only model supporting instruction-based steering | All 13 | | `tts-1` | Lower latency, lower quality | 9 | | `tts-1-hd` | Higher quality | 9 | The 13 built-in voices are **alloy, ash, ballad, coral, echo, fable, nova, onyx, sage, shimmer, verse, marin,** and **cedar**. `tts-1` and `tts-1-hd` support the subset alloy, ash, coral, echo, fable, onyx, nova, sage, and shimmer. Output formats: MP3 (default), Opus, AAC, FLAC, WAV, and PCM. ## Steering On `gpt-4o-mini-tts`, the `instructions` parameter controls: * **accent** * **emotional range** * **intonation** * **impressions** * **speed of speech** * **tone** * **whispering** An instruction such as *"speak in a warm, reassuring tone with occasional pauses for emphasis"* changes the performance without changing the voice. For dubbing this is the practical substitute for line-by-line direction. ## Where it fits in a workflow This is the engine for **volume with direction**: internal communications, training modules, product walkthroughs, compliance content, and first-pass drafts, where delivery needs steering but a bespoke voice identity does not. A useful pattern: run the full backlog through OpenAI TTS, review, and re-run only the segments that need a distinctive voice through [Cartesia](/apis/tts-apis/cartesia) or [ElevenLabs](/apis/tts-apis/elevenlabs). ## Trade-offs * **No custom or cloned voices.** A character cannot be carried across a series with a distinctive voice identity the way ElevenLabs, Cartesia, or Azure custom neural voices allow. If brand voice consistency is a requirement, this is the disqualifying constraint. * **Language support broadly follows Whisper's 50+ languages, but the voices are optimized for English.** Quality outside English is less consistent than the language count suggests — benchmark your specific target languages rather than assuming parity. * **Narrower expressive ceiling** than [Gemini TTS](/apis/tts-apis/gemini-2-5-tts) or Cartesia on performed content. ## Reference * [Text-to-Speech provider catalog](/providers/text-to-speech) * [OpenAI text-to-speech guide](https://developers.openai.com/api/docs/guides/text-to-speech) # PlayHT Text-to-Speech API Source: https://api-docs.ollang.com/apis/tts-apis/playht **PlayHT** provides advanced AI-powered text-to-speech capabilities with a focus on natural-sounding voices and extensive customization options. Their platform offers both cloud-based and on-premise solutions for various TTS applications. ## Key Features * **High-Quality Voices**: Offers over 800+ natural-sounding voices across 142+ languages and accents. * **Voice Cloning**: Advanced voice cloning technology allows users to create custom voices from audio samples. * **Real-time Generation**: Provides fast TTS generation suitable for real-time applications and streaming. * **Customizable Speech**: Extensive control over speech parameters including speed, pitch, and emotion. ## Advanced Technologies * **Neural TTS**: Utilizes state-of-the-art neural networks for lifelike voice synthesis. * **Emotion Control**: Can generate speech with specific emotions and tones to match content requirements. * **Multi-format Support**: Outputs audio in various formats including MP3, WAV, and streaming formats. * **API Integration**: Comprehensive REST API with SDKs for multiple programming languages. * **Enterprise Features**: Offers on-premise deployment options for security-sensitive applications. ## Use Cases 1. **Content Creation**: Ideal for creating voiceovers for videos, podcasts, and audiobooks with natural-sounding voices. 2. **E-learning**: Enhances educational content with clear, engaging speech synthesis for various learning materials. 3. **Accessibility**: Improves accessibility by converting text content into speech for visually impaired users. 4. **Customer Experience**: Powers interactive voice responses and virtual assistants with natural-sounding voices. For more details and to access the API, visit [PlayHT](https://play.ht/). # Resemble AI Text-to-Speech API Source: https://api-docs.ollang.com/apis/tts-apis/resemble-ai **Resemble AI Text-to-Speech (TTS) API** provides advanced, customizable voice generation capabilities, enabling the creation of lifelike synthetic voices suitable for a wide range of applications. ## Key Features * **High-Quality Voices**: Generates realistic AI voices that are virtually indistinguishable from human speech, suitable for applications in entertainment, customer service, and more. * **Rapid Voice Cloning**: Capable of creating a new voice with just a few seconds of audio data, facilitating quick and efficient voice cloning. * **Multilingual Support**: Supports over 60 languages, allowing for broad applicability in global markets. * **Custom Voices**: Allows for the creation of custom voices tailored to specific needs, ensuring brand consistency and unique voice identities. ## Advanced Technologies * **Speech-to-Speech Conversion**: Transforms input speech into another voice in real-time, useful for applications requiring voice modulation. * **SSML Support**: Utilizes Speech Synthesis Markup Language (SSML) to fine-tune aspects of speech output, such as pronunciation, intonation, and pace. * **Neural Audio Editing**: Enables precise editing of synthetic voices, making it easier to adjust and perfect audio output. ## Use Cases 1. **Content Creation**: Ideal for generating voiceovers for videos, audiobooks, podcasts, and other multimedia content, enhancing accessibility and engagement. 2. **Customer Support**: Improves interactive voice response (IVR) systems and call centers with natural-sounding, responsive voices. 3. **Entertainment**: Enhances video games, movies, and other entertainment media with lifelike character voices and narration. For more details and to access the API, visit [Resemble AI](https://www.resemble.ai). # WellSaid Labs Text-to-Speech API Source: https://api-docs.ollang.com/apis/tts-apis/wellsaid-labs **WellSaid Labs Text-to-Speech (TTS) API** offers state-of-the-art AI-driven text-to-speech services, providing lifelike voice generation suitable for various applications, from content creation to customer support. ## Key Features * **High-Quality Voices**: Utilizes advanced AI models to create realistic and human-like voices, supporting over 150 combinations of voices and styles. * **Fast Rendering**: Achieves fast rendering speeds, with approximately 500ms per 35 characters, ensuring seamless integration for real-time applications. * **Custom Voices**: Supports the deployment of custom voices tailored to specific needs, enhancing brand consistency and user engagement. * **Wide Language Support**: Strong English coverage; additional locales and voice options evolve — see [WellSaid Labs](https://wellsaidlabs.com) for the current language and voice list. ## Advanced Technologies * **SSML Support**: Supports Speech Synthesis Markup Language (SSML) for fine-tuning speech output, allowing control over aspects like pronunciation, volume, pitch, and speed. * **Real-Time Streaming**: Provides a streaming endpoint for real-time audio generation, reducing latency and improving user experience in live applications. * **Elastic Infrastructure**: Built to scale with your needs, ensuring high performance and reliability even under heavy usage. ## Use Cases 1. **Content Creation**: Ideal for generating voiceovers for videos, e-learning materials, audiobooks, and podcasts, enhancing accessibility and engagement. 2. **Customer Support**: Enhances interactive voice response (IVR) systems with natural-sounding voices, improving the customer service experience. 3. **Marketing and Advertising**: Personalizes marketing content with custom voice avatars, enabling the creation of engaging and effective advertising campaigns. For more details and to access the API, visit [WellSaid Labs Text-to-Speech API](https://wellsaidlabs.com). # Changelog Source: https://api-docs.ollang.com/changelog Product updates, new APIs, and platform announcements Updates to the Ollang public API, SDK, MCP server, and developer integrations. ## Attach a folder guideline by uploading the file Folder-level documents can now be sent as a file upload, not only as a URL: [Upload Folder Document](/apis/ollang-api-reference/upload-folder-document) — `POST /integration/folder/{folderId}/docs/upload`, `multipart/form-data` with `file`, `type`, and optional `name` and `language`. The limit is 50 MB. This works the same way as [Upload VTT File](/apis/ollang-api-reference/upload-a-vtt) and [Direct File Upload](/apis/ollang-api-reference/direct-file-upload), so you no longer need to host a guideline or generate a pre-signed URL just to attach it. The existing URL-based [Attach Folder Document](/apis/ollang-api-reference/attach-folder-document) is unchanged and still available for files you already host. Both produce the same result: the document is applied to every project in the folder and to projects created in it afterwards. ## Uploads without a usable filename are rejected up front [Direct File Upload](/apis/ollang-api-reference/direct-file-upload) takes the stored file's extension from the multipart `file` part's filename, not from the `name` field. A part sent without one — a bare JavaScript `Blob` defaults its filename to `blob` — was stored as `.blob`, the document pipeline failed on it, and the project was persisted anyway. [Create Order](/apis/ollang-api-reference/create-order) against that project then returned `404 UploadRecordNotFoundException`, and every retry left another orphan project behind. Such an upload now returns `400 Unsupported file type` before the project is created, so a rejected upload leaves nothing behind. The same check applies to the URL-based variant, `POST /integration/upload/direct-url`. ## `name` no longer gets a duplicated extension The uploaded file's extension was appended to `name` unconditionally, so a `name` that already carried it came back as `translated_strings_en.json.json`. The extension is now only appended when `name` does not already end in it. ## SDK releases: Node 0.4.1, Python 0.2.1, Java 0.2.1 VTT uploads now take the source project ID and a display name instead of an order ID, matching the API. Existing callers must update these arguments. The response contains `projectId`. ## Node SDK * `uploads.direct()` and `uploads.vtt()` send the file under a real filename — the `File`'s own name, a new `filename` parameter, or the display name — instead of letting `FormData` default it to `blob`. This was the root cause of the `.blob` uploads above. * `import Ollang from "@ollang-dev/sdk"` works under native ESM. The class was exported by name only in practice, and the default import resolved to the module namespace, throwing `Ollang is not a constructor`. `import { Ollang }` keeps working. * `orders.get()` exposes the nullable QC result as `latestEvaluation`, matching the API. * `orders.get()` results now declare `orderDocs`, along with the rest of the fields the endpoint returns. Reading the signed download links no longer needs a cast. * The packaged README's quick start matched a pre-0.4.0 surface (`uploads.upload()`, `orders.create({ sourceLanguage, targetLanguages })`). It now matches the shipped API and this site. ## Python SDK `uploads.direct()` and `uploads.vtt()` take a `filename` parameter, for raw bytes and in-memory streams that carry no name of their own. Paths and open files are unchanged — they already supplied one. ## Manage folder-level guidelines without the dashboard Folder-level documents — guidelines, glossaries, and character lists — can now be listed, attached, and removed through the API. Previously they could only be managed from the folder's **Guidelines** panel in the dashboard. * [List Folder Documents](/apis/ollang-api-reference/list-folder-documents) — `GET /integration/folder/{folderId}/docs` * [Attach Folder Document](/apis/ollang-api-reference/attach-folder-document) — `POST /integration/folder/{folderId}/docs` * [Remove Folder Document](/apis/ollang-api-reference/delete-folder-document) — `DELETE /integration/folder/{folderId}/docs/{docId}` Behaviour matches the dashboard: an attached document applies to every project already in the folder and to projects created in it afterwards, and removing it detaches it from those projects too. Attach accepts a pre-signed URL — Ollang fetches the file and stores its own copy, so the document stays readable to later orders after your signature expires. ## Folder guidelines now reach projects created by direct upload Projects created through [Direct File Upload](/apis/ollang-api-reference/direct-file-upload) into a folder did not inherit that folder's guideline documents, while projects created in the dashboard did. They now do. Guidelines already attached to your folders apply to new API-created projects from this release onward; projects created before it are unchanged. A folder document attached with a `language` now also keeps that language on the copies inherited by projects created later. Copies previously fell back to no language. ## Track an order's delivery history programmatically [Get Order by ID](/apis/ollang-api-reference/get-order-by-id) (`GET /integration/orders/{orderId}`) now returns a `deliveryEvents` array recording the order's delivery milestones, oldest first. Each event carries the milestone `type`, when it `occurredAt`, and which kind of actor produced it (`actorType` / `actorId`). Four milestones are recorded: `ai_delivered` when the AI pipeline finishes and AI results become available, `translator_delivered` when a translator delivers their work, `lsp_approved` when an LSP admin or project manager approves a member's delivery, and `order_delivered` when the deliverable becomes available to you. This removes the need to infer an order's history by polling `status`: a single call now shows when the AI stage completed, when human work landed on top of it, and when the order was delivered. The log is not backfilled — orders created before this release return an empty array, and populate as they hit new milestones. The same event type can appear more than once for a given order, for example on an LSP re-delivery or a rerun. ## Filter your jobs by status The **My Jobs** list in Translator Studio has a status filter in the filters drawer. Selecting a status matches the status shown on the job cards, so a single choice such as *Delivered* covers every underlying stage grouped under it, and jobs waiting for approval follow the same labelling you already see for your role. ## Translation readiness reads project source documents The translation readiness score on new orders now picks up source documents attached at the project level, not only files uploaded to the order, and auto-detection of context assets fires correctly for those documents. Text extraction falls back to a second parser for `.docx` files that the primary extractor cannot read, and scores are no longer produced from asset signals alone, so a score always reflects the source content that was actually analysed. ## Bulk download file names Bulk downloads of translated files use the full order id prefix in each file name, so orders whose names collide no longer overwrite each other in the archive. ## Filter the contents of a folder Folders now have a filter button next to the folder settings gear, letting you narrow the projects and orders inside a folder by status, source and target languages, and creation date. Multiple source or target languages can be selected at once, and the filter popover stays inside the viewport on narrow screens. ## Orders waiting on you are left alone The automatic retry that recovers stalled orders now skips orders that are intentionally waiting — for example waiting for closed captions, for subtitles, or for a review decision — so those orders are no longer reprocessed while they wait for input. ## Translate SVG files SVG files can be uploaded on new orders and in bulk upload alongside PNG and JPEG, are previewed in the order view, and are routed through the image translation pipeline. ## Faster order creation and reporting Order creation now writes once instead of three times after an order is created, the universal editor autosave no longer loads full document rows, consumption and payout lookups query only the records they need, and account lookups make fewer round trips. Together these make order creation, editing, and the consumption and credits views noticeably faster on large accounts. ## Figma integration API endpoints The API reference now documents the Figma plugin endpoints for [creating an order](/apis/ollang-api-reference/figma-create-order), [listing Figma orders](/apis/ollang-api-reference/figma-get-orders), and [checking order status](/apis/ollang-api-reference/figma-order-status). Figma order creation runs through the standard basket flow, so pricing, currency, and finance data on a Figma order match orders created anywhere else, and validation errors are reported clearly when the design or authorization is not usable. ## Rush delivery follows human review Rush delivery can now be selected only for target languages whose workflow includes human review, and a stale rush selection is cleared before checkout so you are never charged for rush on a language that cannot benefit from it. A rush eligibility check is available per target language while building the basket. ## Revision window enforced consistently The 14-day revision window is now enforced on every client revision endpoint, with the remaining window calculated the same way across revision and reorder requests so the error message matches the actual deadline. ## Subtitle exports and delivery Downloaded SRT files always use commas as the decimal separator in timestamps, as the format requires, so exports open correctly in every subtitle tool. Mix Master generation ignores the global M\&E and vocal volume controls, and speaker selection is off by default on SDH orders. ## Bulk segment delete in Studio Segments selected with CTRL+SHIFT+click in Translator Studio can be deleted in one action. ## Steadier SSO sign-in The one-time code issued during SAML single sign-on is valid for five minutes instead of one, so slower identity providers no longer fail the hand-off. ## Element ids in the content editor The content editor shows the element id under each source text, making it easier to match a string back to the file or CMS field it came from. ## Links from branded file-sharing domains Automatic download of source files now accepts branded subdomains of supported file-sharing providers, so links from a company-specific transfer domain are imported instead of rejected. ## Tridion connector: full publications Batches submitted from the Tridion browser extension expand to the whole publication when the job name marks it as a full run, and the batch is checked against the object limit before anything is created so an oversized run fails up front instead of halfway through. ## Glossary and translator document fixes Glossary term counts no longer drop twice when the same term is deleted repeatedly, context asset detection samples each memory so a large translation memory cannot crowd out the others, and order details return the most recent translator document version. ## Classification and readiness in one place Content classification results are shown inline on the content terms view with both the deterministic and AI confidence scores, and the readiness card explains what to add to raise a low score instead of only reporting the number. ## Segment-level glossary matching Glossary and memory matching runs per segment with fuzzy-match diagnostics, so evidence shown on an order points at the exact segment a term or match came from. ## Deliver a chosen Visual Translation version The Visual Translation version selected in Translator Studio is saved to the order and used for delivery, subtitle burn-in, and lip sync, and it resets when a translation is rerun. Project managers at language service providers can select the version, and the selection is dropped once an order is delivered. ## AI confidence in the content editor Segments in the content editor are colour-coded by their classification, with the AI confidence score shown per segment so low-confidence lines are easy to find and review first. ## Steadier AI dubbing playback AI dubbing preview playback is scheduled by a dedicated audio service, so segments no longer stutter or replay when a short segment sits inside a longer box. ## Dubbing style defaults Switching a template back to AI Dubbing resets the dubbing style to Vocal Replacement instead of keeping the previously chosen style, and the re-translate tooltip is now available in Turkish and Indonesian. ## See what the retranslation changed After retranslating a Visual Translation order, each on-screen text entry in Translator Studio carries a change badge showing whether the AI updated the line, so you can review only what moved instead of re-reading every block. The badge clears as soon as you edit the entry yourself, and only the edits actually sent to the model are kept in the comparison snapshot. ## Click an on-screen text entry to seek the video Selecting an on-screen text entry now jumps the video player to the moment that text appears, making it faster to check a correction in context. ## Better processing-time estimates The progress banner for a running Visual Translation now estimates remaining time from previous runs of comparable duration instead of a fixed guess. ## Downloads with non-Latin file names Signed download links now work for files whose names contain Japanese characters, `#`, or other characters that were previously mangled during URL signing. ## Jump between related orders in Translator Studio The Studio header now lists the orders related to the one you are working on — parent, child, and sibling orders such as other target languages or follow-up steps — so you can switch between them from the order type/language badge without going back to the order list. Only orders in client-visible statuses are listed. ## Faster timeline on long videos The Studio timeline now renders only the segments near the visible range, so long subtitle and dubbing timelines scroll smoothly while every segment in view still gets a box, including after a window resize. ## Language switcher in the dashboard The dashboard account menu now has a **Language** row for switching between the supported interface languages (English, Turkish, French, Spanish, Korean, and Portuguese). ## Review gates Workflows that reuse the same review step in more than one position no longer produce duplicate review gates; gates are now identified by their position in the workflow. ## Subtitles burn onto the lip-synced video When an order includes lip sync, embedded subtitles are now burned onto the lip-synced render rather than the audio mix master, and the embed step only waits for a lipsync output when one is actually produced. ## Google Drive delivery Localized subtitle embeds are retried before delivery to Google Drive, so a slow embed no longer drops deliverables from the exported folder. ## Recognizable AI dubbing file names Created M\&E, source-vocals-only, and AI Dubbing audio deliverables are now prefixed with the order name so files from different orders are easy to tell apart. ## Memory export accuracy TMX export preserves emoji and other astral characters, and item counts stay correct for legacy memories after a rename. ## Figma orders for translators Translators can now open the Figma editor view for document orders directly, with the target language carried into the editor, and the Figma import endpoints accept verified translator access. Delivery of Figma orders is faster, and the apply step explains what the plugin does instead of pointing at manual steps. ## Tridion connector: folder and Jira prefix Publication batches submitted from the Tridion browser extension now honor the folder you selected in the widget and apply the configured Jira prefix, so orders land in the right place in the dashboard. ## Upload safeguards Direct uploads into a deleted folder are now rejected instead of silently creating an orphaned document, and the subtitle player computes its overlay box from the actual video resolution. ## Subtitle preview matches the embedded output Subtitle position is now stamped onto the order, so previews in the dashboard and Translator Studio line up with the burned-in video even when a project has no aspect ratio configured. Legacy top and bottom positioning share the same logic, and preview fonts match the embed. ## Subtitle formatting constraints are opt-in Characters-per-second and line-length constraints are applied only when enabled for the project, so provider-supplied cue layouts are preserved by default. ## Credit totals at checkout Clients billed in AI credits now see the credit total for a new order, a shortfall warning, and a direct buy-credits action, and checkout is gated until enough credits are available. ## Manage translation memories via the API Translation memories can now be fully managed through the public API. New endpoints let you [create](/apis/ollang-api-reference/create-memory), [retrieve](/apis/ollang-api-reference/get-memory-by-id), [rename](/apis/ollang-api-reference/update-memory), and [delete](/apis/ollang-api-reference/delete-memory) memories, alongside the existing [List Memories](/apis/ollang-api-reference/list-memories) endpoint (`GET /integration/memories`), which is now also documented. ## Import translation units into a memory A new [Import Memory Items](/apis/ollang-api-reference/import-memory-items) endpoint (`POST /integration/memories/{memoryId}/items/import`) queues translation units (source/target text per language pair) for import into a memory — up to 1000 units per request. Units are processed asynchronously through the same pipeline as dashboard file uploads, including the vectorization step that powers semantic matching. A companion [Get Memory Import Job](/apis/ollang-api-reference/get-memory-import-job) endpoint (`GET /integration/memories/import-jobs/{jobId}`) tracks import and vectorization progress. All endpoints require API key authentication. ## Embedded subtitles on the Final Visual Translation video Subtitle and closed-caption orders can now be delivered as a **Final Visual Translation – Embedded Subtitles** video: the visual translation render is offered in bulk download, lip sync is preserved in the final video, and both embed variants for an order are produced in a single batch so you receive one zip and one email. ## After Effects packages belong to a project An After Effects package uploaded with an order is attached to the project, so the same upload can no longer be split across two projects, order-level uploads are blocked where the project already owns the package, and upload state is cleared when you change the order type. ## Image translation uses your instructions Image translation now receives your resolved custom instructions and project notes as reference knowledge, so terminology and tone preferences carry into translated images. ## Review gates A completed order is never pulled back into a review gate. ## Status board on folder detail Folder detail pages gained a **Status** group-by option that lays orders out as a kanban board, with columns filtered server-side and a clear indicator when a column has more orders than it can display. ## Figma reruns: delta pricing Rerunning a Figma import now reimports the file as part of the rerun — the separate re-import action is gone — and shows the delta cost for newly added words instead of recharging the whole file. Duplicate file imports and already-translated pages are skipped, and failed imports are cleaned up before a retry. ## Translation memories for API clients API-key clients can now list translation memories and attach them to orders, and orders listings accept a `statuses` filter. ## Tridion connector: translation memory picker The Tridion browser extension order widget now includes a translation memory picker, and the selection is snapshotted with the order so it is reflected back by the order endpoints. ## Content editor Numeric-only source segments are hidden from the client content editor, and bulk saves are queued so page changes and searches cannot lose a pending edit. ## Retranslate with live processing status Retranslate is now a toolbar dropdown in Translator Studio that reports live progress: it polls for completion, shows a success banner when the run finishes, keeps the processing state if you reload the page, and surfaces a failure banner with retry if a run exceeds its expected time. Error toasts are shown when a submit or status check fails, and editing an on-screen text field no longer loses focus or cursor position while autosave runs. ## Multi-type context asset picker on new order When creating an order you can now select translation memories, glossaries, and style guides together in one picker, with automatically resolved assets pre-seeded and custom instructions shown read-only. ## Review evidence filters Order details show classification chips for the assets used in a translation, with per-segment filters in the evidence drawer, and the order details layout no longer overflows horizontally. ## Document reruns Rerunning a document order clears stale content terms and previous document data, so the new run starts from a clean state. ## On-screen text editing mode in Translator Studio Visual Translation orders now expose the on-screen text detected in the video as an editable layer in Translator Studio. Each detected text block keeps its source and translated text, and edits autosave as you work, so burned-in graphics, lower thirds, and signage can be corrected without waiting for a full re-run. ## On-screen text edits feed the retrigger When a Visual Translation order is retriggered, your saved on-screen text edits are passed to the model as **On-Screen Text Edits** context alongside any custom prompt, so re-runs keep the corrected wording instead of reverting to the original detection. ## New MCP client guides Added setup and workflow guides for [Hermes Agent](/mcp/use-cases/hermes), [Grok Build](/mcp/use-cases/grok-build), and [OpenClaw](/mcp/use-cases/openclaw), including their verified remote MCP configuration formats and Ollang-specific localization examples. ## Browser extension integrations Added documentation for the [Tridion browser extension integration](/mcp/integrations/tridion) and [TikTok One browser extension integration](/mcp/integrations/tiktok-one), including API-key setup, document and campaign order flows, order monitoring, and QC behavior. ## Official MCP server migrations Updated the Airtable, Notion, Vimeo, Strapi, Dropbox, and YouTube integration guides to distinguish official hosted servers from community alternatives and document current OAuth, Streamable HTTP, and self-hosted configuration paths. ## New integrations and clients Added localization workflows for [Figma](/mcp/integrations/figma), [GitHub](/mcp/integrations/github), [Contentful](/mcp/integrations/contentful), and [Webflow](/mcp/integrations/webflow). Added [Claude.ai](/mcp/use-cases/claude-ai) connector-directory setup plus configuration guides for Windsurf, VS Code, Gemini CLI, Codex CLI, and Cline. ## Searchable AI model picker on the workflow canvas The AI model dropdown on workflow nodes is now searchable, so you can type to filter instead of scrolling the full provider and model list when building or editing a workflow. ## Subtitle embedding matches Studio preview Embedded subtitles no longer auto-bold lines that start with a speaker label followed by a colon, legacy font sizes are scaled to match what you see in the Studio preview, and canvas width is omitted when a project has no design canvas — so the burned-in output matches the preview. ## Tridion connector: Traditional Chinese and larger batches Traditional Chinese (`zh-Hant`) now maps to the Tridion `zh-TW` language list value, and publication batches accept up to 20 objects per request with clearer logging that separates an empty baseline from an unmatched root map. ## Subtitle context on Visual Translation retrigger Retriggering a Visual Translation order now sends the existing subtitle source and target pairs as reference knowledge, improving consistency between the subtitle track and translated on-screen text. ## Public share links Publicly shared orders now render document and image previews with the same viewer used inside the app, play videos with the correct subtitle overlay, and no longer show a session-expired prompt when the visitor has stale cookies from a previous session. ## Subtitle preview alignment The subtitle overlay in the video player now follows the project aspect ratio and configured position, keeps the design-canvas preview when a project aspect is set, and stays in sync with the playhead, with improved readability while scrubbing. ## Review gates for AI Dubbing Configurable review gates now support AI Dubbing orders on the **text-to-speech** step, including a new **always** gate mode that makes the QC threshold optional, a manual trigger for gate entry, the gate mode shown on the assignment, all gate stages listed in order history, and regeneration of output files when an order exits the gate. ## Checkout return pages Buying AI credits or a subscription now returns you to a dedicated confirmation page in the dashboard after Stripe checkout, and purchase totals are only shown once the payment is verified. ## Billing Access is owner-only Only account owners can grant the Billing Access role to team members; existing assignments are unaffected when other fields are edited. ## Bulk download modal A new bulk download dialog lets you pick the scope and output formats for multiple completed orders at once, offers only the formats the selected scope can actually produce, keeps project-level downloads scoped to the selected projects, and delivers a single email per request instead of one per file. ## Workflow template defaults Creating a workflow template now pre-fills your default client preferences, and stale preference data is no longer carried into a newly created template. ## Faster order content editing The order content editor is paginated with server-side search, saves are serialized so pending edits are never lost when searching or changing pages, and content terms with empty target text are hidden from the client order view. ## Read-only workspace tools in Ollang Assistant The Ollang Assistant gained a set of read-only workspace tools, so it can answer questions about projects, folders, team members, and workflows directly in chat. Team listings include freelancers and are ordered newest-first. ## Analytics filters The date-range filter on the analytics dashboard now applies reliably without racing against chart loads, and the orders chart axis shows both day and month. ## Order lookup in Ollang Assistant The Ollang Assistant can now **list your own orders** in chat, scoped to your account and filterable by project and language pair, so you can ask for order status without leaving the conversation. ## Workflow model management from the Assistant The Assistant can now **list workflow templates, inspect a step, and change the AI model used by that step**, with ineligible providers rejected up front. ## Assistant chat experience Assistant answers containing tabular data now render as **clean data tables**, the chat panel is **resizable**, drag interactions no longer freeze the panel, and failed tool calls surface an error instead of failing silently. The underlying chat model was also upgraded for faster responses. ## Accurate AI credit limit emails The email sent when an action is blocked for credit reasons now states the **actual reason** — a monthly limit email is only sent when a monthly limit was what blocked the action. ## Adobe After Effects source files After Effects project files now appear as their own **Source Files** tab in the dashboard, and the project documents endpoint returns After Effects project documents alongside other source files. ## Automatic MCP access provisioning Connecting the **Ollang MCP server** now provisions API access automatically for a known account email, so no manual key setup step is required before the first MCP call. ## Reference files in Visual Translation Additional project files are now passed to the **Visual Translation** pipeline as reference material, while hidden or removed additional files are excluded from the payload. ## Dubbing style in workflows and preferences A **Dubbing Style** setting is now available on workflow templates and on folder and account preferences, with an auto-saving selector in the workflow editor. AI Dubbing orders created from a workflow **apply its dubbing style automatically** and pre-fill it on the order form, and the order preferences endpoint accepts a style-only update. ## Large video uploads Video uploads **above 10 GB** are no longer blocked for older accounts, bulk upload no longer creates duplicate projects, and additional files in a bulk upload resolve to their parent folder. ## Faster delivery when nothing changed Delivering an edit session with **no content changes** now skips the document rebuild, finalizes the order, and releases the translator immediately instead of re-running the full pipeline. ## Faster Translator Studio loading Translator Studio now boots without waiting on blocking requests, speaker lookups are **scoped to the open order** instead of rescanning the whole folder, and the waveform layout offset was restored. ## Delivered orders protected from automatic retrigger The automatic retrigger for stuck orders now **skips delivered orders**, so completed translator work can no longer be overwritten. ## Freelance translators without an LSP Freelance translators who are not attached to an LSP remain **assignable** to orders. ## In-app Help Center The dashboard now includes a **Help Center trigger** with in-product guidance available from the main layout. ## Tridion connector credentials The integration configuration modal now accepts **Tridion SOAP/ISH credentials**, so Tridion connections can be configured directly from the dashboard. ## Dashboard usability pass A round of behaviour fixes across the dashboard: matched terms are **highlighted in search results** and filter changes are debounced so rapid edits no longer clobber each other, folder grids use **infinite scroll** instead of a paginator, translation memory files can be **dragged and dropped** onto the empty state, support ticket threads read **oldest-first** with clearer status labels, eligible folder orders open directly in Translator Studio, and completed or delivered orders no longer redirect to the studio. ## Per-account AI credit rate The **Get AI Credits Status** response now includes a **`creditsPerUsd`** field — how many credits equal \$1 USD for your account. Convert any credit amount to USD with `credits / creditsPerUsd`. Accounts without a negotiated rate keep the default of 1000 credits = \$1. The **Consumption Breakdown** in the dashboard and its export now convert credits to USD at your account rate instead of the fixed default. ## Audio Description credit pricing Audio Description orders are now charged a **flat rate per minute of source media** and appear as a single **Audio Description** line in the consumption breakdown, instead of separate charges for each pipeline step (audio split, speech-to-text, text-to-speech). The closed-caption child order created automatically under an Audio Description order is not charged separately. ## Visual Translation preview The order preview player now plays the **translated video** for Visual Translation orders instead of the source video. ## List AI consumption line items A new [List Consumption](/apis/ollang-api-reference/list-consumption) endpoint (`GET /integration/consumption`) returns a paginated list of AI credit consumption line items — one row per provider run — equivalent to the dashboard **Consumption Breakdown** export. Each line includes credits used, USD equivalent, provider, service, requestor, and program tags, and supports filtering by date range, provider, order type, requestor, order id, and program tag. ## Get AI credit wallet balance A new [Get Credit Wallet](/apis/ollang-api-reference/get-credit-wallet) endpoint (`GET /integration/credits`) returns the account AI credit wallet: total, remaining, and used credits, each with its USD equivalent at the account rate of 1000 credits = \$1, along with the last sync date. Both endpoints require API key authentication and are restricted to account owners and billing managers (the key must belong to a user with the `client_owner` or `client_accessBillings` role). ## Reliable file downloads Source files, subtitle files, and other deliverables now **download directly** instead of opening in a browser tab, large files stream to disk rather than being buffered in memory, and failed requests no longer save an error page as the downloaded file. This applies to the client dashboard and the Translator Studio. ## DITA markup detection Plain text wrapped in angle brackets is no longer mistaken for **DITA markup** and locked in the editor, so translators can edit those segments normally. ## Faster translation memories Language-filtered memory queries and memory detail loading are now significantly faster on large memories, and bulk status updates and deletions are processed in batches so large operations complete reliably. ## Simplified memory management The separate **approve / unapprove** step for memory items has been removed. Memory items are now managed directly through their status, and the memory detail page reflects the simplified workflow. ## Edit sessions for orders in review Document orders that are in a **review state** can now start an edit session, so content can be corrected without waiting for the review to finish. ## Edit ongoing document orders in the content editor The **Edit** action on an ongoing document order now opens the order directly in the **content editor**, matching the Edit Content workflow, instead of routing to the Translator Studio. ## Overall Quality Score in the Get Orders API The **Get Orders** API response now includes an **`overallQualityScore`** field — the average of the latest QC evaluation dimension scores (0–100). The value is `null` when an order has no QC evaluation yet. ## Adobe InDesign (IDML) file support **IDML** files are now recognised as source documents across order creation, bulk upload, and project source files. Uploaded IDML files are typed as source documents and flow through the standard word-count pipeline. ## Custom CPS/CPL thresholds without hard caps Translator Studio now lets you set **custom CPS/CPL warning and error thresholds** without upper limits. The previous maximum values are now shown only as recommendations in the field tooltips. ## AI Dubbing script XLSX export Order Preview now offers an **AI Dubbing Script (XLSX)** download for AI Dubbing orders, exporting the full dubbing script — speakers, segments, and timecodes — as a spreadsheet. ## Single source-file enforcement Document orders are now limited to a **single source file**, and projects are restricted to a **single source video**. The upload area is hidden while an upload is in flight to prevent accidental multi-file submissions. ## Adobe After Effects in Visual Translation Visual Translation orders now recognise **Adobe After Effects** project files as a supported document type. ## Reliable save on delivery The Translator Studio now **flushes all pending edits before an order is delivered**, so in-progress segment changes can no longer be lost at delivery time. ## Faster Speakers dialog Resolved a multi-second freeze when opening the **Speakers dialog** in AI Dubbing projects. ## Overlapping segment validation for Audio Description For Audio Description orders, **overlapping segments are now flagged as errors**, helping editors catch timing conflicts before delivery. ## Spanish (United States) **Spanish (United States) (es-US)** is now selectable as a source/target language across order creation, transcription, and text-to-speech. Speech-to-text resolves to the native es-US locale on Azure, Google, and AWS. ## Automatic source language detection When you upload a source file, the platform now **auto-detects the source language** and pre-fills it on the order form, re-detecting when the file changes. ## Client-owner review gate triggers Order owners and creators can now **push their own orders into a review gate** directly from the order details page, without waiting for an admin. ## 10-minute limit for LipSync and In-video Text Translation LipSync and In-video Text Translation add-ons are now capped at **10 minutes** of content. The order form automatically disables these visual features when the source exceeds the limit. ## Image uploads in Visual Translation Visual Translation orders now accept **PNG and JPEG image uploads** as document sources, validated against the document size cap. ## Audio Description output preferences A new **Audio Description output preferences** section in client Configurations lets you set default AD delivery options that apply to new orders. ## Review gate history Order detail pages now include a **review gate history** section showing each gate an order has passed through, backed by a review-gate history endpoint for client orders. ## Translator tags in search and exports Translator tags now appear **under the status in advanced/global search results** and are included in Excel exports, making it easier to filter and report on tagged translators. ## LSP bulk actions LSP administrators can now **bulk assign, unassign, and approve** orders from the dashboard, with role-based authorization for project managers. ## TTML subtitle download format Subtitles can now be downloaded in **TTML** format (delivered with an `.xml` extension) alongside the existing subtitle formats. ## Native PDF document preview Document preview now renders PDFs **natively with pdf.js** instead of the previous third-party viewer, for faster and more reliable in-browser previews. ## Richer global search columns Global search results now include **order type, word count / duration, and unit** columns for quicker scanning. ## TikTokOne progress overview The TikTokOne browser extension's orders modal gained a **colorized segmented progress overview** that visualizes order stages at a glance. ## AI Dubbing auto-paraphrase toggle A new **Auto Paraphrase for AI Dubbings** toggle is available in the Configurations section. When enabled, the TTS engine may rephrase text for more natural-sounding output on fully-AI dubbing orders. The setting is off by default. ## Batch assign language pair filtering Batch assign orders now supports **source/target language pair filtering**, letting you narrow the assignment scope to a specific language combination before selecting translators. ## TCR OUT column in subtitle XLSX export The XLSX subtitle export now includes an **end time (TCR OUT)** column alongside the existing start time, giving editors complete timecode coverage in spreadsheet exports. ## Translator content editing Translators can now be assigned to **edit delivered content** directly. When a translator delivers edited content, the platform automatically triggers document rebuild and image regeneration. LSP admins and PMs can also access order documents in edit mode. ## Google Drive Configure Folders The **Configure Folders** action is now available on connected Google Drive cards in the client dashboard. Manage pull and push folder mappings — including source/target languages, order type, and internal folder assignment — without leaving the platform. ## Duplicate basket item warnings The basket now flags potential duplicate orders when the same project, order type, and source/target language combination appears more than once, helping avoid accidental duplicate submissions. ## Cartesia Sonic 3.5 TTS with 42-language support The Cartesia TTS provider has been upgraded to the latest **Sonic 3.5** model. Language coverage is expanded from 15 to **42 languages**, adding Arabic, Hebrew, Thai, Vietnamese, and Indian languages among others. ## Subtitle embedding on dubbed video Subtitle embedding now supports burning captions onto **localised dubbed video**. When enabled, the output file contains both the dubbed audio track and burned-in subtitles in a single deliverable. ## Custom instructions in workflow templates Workflow templates now support a **Custom Instruction** field. Add persistent instructions that apply every time the template is used for order creation. ## Download speaker audio In AI Dubbing projects, translators can download a **speaker's combined audio** as a single file from the order documents panel. The platform merges all segment audio for the selected speaker into one deliverable. ## User onboarding flow New users are now guided through a **step-by-step onboarding wizard** covering personal information, dynamic configuration questions, and plan selection. ## Skip to Complete for review gates Reviewers can now use a **Skip to Complete** option to bypass the next review gate in an approval workflow, moving the order directly to the following stage without waiting for additional sign-off. ## Segment gap adjustment for AI Dubbing A new segment gap adjustment tool is available in AI Dubbing projects. Fine-tune the timing between segments to improve pacing and synchronization of dubbed audio. ## VTT without Styling bulk download Added a **VTT without Styling** format option for bulk subtitle downloads. This strips all formatting tags (bold, italic, underline, strikethrough) from WebVTT files, producing clean plain-text captions. ## TikTokOne browser extension redesign The TikTokOne browser extension has been redesigned with a modern popup interface and an improved orders panel for faster navigation and a cleaner workflow. ## Video file versioning for redelivery Improved video file versioning in redelivery workflows to ensure the correct file version is used when regenerating and delivering updated assets. ## Tridion Integration Tridion Integration is available for Enterprise customers. To learn more or enable it for your workspace, please [contact sales](https://ollang.com/contact). Tridion Publication Batch API ## Google Drive → S3 transfers Drive filenames are sanitized before being embedded in S3 keys, and the prior key/URL encoding mismatch on Drive→S3 transfer is resolved. ## Review-gate state for API key clients `GET /v1/api/client/orders/:orderId/review/info` exposes the team-tag review-gate state for an order, including `tagName`, `reviewType`, and `tagColor`. Designed to support browser extensions and downstream review automation. ## Human QC Annotation Editors can now annotate translations during the editing process, assigning a **severity** and **category** to each fix. Annotation reports are exportable from the Order Preview and Studio sections, and the data feeds into the broader QC Management Dashboard alongside AI QC results so teams can track human and AI quality insights in one place. Human QC Annotation 1 ## Tibetan Tibetan is now a supported translation language across the API and dashboard. ## Folder preferences Folder-level workflow overrides are now generally available. Speech-to-text provider resolution is folder-first, falling back to client preferences when no folder rule applies. Folder Level Workflow Overrides 1 Folder Level Workflow Overrides 2 ## Provider config admin endpoints New `GET` and `PATCH /v1/package-features/provider-configs` (and `/:id`, `/export`) endpoints for managing AI provider routing per package feature. CSV export uses standards-compliant double-quote escaping on all string fields. ## Folder-level workflow overrides New REST resource at `/client/folders/:folderId/preferences` (GET / POST / PATCH / DELETE) lets you override workflow defaults per folder. Resolution follows a **4-tier ladder**: exact source+target → source-only → target-only → all-to-all, with folder rules taking precedence over client-level rules when matched. ## Adobe After Effects ZIPs for AI Dubbing `.zip` AE project uploads are now exposed in advanced settings for AI Dubbing, alongside Visual Translation. Adobe After Effects ZI Ps For AI Dubbing ## Embed subtitles into delivered video `POST /integration/orders/{orderId}/subtitle-embedding` requests subtitle embedding for an existing subtitle order. Useful when you want a single delivered video file with burned-in or attached captions. ```bash cURL theme={null} curl -X POST "https://api-integration.ollang.com/integration/orders/{orderId}/subtitle-embedding" \ -H "X-Api-Key: " ``` See the full reference on the [Request Subtitle Embedding](/apis/ollang-api-reference/request-subtitle-embedding) page. ## QC report Excel export Download QC reports as `.xlsx` with full annotation coverage. QC Report Excel Export 1 QC Report Excel Export 2 ## QC score on the project order list Per-order QC score is now visible in the project order list view. QC Score On The Project Order List ## Fullscreen subtitle preview Captions persist when viewing dubbed and subtitled videos in fullscreen. ## TikTok connector TikTok now appears in App Integrations. The companion Chrome extension is in **private release** as **v1.1.3**. ## MCP integrations now documented Reference docs are live for **Airtable**, **Notion**, **Vimeo**, **YouTube**, **Dropbox**, and **Strapi**. See [Ollang MCP](/mcp/integrations). ## Studio edits during review Translators can now edit in Studio while an order is in `review` or `ongoing` status. The cron retrigger correctly skips orders in `review`. ## AI Voices speaker usage indicator Each AI voice in the selection flow now shows how many speakers are assigned to it (e.g. *"Assigned to 5 speakers"*), along with the segment count per speaker. Helps translators distribute voices across a cast and avoid overuse of any single voice. AI Voices Speaker Usage Indicator 1 AI Voices Speaker Usage Indicator 2 ## Configurable Review Gates with AI-QC threshold Each Review Gate now supports a per-gate `qcThreshold` (0–100). Orders are auto-routed for human review only when AI QC falls below the threshold; gates auto-complete on approved comments and are protected against infinite cycles. Single-assignee assignment is now LSP-aware, and `translatorId` / `lspId` are persisted on assignment. ## Workflow review modes via Team Tags Two review modes are now supported per gate: * **Assignment** — auto-assigns the order directly to a Team Tag member (typically a linguist) to fix and deliver.\\ Review Gate State For API Key Clients 1 * **Comment** — routes to the selected Team Tag for review-only; the reviewer leaves comments and saves the order without making fixes.\\ Review Gate State For API Key Clients 2 ## Google Drive folder mappings Pull configurations can target an internal folder; push configurations can scope to a source pull folder. Folder drop downs are searchable with a capped height for large drives. Push delivers the subtitle-burned video, the VTT, and an Excel of comments (when present) back to the configured push folder. Also shipped: per-gate threshold routing in the cron QC dispatcher, async QC kickoff, and visibility status set on gate entry. Google Drive Folder Mappings ## Mobile localization formats Document translation now accepts **Android `.xml` strings**, **iOS `.strings`**, and **iOS `.stringsdict`** (plural-aware). Plurals and string arrays are flattened into key-per-variant translation units, and comments are preserved on rebuild. ## Bulk download for translator and LSP dashboard New endpoint to bulk download source and deliverable assets, with Mux URLs included. ## Adobe After Effects upload reliability `S3Service.uploadAdobeAEFileWithRetry` adds retry-with-backoff for AE file uploads. Conversion request timeout raised to 5 minutes for large project processing. ## New frontier models Claude Opus 4.7, GPT-5.4, and Gemini-3.1 Pro are now selectable as workflow models across translation and review pipelines.\ \\ STT ## Independent Closed Caption and Subtitle workflows Standalone Closed Caption (time-coded transcription) and Subtitle workflows no longer cascade from the AI Dubbing model selection — each can now be configured with its own AI models. Workflows ## QC Score Progression Tracker New analytics widget tracks QC score over time. The Quality dashboard also gains an average human-edit-percentage metric. QC Score Progression Tracker ## BYOK — bring your own LLM keys Clients can now provide their own LLM API keys. New `client-byok` BFF with encrypted CRUD, a workflow key router, and n8n body injection. Plan-gated; check your subscription's BYOK feature flag. BYOK — Bring Your Own LLM Keys ## Ollang SDK (Beta, Open Source) The official Ollang SDK is now available: * npm: [`@ollang-dev/sdk`](https://www.npmjs.com/package/@ollang-dev/sdk) * GitHub: [github.com/ollang/sdk](https://github.com/ollang/sdk) Install with `npm i @ollang-dev/sdk`. ## Tag column on advanced consumption export The advanced credit consumption Excel export now includes a `Tag` column for segmentation. ## TTS `.txt` source upload AI Dubbing's TTS workflow accepts a `.txt` script directly as the source — no video required. The TTS source-file tab is marked as **New**. ## Anomaly detection toggle Anomaly detection can now be enabled or disabled at folder and project levels with cascade behavior. Enable Delivery ## Agentic Turbo model A faster, more cost-efficient option with lower credit usage is now available as an **experimental** soft launch. Treat it as best-suited for testing on videos or documents where you want to evaluate output quality before adopting it for production workloads. ## LSP roles overhaul Added **LSP Admin** and **LSP Project Manager** roles. Inviting an editor now auto-promotes them along the structured AI → Linguist → Admin flow. Project Managers can manage LSP members; finance data is hidden from PM and member roles. Team management enforces edit permissions based on role. ## In-video text translation editing Translators can now edit AI translations on Visual Translation orders. Prompt-based updates produce a new version in 2–5 minutes — designed for human-in-the-loop correction and iteration. VT ## Custom team-member tags New `client-tags` controller with assign / remove / CRUD operations. `clientTagIds` added to `User` and `Freelancer`. Foundation for downstream tag-driven workflow automation. ## TTS direct order linking Post-creation redirect now lands users on the new TTS order with English as default. Duration handling fixed for TTS, and `autoRate` is disabled when in TTS mode. ## Persistent speaker voice assignment Speaker → voice mappings are persisted on `AiDubbingWork` records and survive reruns. ## Image-to-image translation Document Translation now accepts `JPEG`, `JPG`, and `PNG` files and translates images directly. The AI dubbing/subtitle pipeline is unchanged; this lands as a new input type for the Document Translation order. Future iterations will extend the same flow to images embedded inside PDFs and other document formats. ## Source Text Editing in AI Dubbing Edit source text directly in Studio and trigger retranslation. AI actions to **shorten** or **expand** text are also available. `sourceText` is now included in `ParaphrasedResponse` and a retranslate task was added to NLP. Retranslate ## TTS rerun fixes Rerun correctly preserves the last provider for TTS orders, and the AI-only flow handler now applies to all level-0 orders. ## Human Edit Distance on subtitle order details AI-generated subtitle orders now expose a **Human Edit Distance** metric in order details, reflecting edits made by your team or translation partners. Useful for tracking how much human editing each AI-generated subtitle order needed. ## Wolof language support Wolof is now a supported translation language. See the full list on the [Supported Languages](/apis/ollang-api-reference/supported-languages) reference page. ## Text-to-Speech in AI Dubbing Generate dubbed speech without a source video. The AI Dubbing pipeline now supports a TTS-first flow with completion, download, and rerun. Unlocks audio-only workflows and faster content creation. Script ## Studio configurations dropdown New configurations dropdown in Studio with a subtitle preview toggle. ## Google Drive integration (BETA) Pull and push files directly via Google Drive. OAuth-based auth, polling-based sync (5-minute interval in production), shared-drive support, and content-type forwarding to S3 multipart uploads. Subtitle orders push embedded-subtitle video plus a comments xlsx back to Drive. ## HITL document orders generate AI outputs by default Human-in-the-loop document localization orders now produce AI outputs by default. Translators and LSPs can review the AI result and edit, delete, or add content before delivering the final translation. ## Client guidelines surfaced in document upload HITL document projects display client-uploaded guidelines, supporting documents, and references directly in the document upload screen. ## Unified Studio reference panel In the Closed Caption, Subtitle, and AI Dubbing Studios, the **Reference** button now surfaces all supporting documents, client-specific instructions, and related order assets in one place. ## Spend limits and notifications Subscriptions now expose `notificationThresholds`, with owner-only notifications and both soft and hard limit enforcement applied across order creation, rerun, and QC pricing. Negative thresholds are rejected. S Limits ## Studio Comments v2 Threaded comments inside the editing Studio for collaboration between linguists and reviewers. ## `folderId` on uploads API key uploads can now target a folder via `folderId`. A new endpoint lists available folders for the authenticated client. ## Client Configurations: Comment and QC Threshold toggles Clients can now opt into: * **Comment** — team members can leave comments on projects that other members can see. * **QC Threshold** — when an order's QC score falls below the configured threshold, it is automatically routed to an Editor on the team. ## Advanced Cost Breakdown Orders and AI providers are now filterable, searchable, and exportable from a single Advanced Consumption interface. ## Dubbing style in the Studio header AI Dubbing orders now display the dubbing style in the Studio header for quick context. ## Self-register onboarding New onboarding questions module and end-to-end self-serve signup. New clients automatically have an LSP record created on registration. Google sign-in includes an auto-signup fallback. ## Cancel Human Review `POST /integration/orders/{orderId}/cancel-human-review` programmatically cancels an in-progress human review gate, mirroring the existing [Request Human Review](/apis/ollang-api-reference/request-human-review) endpoint. The order is reverted to its AI-only (Level 0) state and human review credits are refunded. See the [Cancel Human Review](/apis/ollang-api-reference/cancel-human-review) reference. ## `callbackUrl` for QC and order completion [Create Order](/apis/ollang-api-reference/create-order) and [Rerun Order](/apis/ollang-api-reference/rerun-order) payloads accept an optional `callbackUrl`. Completion events for document translation, QC, and review pipelines POST to your URL with the order, document, and result payload. IPv6 is blocked at the SSRF guard, and `callbackUrl` is excluded from criteria sent to the AI evaluation service. ## After Effects (`.ZIP`) for end-to-end localization Order creation now accepts **After Effects project files (`.ZIP`)** for localization, rendering, and final delivery. Custom Instructions can drive translation behavior; main composition identification uses the maximum number of elements and the presence of an audio layer as heuristics. ## PNG image translation inside After Effects (experimental) PNG images embedded inside AE projects are now translated as part of the AE flow. Marked **experimental** — transparent image outputs may not always produce optimal results. ## Order type structure update Order creation now distinguishes: * **Visual Translation** and **Audio Descriptions** as separate order types. * **In-Video Text Translation** remains selectable under the **Subtitle** order type. * **Audio Description** is also available under the **AI Dubbing** order type. ## Adobe After Effects input In-text and Visual Translation orders now accept Adobe AE project files as source. S3 multipart streaming, retry-with-backoff, and a callback service for the AE machine are all in place. ## SDLXLIFF translation formatting SDLXLIFF translation formatting now covers more edge cases (segment grouping, inline tag preservation, mid-word tag handling). ## Agentic long-form subtitle translation Long-form subtitle translation through the Agentic pipeline is faster and produces tighter alignment between the source and translated segments. ## Agentic SDH no longer overflows video duration Generated SDH output is now bounded by the video length, preventing trailing captions from extending past the final frame. ## LSP Admin: retrigger CC orders LSP Admins can now retrigger closed-caption orders. Retrigger cadence relaxed from hourly to every three hours. ## Auto QC on `Order` An `autoQC` flag has been added to the `Order` model so clients with `enableQCThreshold` can opt orders into automatic QC scoring. ## Bulk download (preview) Initial scaffolding for the LSP / translator bulk download feature lands; full release on April 22. ## Language-based workflow management Workflows are no longer limited to a single **All Languages → All Languages** rule. You can now configure and switch workflows by **language pair** and **order type** (e.g. AI Dubbing, Document Translation), giving you per-pair AI model and review-gate routing. This is the foundation that the later folder-level overrides build on top of. ## Hidden orders excluded from AI credit consumption CC files uploaded for hidden orders no longer consume AI credits, fixing a billing edge case. ## Order rerun `POST /integration/orders/{orderId}/rerun` re-executes a completed order against the current workflow, useful when source content changes or you've adjusted preferences. See the [Rerun Order](/apis/ollang-api-reference/rerun-order) reference. ```bash cURL theme={null} curl -X POST "https://api-integration.ollang.com/integration/orders/{orderId}/rerun" \ -H "X-Api-Key: " \ -H "Content-Type: application/json" \ -d '{}' ``` ## QC evaluation APIs (experimental) * `POST /integration/orders/{orderId}/qc` — trigger QC evaluation on demand. See [Run QC Evaluation](/apis/ollang-api-reference/run-qc-evaluation). * QC result is now embedded in `GET /integration/orders/{orderId}` responses when available. See [Get Order by ID](/apis/ollang-api-reference/get-order-by-id). ```bash cURL theme={null} curl -X POST "https://api-integration.ollang.com/integration/orders/{orderId}/qc" \ -H "X-Api-Key: " \ -H "Content-Type: application/json" \ -d '{"accuracy": true, "fluency": true, "tone": true, "culturalFit": true}' ``` Both endpoints are marked **experimental**; payload shape may change. ## Granular TTS credit calculation Dubdata is calculated more granularly so TTS credit consumption matches actual generated audio. ## Bulk unassign translator from folder Folder-scoped bulk unassign for clients managing translator pools across folders. ## Source transcript pasting When creating a subtitle translation or AI Dubbing order, you can now paste a **source transcript** (a script without timecodes). The agentic pipeline matches the pasted text against timecoded segments to keep transcription accuracy at 100% before translation and AI Dubbing run on top. ## ESC reverts AI Dubbing segment edits Pressing **ESC** while editing inside an AI Dubbing segment resets the segment back to its original text and Synthesized state. Prevents accidental re-synthesis from inadvertent edits. ## Click anywhere in a segment to jump Clicking anywhere inside a segment now jumps the video to that segment's start time. Previously this only worked when clicking the text area. ## Speed adjustment with box sizing AI Dubbing's editing UI gains box-level speed adjustment, with `needsSpeedAdjust` persisted in dubdata. Original stats are saved for future reference. ## Foreground / background preview, split, trim, reprocess AI Dubbing now lets you preview, split, trim, and reprocess against foreground or background tracks via media-service hooks. ## Bulk assign translator for folder Folder-scoped bulk translator assignment. ## Document translation versioning Previously translated documents are now retained across reruns rather than being cleaned up. Useful when you need to compare or roll back across versions. # API Conventions Source: https://api-docs.ollang.com/concepts/api-conventions Base URL, authentication, request/response format, pagination, errors, and callbacks for the Ollang Integration API. # API Conventions The conventions on this page apply to every endpoint under `https://api-integration.ollang.com`. Read this once and the individual API reference pages should feel predictable. ## Base URL ``` https://api-integration.ollang.com ``` All endpoints are HTTPS-only. There is no separate sandbox host — use test data and the AI-only `level: 0` flow against the same base URL to experiment safely. ## Authentication The REST API authenticates with a single header: | Header | Value | | - | - | | `X-Api-Key` | Your API key from the [Olabs Dashboard](https://lab.ollang.com) | ```bash theme={null} curl https://api-integration.ollang.com/integration/orders \ -H "X-Api-Key: " ``` * The `/health` endpoint does **not** require a key — it's the recommended connectivity sanity check. See [Health Check](/apis/ollang-api-reference/health-check). * Header name is case-sensitive on some HTTP clients. Use `X-Api-Key`, not `Authorization` or `X-API-KEY`. * API keys are account-scoped and can read every Folder, Project, and Order on that account. ## Content Types | Operation | Content type | | - | - | | File uploads | `multipart/form-data` | | Everything else (JSON in / JSON out) | `application/json` | ## Request and Response Format JSON responses generally fall into three shapes: **Single resource:** ```json theme={null} { "id": "", "status": "completed", "...": "..." } ``` **List endpoints (paginated):** ```json theme={null} { "data": [ { "id": "", "...": "..." } ], "meta": { "page": 1, "take": 10, "itemCount": 153, "pageCount": 16, "hasPreviousPage": false, "hasNextPage": true } } ``` * `page` is 1-indexed. * `take` is the page size that was applied. * `itemCount` is the total number of items across all pages. * `pageCount` is the total number of pages. * Iterate until `hasNextPage` is `false`. **Order creation:** an **array** of objects, one per `targetLanguageConfigs` entry: ```json theme={null} [ { "orderId": "" }, { "orderId": "" } ] ``` See [Create Order](/apis/ollang-api-reference/create-order). ## Pagination List endpoints accept a common set of pagination parameters. Two query-string styles are used depending on the endpoint: | Parameter | Type | Description | | - | - | - | | `page` | integer | 1-indexed page number. Defaults to `1`. | | `take` | integer | Page size. Defaults to `10`, max `50`. | | `search` | string | Free-text search across name/description. | | `orderBy` | string | Sort field (e.g. `createdAt`, `name`). | | `orderDirection` | string | `asc` or `desc`. Defaults to `desc`. | * **Flat style** (`page=`, `take=`, ...) is used on [Retrieve All Folders](/apis/ollang-api-reference/retrieve-all-folders) and [Retrieve All Projects](/apis/ollang-api-reference/retrieve-all-projects). * **Nested `pageOptions[...]` style** is used on [Get Orders](/apis/ollang-api-reference/get-orders) (e.g. `pageOptions[page]=1`, `pageOptions[take]=20`). The canonical example for each endpoint is in its API reference page. ```bash theme={null} # Flat style (folders, projects) curl "https://api-integration.ollang.com/integration/folder?page=1&take=20&orderBy=createdAt&orderDirection=desc" \ -H "X-Api-Key: " # pageOptions style (orders) curl "https://api-integration.ollang.com/integration/orders?\ pageOptions[page]=1&\ pageOptions[take]=20&\ pageOptions[orderBy]=createdAt&\ pageOptions[orderDirection]=desc" \ -H "X-Api-Key: " ``` **Iteration pattern:** ```typescript theme={null} let page = 1; while (true) { const res = await fetch( `https://api-integration.ollang.com/integration/orders?pageOptions[page]=${page}&pageOptions[take]=50`, { headers: { "X-Api-Key": process.env.OLLANG_API_KEY! } } ).then(r => r.json()); for (const order of res.data) handle(order); if (!res.meta.hasNextPage) break; page += 1; } ``` ## Filters List endpoints also accept domain-specific `filter` parameters. Common filters across endpoints: | Parameter | Type | Description | | - | - | - | | `filter[type]` | string | Restrict by `orderType` (`cc`, `subtitle`, `document`, `aiDubbing`, `studioDubbing`). | | `filter[name]` | string | Substring match on entity name. | | `filter[createdAtRange]` | object | `{ "from": "ISO-8601", "to": "ISO-8601" }`. | See per-endpoint reference pages for the full filter list. ## Error Format All error responses share this shape: ```json theme={null} { "error": "Invalid file format", "message": "Only VTT files are supported", "code": "INVALID_FILE_FORMAT" } ``` | Field | Description | | - | - | | `error` | Short, human-readable summary. | | `message` | Detailed explanation suitable for surfacing to the end user. | | `code` | Stable machine-readable identifier safe to switch on in client code. | ### Standard Status Codes | Status | Meaning | Retryable? | | - | - | - | | `200 OK` / `201 Created` | Success | — | | `400 Bad Request` | Invalid parameters | No — fix the request | | `401 Unauthorized` | Missing or invalid API key | No — check `X-Api-Key` | | `403 Forbidden` | Authenticated but not permitted | No | | `404 Not Found` | Resource doesn't exist or isn't visible to your key | No | | `408 Request Timeout` | Slow request | Yes, with backoff | | `413 Payload Too Large` | File exceeds size limit | No — split or use Direct Upload | | `429 Too Many Requests` | Rate-limited | Yes, with backoff — slow down | | `5xx` | Server-side error | Yes, with backoff | See [Best Practices — Retries and Backoff](/concepts/best-practices#retries-and-backoff). ## Webhooks / Callbacks Endpoints that kick off long-running work (`createOrder`, `rerunOrder`) accept an optional `callbackUrl`. Ollang `POST`s a JSON payload to that URL when the order completes: ```json theme={null} { "orderId": "", "status": "completed", "orderType": "subtitle", "targetLanguage": "fr", "completedAt": "2026-05-12T10:00:00Z", "orderDocs": [ { "type": "created_subtitle", "name": "fr.srt", "url": "https://example.com/..." } ], "vttUrl": "https://example.com/.vtt" } ``` **Rules:** * 10-second response timeout. * IPv6 destinations and internal hostnames are blocked at the SSRF guard. * Treat handlers as **idempotent**. Use `orderId` as the dedup key. * Re-confirm via [Get Order by ID](/apis/ollang-api-reference/get-order-by-id) before acting on the body for irreversible operations. See [Best Practices — Callbacks vs. Polling](/concepts/best-practices#callbacks-vs-polling). ## IDs * All Ollang IDs are opaque strings — do not assume any particular format (length, prefix, or characters). Treat them as case-sensitive identifiers. * IDs are stable for the lifetime of the resource. * Each `targetLanguageConfigs` entry produces a distinct `orderId`. ## Timestamps All timestamps are ISO-8601 UTC unless otherwise noted (e.g. `2026-05-12T10:00:00Z`). Where a numeric epoch is returned (`/health`'s `time`), it is milliseconds since the Unix epoch. ## Language Codes Mostly ISO 639-1 two-letter codes (`en`, `fr`, `es`), with regional and script variants where needed (`pt-PT`, `es-MX`, `zh-Hant`, `fr-CA`). See [Supported Languages](/apis/ollang-api-reference/supported-languages) for the canonical, verified list — the API response is authoritative if a code isn't listed there. Language fields are validated as free-form strings rather than a fixed enum, so any well-formed BCP-47 tag is also accepted as input beyond that list, falling back to the closest supported match when a regional variant isn't directly recognized; see [BCP-47 support](/apis/ollang-api-reference/supported-languages#bcp-47-support) for how that resolves. ## File Size Limits | Resource | Limit | | - | - | | Video uploads (Direct Upload) | 30 GB | | Audio / Document uploads | 100 MB | | In-page API playground | 5 MB | | Embedded callback payload | \< 1 MB (URLs reference downloads) | For very large videos, always use [Direct File Upload](/apis/ollang-api-reference/direct-file-upload) rather than web/dashboard upload paths. ## Rate Limits Ollang enforces per-account rate limits. If you receive `429`, back off exponentially. For high-volume use cases, contact Ollang to discuss limits before launch. ## Service Status Live availability, open incidents, and scheduled maintenance for the Ollang platform and its APIs are published at **[status.ollang.com](https://status.ollang.com)**. Check it first when requests start failing across the board — an incident there explains more than a retry loop will. The unauthenticated [Health Check](/apis/ollang-api-reference/health-check) endpoint answers a narrower question — whether `api-integration.ollang.com` is reachable and healthy from *your* network. Use `/health` for readiness probes and connectivity checks, and the Status page for platform-wide incidents. ## Security and Trust Ollang's security, privacy, and compliance documentation lives at the **[Trust Center](https://trust.ollang.com)** — start there for vendor security reviews and questionnaires. For day-to-day integration hygiene (key rotation, handling signed `orderDocs[].url` links), see [Best Practices — Security](/concepts/best-practices#security). ## Versioning The Integration API is non-versioned at the URL level. We commit to: * **Additive changes** (new optional fields, new endpoints) ship without notice. * **Breaking changes** (parameter removal, response shape changes) are announced in the [Changelog](/changelog) in advance. ## See Also * [Best Practices](/concepts/best-practices) * [Troubleshooting](/troubleshooting) * [Getting Started](/getting-started) * [How It All Connects](/concepts/how-it-all-connects) * [Service Status](https://status.ollang.com) — live availability and incidents * [Trust Center](https://trust.ollang.com) — security, privacy, and compliance # Best Practices Source: https://api-docs.ollang.com/concepts/best-practices Production-grade guidance for using the Ollang platform — API keys, callbacks, retries, pagination, error handling, folder structure, memory, and review gates. # Best Practices Recommended patterns for shipping reliable, secure, and consistent localization workflows on Ollang. ## API Key Hygiene * **Store keys in environment variables or a secrets manager.** Never commit `` values to source control or paste them in shared chats. * **Use a separate key per environment.** Development, staging, and production should each have their own API key. Rotate when team members leave or a key is suspected leaked. * **Pass keys via `X-Api-Key`,** not in the URL or request body. The header name is case-sensitive on some HTTP clients. * **Scope by Folder, not by key.** Folders are how you isolate workflows and content (legal vs. marketing vs. internal training). All keys on an account can see all folders. ```bash theme={null} # Recommended export OLLANG_API_KEY="" curl -H "X-Api-Key: $OLLANG_API_KEY" https://api-integration.ollang.com/health ``` ## Folder Structure Folders are the primary organizational unit. Use them to group projects that share a workflow. **Recommended folder layout for an enterprise account:** ```text theme={null} Marketing — Campaigns (folder workflow: aiDubbing overdub, Level 0) Marketing — Brand Videos (folder workflow: aiDubbing overdub, Level 1) Product — Training Videos (folder workflow: subtitle, Level 1) Product — Help Center (folder workflow: document, Level 1) Legal — Contracts (folder workflow: document, Level 1, formal tone) Accessibility — Audio Description (folder workflow: aiDubbing audioDescription) API Uploads (default — for ad-hoc / dev usage) ``` **Benefits:** * Folder-level workflows override Global workflows, so each team gets its preferred provider/review-gate setup without touching account defaults. * Folder-level Custom Instructions / Guidelines apply automatically to every order created in that folder. * Folder-level Memory keeps terminology consistent across multiple campaigns or product lines. See [Workflows and Provider Architecture](/workflows-provider-architecture) and [Memory, Guidelines, and Custom Instructions](/memory-guidelines-custom-instructions). ## Callbacks vs. Polling Always prefer **callbacks** for production workflows. Fall back to polling for short-lived scripts or as a safety net. ### Callback handler checklist * **Idempotent.** Use `orderId` (and optionally `completedAt`) as the deduplication key. The same callback may fire more than once on retry. * **Fast acknowledgment.** Return `2xx` within **10 seconds**. Process asynchronously (queue, background job) if your handler does any real work. * **Confirm before acting.** Don't trust callback bodies alone. Pair with `GET /integration/orders/` using your API key before performing irreversible actions (publishing content, billing customers). * **Public URLs only.** Callback URLs must be reachable from the public internet. Internal hostnames and IPv6 destinations are blocked at the SSRF guard. ```typescript theme={null} // Example: Express handler app.post("/webhooks/ollang", async (req, res) => { // 1. Ack immediately res.sendStatus(200); // 2. Process asynchronously await queue.add("ollang-order-completed", { orderId: req.body.orderId, completedAt: req.body.completedAt, }); }); // Worker async function handle(payload) { // 3. Re-fetch to verify const order = await ollang.orders.getById(payload.orderId); if (order.status !== "completed") return; // ignore false positives // 4. Use a transactional upsert keyed on orderId await db.deliveries.upsert({ where: { orderId: order.orderId }, create: { ... }, update: { status: order.status }, }); } ``` ### Polling pattern ```bash theme={null} while true; do STATUS=$(curl -s "https://api-integration.ollang.com/integration/orders/" \ -H "X-Api-Key: " | jq -r '.status') case "$STATUS" in completed|revision) break ;; *) sleep 30 ;; esac done ``` Recommended cadence: every 30–60 seconds. AI-only orders typically complete within minutes; Level 1 orders depend on reviewer availability. ## Retries and Backoff The Integration API is generally available 99.9%. Network blips happen. * Retry on `408`, `429`, `500`, `502`, `503`, `504`. * Use **exponential backoff with jitter** (e.g. 500ms → 1s → 2s → 4s → 8s, cap \~30s). * Treat `429` (rate limit) seriously — slow your overall request rate, don't just retry harder. * **Do not retry** `400`, `401`, `403`, `404` without changing the request — they indicate a client-side bug, not a transient failure. * File uploads can have multi-minute response times. Set HTTP client read/write timeouts to **5–10 minutes** for upload requests. * If retries keep failing across every endpoint, check [status.ollang.com](https://status.ollang.com) before escalating — an open incident or maintenance window is reported there first. ## Choosing `level: 0` vs `level: 1` | Use `level: 0` (AI only) when… | Use `level: 1` (Human Review) when… | | - | - | | Internal previews, QA, sample reviews | External / paid distribution | | Volume is high and SLAs are tight | Brand-sensitive or legal content | | You're iterating on prompts, guidelines, or Memory | First time localizing into a new language | | Multiple subsequent reruns expected | Accessibility / compliance deliverables | You can always **escalate** a Level 0 order to Level 1 after it completes via [Request Human Review](/apis/ollang-api-reference/request-human-review), and **revert** with [Cancel Human Review](/apis/ollang-api-reference/cancel-human-review). This lets you ship quickly and only pay for review on the languages or files that need it. ## Memory and Custom Instructions Memory and Custom Instructions are the strongest levers you have for quality and consistency: * **Memory** — approved translations for recurring terms (product names, trademarks, legal jargon). Reuse across projects. * **Custom Instructions** — natural-language guidance to the AI ("Always use formal register in French," "Translate 'cookie' as 'cookie' in cybersecurity contexts, not as the food"). * **Folder Guidelines** override account-wide Custom Instructions for specific workflows. **When introducing Ollang into a new language:** 1. Run a small Level 1 pilot batch. 2. Capture linguist edits into Memory. 3. Run subsequent Level 0 orders with the populated Memory — quality tends to converge quickly. See [Memory, Guidelines, and Custom Instructions](/memory-guidelines-custom-instructions). ## QC and Review Gates * Enable **`autoQc: true`** on order creation to score every order immediately on completion. See [Run QC Evaluation](/apis/ollang-api-reference/run-qc-evaluation). * Configure **Review Gates** in your Folder workflow to auto-route low-scoring orders to human review (Assignment mode) or to a review tag (Comment mode). See [Workflows and Provider Architecture](/workflows-provider-architecture) and the [Review Gate](/glossary#review-gate) entry in the glossary. * Track QC progression in the Analytics dashboard — declining scores are usually a sign of a content/domain shift that needs Memory or Custom Instructions updates. See [Analytics and QC Monitoring](/analytics-qc-monitoring). ## Bulk and Concurrent Operations * **Each `targetLanguageConfigs` entry creates one order.** Issue them in a single `createOrder` request rather than looping, so you get consistent timestamps and a single response array. * **Parallelize uploads** moderately (start at 3–5 concurrent). Watch for `429` and back off. * **Reuse projects** across orders. One source video can drive multiple `cc` + `subtitle` + `aiDubbing` orders without re-uploading. ## Error Handling The REST API returns standard HTTP status codes with a JSON body: ```json theme={null} { "error": "Invalid file format", "message": "Only VTT files are supported", "code": "INVALID_FILE_FORMAT" } ``` **Recommended client logic:** * `2xx` → success * `4xx` → log and surface to the user; do not retry without changing the request * `429` → backoff and retry * `5xx` → backoff and retry (up to N times) Capture the response `code` and the original request when escalating to support — see [Troubleshooting](/troubleshooting#what-to-send-support). ## Pagination List endpoints use one of two query-string styles depending on the endpoint: ``` # Flat (folders, projects) ?page=1&take=20&search=sample&orderBy=createdAt&orderDirection=desc # Nested pageOptions[...] (orders) ?pageOptions[page]=1 &pageOptions[take]=20 &pageOptions[search]=sample &pageOptions[orderBy]=createdAt &pageOptions[orderDirection]=desc ``` * `take` is the page size (default `10`, max `50`); the API returns a `meta` object with `page`, `take`, `itemCount`, `pageCount`, `hasPreviousPage`, and `hasNextPage`. * Iterate until `hasNextPage` is `false`. * Combine with `filter[name]`, `filter[type]`, or `filter[createdAtRange]` for more targeted queries. See [API Conventions — Pagination](/concepts/api-conventions#pagination), [Get Orders](/apis/ollang-api-reference/get-orders), and [Retrieve All Projects](/apis/ollang-api-reference/retrieve-all-projects) for the canonical examples. ## Security * Never log API keys, callback bodies containing tokens, or signed URLs. * Treat `vttUrl` and `orderDocs[].url` as **short-lived, sensitive URLs**. Re-fetch via [Get Order by ID](/apis/ollang-api-reference/get-order-by-id) before downloading rather than persisting them indefinitely. * Restrict who has access to your API keys to the smallest team possible. * If you suspect a key leak, **rotate immediately** in the [Olabs Dashboard](https://lab.ollang.com) and update all consumers. * Ollang's security, privacy, and compliance documentation — the material a vendor security review will ask for — is published at the [Trust Center](https://trust.ollang.com). ## Versioning and Deprecations The Integration API is currently stable and non-versioned at the URL level. Breaking changes (parameter removals, response shape changes) are announced in the [Changelog](/changelog) ahead of rollout. Additive changes (new optional fields, new endpoints) ship without notice. ## When to Reach for Each Surface A quick mental model: * **REST API** — anything programmatic. Default choice. * **SDK** — Node.js / TypeScript projects, plus when you want the Asset Management UI for i18n strings or CMS capture. * **MCP** — non-developer team members operating Ollang through an AI assistant; ad-hoc / exploratory work; automated agents. * **Skills** — coding agents (Cursor, Claude Code, Codex, Windsurf, Cline) when you want zero infra — just a file-based skill bundle. See [How It All Connects](/concepts/how-it-all-connects) for the full comparison. ## See Also * [Use Cases](/concepts/use-cases) — end-to-end workflow walkthroughs. * [API Conventions](/concepts/api-conventions) — pagination, errors, auth in one reference page. * [Troubleshooting](/troubleshooting) — diagnostics for common issues. * [Service Status](https://status.ollang.com) — live availability, incidents, and maintenance windows. * [Trust Center](https://trust.ollang.com) — security, privacy, and compliance documentation. # How It All Connects Source: https://api-docs.ollang.com/concepts/how-it-all-connects How Ollang APIs, the MCP server, the SDK, Skills, and platform workflows fit together — and when to use each. # How It All Connects Ollang exposes the same underlying platform through four integration surfaces. They are complementary, not exclusive — most teams use two or three of them together. ``` ┌──────────────────────┐ │ Olabs Dashboard │ ← humans: create orders, configure workflows, review │ (lab.ollang.com) │ └──────────────────────┘ │ ▼ ┌──────────────────────────────────────────────────────────────┐ │ Ollang Integration API (api-integration.ollang.com)│ │ REST endpoints for uploads, orders, projects, QC, revisions, │ │ human review, custom instructions, folders, callbacks. │ └──────────────────────────────────────────────────────────────┘ ▲ ▲ ▲ ▲ │ │ │ │ │ │ │ │ ┌──────┴─────┐ ┌───────┴──────┐ ┌───────┴──────┐ ┌──────┴──────┐ │ Your code │ │ Ollang MCP │ │ Ollang SDK │ │ Ollang │ │ (curl, │ │ (Cloudflare, │ │ (npm, │ │ Skills │ │ HTTP libs)│ │ OAuth 2) │ │ TypeScript) │ │ (file-based)│ └────────────┘ └────────────────┘ └───────────────┘ └─────────────┘ ``` ## The Four Integration Surfaces Programmatic access. Works in any language with an HTTP client. API-key authenticated. Hosted Model Context Protocol endpoint. Plug into Claude Desktop, Cursor, Claude Code, Devin, Replit, Windsurf, and other MCP clients. OAuth 2.0 + PKCE. TypeScript/Node.js library (`@ollang-dev/sdk`) for asset scanning, i18n workflows, CMS capture, and a typed REST client. File-based [Agent Skills](https://skills.sh) bundle that teaches your AI coding agent how to call Ollang. No proxy server, no MCP needed. ## When to Use Which | Scenario | Best fit | | - | - | | Build a translation pipeline from a backend or CI job | **REST API** (any language) or **SDK** (if Node.js) | | Let translators / PMs trigger work from their AI assistant (Claude, Cursor, Devin) without writing code | **MCP** | | Localize an internal Next.js / React / Vue app's i18n files | **SDK** Asset Management | | Localize CMS content (Strapi, custom) captured live in the browser | **SDK** Browser SDK | | Add translation to an existing AI coding workflow without running a server | **Skills** | | Trigger orders from no-code/low-code tools (Airtable, Notion) | **MCP** with the matching [integration](/mcp/integrations/airtable) | | Run Ollang as part of a workflow editor / agent runtime | **MCP** (preferred) or **REST API** if you can't run MCP | ## Authentication at a Glance | Surface | Auth | | - | - | | REST API | API key in `X-Api-Key` header. Generate one in the [Olabs Dashboard](https://lab.ollang.com). | | MCP Server | OAuth 2.0 + PKCE. Sign in with email OTP, Google, or GitHub the first time you connect. | | SDK | API key (via `OLLANG_API_KEY` env var or constructor argument). | | Skills | API key. The agent reads `OLLANG_API_KEY` from your environment or asks you to provide one in chat. | All MCP traffic still flows through the same Integration API behind the scenes — MCP is a protocol layer that translates conversational tool calls into Ollang REST calls. ## A Concrete End-to-End Example A typical localization flow — phrased four ways: ```bash theme={null} # 1. Upload curl -X POST "https://api-integration.ollang.com/integration/upload/direct" \ -H "X-Api-Key: " \ -F "file=@sample.mp4" \ -F "name=sample" \ -F "sourceLanguage=en" # → { "projectId": "" } # 2. Create subtitle order for French + Spanish curl -X POST "https://api-integration.ollang.com/integration/orders/create" \ -H "X-Api-Key: " \ -H "Content-Type: application/json" \ -d '{ "orderType": "subtitle", "level": 0, "projectId": "", "targetLanguageConfigs": [{"language":"fr"},{"language":"es"}], "autoQc": true }' # → [{ "orderId": "" }, { "orderId": "" }] ``` ```typescript theme={null} import { readFile } from "node:fs/promises"; import { Ollang } from "@ollang-dev/sdk"; const ollang = new Ollang({ apiKey: process.env.OLLANG_API_KEY, }); const { projectId } = await ollang.uploads.direct({ file: new Blob([await readFile("./sample.mp4")]), filename: "sample.mp4", name: "sample", sourceLanguage: "en", }); const orders = await ollang.orders.create({ projectId, orderType: "subtitle", level: 0, targetLanguageConfigs: [{ language: "fr" }, { language: "es" }], autoQc: true, }); ``` ``` Upload https://example.com/sample.mp4 to Ollang as English, then create a subtitle order for French and Spanish with auto QC enabled. Report the order IDs. ``` The AI assistant calls `uploadFile` → `createOrder` on your behalf and prints the resulting `orderId`s. Large files such as videos upload from a URL; smaller local files (e.g., PDF or DOCX documents) can be passed directly as base64-encoded content. In all four cases: 1. The same upload endpoint runs (`POST /integration/upload/direct`). 2. The same order endpoint runs (`POST /integration/orders/create`). 3. The same project / order records are created in your Ollang account. 4. The same callback fires (if you set one). ## Workflows Apply Equally Everywhere The **workflow** layer (which AI providers run, which review gates apply, which custom instructions are used) is configured in the [Olabs Dashboard](https://lab.ollang.com) at the Global or Folder level. It applies the same way no matter which surface created the order. See [Workflows and Provider Architecture](/workflows-provider-architecture). This means: * A developer creating an order via the REST API gets the same provider routing and review-gate behavior as a PM creating one in the dashboard, or an AI agent creating one via MCP. * Changing a folder workflow affects all future orders into that folder, regardless of where they originate. ## Picking a Path — Quick Recommendations * **Just exploring?** Run through [Getting Started](/getting-started) with `curl`. * **Shipping production code?** Use the [REST API](/apis/ollang-api-reference/direct-file-upload) or, on Node.js, the [SDK](/sdk/overview). * **AI-driven team workflows?** Connect [MCP](/mcp/overview) once and any compatible client can use Ollang. * **AI-driven developer workflows in your editor?** [Skills](/skills/overview) — one command, no server. # Rerunning Connected Order Chains Source: https://api-docs.ollang.com/concepts/rerunning-connected-order-chains How full-chain order reruns work, when to use triggerFullChain, and how connected stages are reprocessed and billed. # Rerunning Connected Order Chains This guide explains how full-chain reruns work and when to use `triggerFullChain` on the [Rerun Order](/apis/ollang-api-reference/rerun-order) endpoint. ## One order vs. the whole chain Some Ollang order types depend on the output of other orders. These dependencies form a **chain**: * A **child** (or **dependent**) order produces the input another order needs. * A **parent** order consumes the output of its child. Examples of connected chains: | Requested order | Chain (dependency order) | | - | - | | Audio Description | Text for AD → Audio Description | | AI Dubbing | Closed Captioning → Subtitle → AI Dubbing | | Subtitle | Closed Captioning → Subtitle | A **standard rerun** (`triggerFullChain: false`, the default) reprocesses only the selected order, reusing the existing results of its dependencies. Use this when only the selected stage needs to be regenerated. A **full-chain rerun** (`triggerFullChain: true`) resets the complete connected chain and reprocesses every stage in dependency order: the deepest dependency runs first, and the requested order is regenerated last using the freshly produced outputs. Use this when the improvement needs to flow through the whole pipeline — for example, a better Text for AD transcription that should feed a new Audio Description. ## How processing order is determined The API walks the requested order's dependency links downward to its earliest required child, resets every order in the chain, and re-triggers the pipeline from the bottom up: * **Audio Description** rerun → regenerates Text for AD first, then produces the new Audio Description from the new text. * **AI Dubbing** rerun → regenerates Closed Captioning, then the Subtitle, then the dub. * **Subtitle** rerun → regenerates Closed Captioning first, then the Subtitle. * A standalone order with no dependencies simply reruns itself. Only the requested order's own chain is affected — orders from other language pairs or unrelated orders in the same project are never touched, and no order above the requested one (its parents) is rerun. If a parent stage also needs regeneration, rerun the parent order itself with `triggerFullChain: true`. ## What happens to existing results All AI-generated outputs of every order in the chain are discarded and regenerated. Source materials are preserved. Review gates configured on the workflow are honored again during the rerun. ## Monitoring The response's `triggeredOrderIds` lists every order that was triggered, from the requested order down to its deepest dependency. Poll [Get Order](/apis/ollang-api-reference/get-order-by-id) for each returned ID to track progress. The requested order completes last. ## Credit consumption A full-chain rerun re-triggers processing for every order type in the chain, and each re-triggered order is billed like an individual rerun. For an AI Dubbing chain that means charges for Closed Captioning + Subtitle + AI Dubbing. Existing account-level rerun exemptions still apply per order — free-rerun clients and daily free-rerun quotas are honored exactly as they are for single-order reruns. If the chain's total cost exceeds your available balance or monthly spend limit, the request fails before anything is reset or charged. ## Limitations and error conditions * The requested order must be a completed (or stalled) Level 0 order of a supported type — the same eligibility rules as a standard rerun. * Full-chain reruns are supported for video pipelines (CC, Subtitle, AI Dubbing, Audio Description) and document orders. Other order types return a validation error: `Full-chain rerun is not supported for order type: ...`. * If any stage of the chain is currently being processed, the request is rejected with `Order chain is already being processed` — wait for the chain to finish first. * If a connected dependency is missing (e.g. a Subtitle order with no CC order), the request is rejected with `Connected dependency chain is incomplete`. * All validation happens before any order is touched: a rejected request never leaves the chain partially reset and never produces a partial charge. ## Recommendation Use `triggerFullChain: false` (or omit the field) when only the selected stage needs to be regenerated. Reserve `triggerFullChain: true` for cases where the upstream stages must also be reprocessed — it consumes more credits and takes longer to complete. # Use Cases Source: https://api-docs.ollang.com/concepts/use-cases End-to-end localization workflows on Ollang — AI dubbing, subtitle translation, document localization, visual translation, human review, and continuous localization. # Use Cases End-to-end walkthroughs of common Ollang localization workflows. Each section shows the recommended integration surface (REST, MCP, SDK, or Skills), the order types involved, and where human review or QC fits. All examples use generic placeholders — replace ``, ``, and `` with values from your account. ## At a Glance | Use case | Order types | Integration surface | | - | - | - | | Marketing video, multi-language AI dubbing | `aiDubbing` | REST API, MCP, Skills | | Enterprise subtitle pipeline with human review | `cc` → `subtitle` (Level 1) | REST API, MCP | | Document localization (legal, marketing, technical) | `document` | REST API, MCP, Skills | | Visual / image-to-image translation | `document` (JPEG/PNG via Direct Upload) | REST API, MCP | | Studio dubbing coordination | `studioDubbing` | REST API + Dashboard | | Accessibility / Audio Description | `aiDubbing` with `dubbingStyle: audioDescription` | REST API, MCP | | Continuous localization for an app's i18n strings | `document` on extracted strings | SDK Asset Management | | Website / CMS content localization | `document` per resource | SDK Browser SDK + MCP | *** ## 1. Marketing Video — Multi-Language AI Dubbing **Goal:** Take a 60–120 second product or marketing video in English and deliver dubbed audio plus a mixed video master in 5–10 target languages, overnight, with no studio booking. **Recommended surface:** REST API or MCP. **Workflow:** ```text theme={null} Upload MP4 (Direct Upload) ↓ Create one aiDubbing order per target language ↓ (Optional) Auto QC after generation ↓ Download mixed video + dubbing audio per language ↓ (Optional) Upgrade specific languages to Level 1 ``` **REST example:** ```bash theme={null} # 1. Upload source video curl -X POST "https://api-integration.ollang.com/integration/upload/direct" \ -H "X-Api-Key: " \ -F "file=@./launch_video.mp4" \ -F "name=launch_video" \ -F "sourceLanguage=en" # → { "projectId": "" } # 2. Create AI Dubbing orders for FR, DE, JA, ES curl -X POST "https://api-integration.ollang.com/integration/orders/create" \ -H "X-Api-Key: " \ -H "Content-Type: application/json" \ -d '{ "orderType": "aiDubbing", "level": 0, "dubbingStyle": "overdub", "projectId": "", "targetLanguageConfigs": [ { "language": "fr" }, { "language": "de" }, { "language": "ja" }, { "language": "es" } ], "callbackUrl": "https://example.com/webhooks/ollang", "autoQc": true }' # → [ {orderId}, {orderId}, {orderId}, {orderId} ] ``` **What gets delivered:** A mixed master video, dubbing audio, vocals-only track, and a Created M\&E file per language. See [Order Types and Workflow Architecture](/order-types-workflows#ai-dubbing-deliverables). **When to upgrade to Level 1:** Use AI-only (Level 0) for previews and internal review. Promote the languages destined for paid distribution to Level 1 via [Request Human Review](/apis/ollang-api-reference/request-human-review). *** ## 2. Enterprise Subtitle Pipeline with Human Review **Goal:** A localization team ships dozens of training or product videos per week. Each video needs accurate, brand-consistent subtitles in 4–8 languages, reviewed by a linguist before release. **Recommended surface:** REST API, with workflow rules configured in the [Olabs Dashboard](https://lab.ollang.com). **Workflow:** ```text theme={null} Upload source video into a Folder ↓ Create cc (Closed Captions) order if no source subtitle exists ↓ Create subtitle orders at Level 1 (Human Review) ↓ Linguists edit inside the Editor Interface ↓ Deliver → export SRT / VTT / DOCX (and more) ↓ Folder-scoped Memory + Custom Instructions improve future orders ``` **Why a Folder?** Configure folder-level **Workflows** (which providers to use), **Custom Instructions** (tone, terminology), and **Review Gates** (which orders are auto-routed to linguists). Folder workflows override Global workflows — see [Workflows and Provider Architecture](/workflows-provider-architecture). **Tips:** * Attach a glossary as a supporting asset on the project — the linguist will see it in the Editor Interface. See [Source Files and Asset Handling](/source-files-assets#glossaries-and-terminology-references). * Enable `autoQc` on the create order request so each order has a QC score before review starts. See [Run QC Evaluation](/apis/ollang-api-reference/run-qc-evaluation). * Reuse the same project for multiple subtitle and dubbing orders to share supporting assets across deliverables. *** ## 3. Document Localization (Legal, Marketing, Technical) **Goal:** Localize contracts, marketing collateral, or product documentation into multiple languages. Preserve formatting, keep terminology consistent, and roll back to a previous version if needed. **Recommended surface:** REST API, MCP (for ad-hoc), or SDK (for repeated batches). **Supported formats:** DOCX, PDF, PPTX, XLSX, HTML, JSON, XLIFF, SDLXLIFF, PO, TXT, SRT, VTT, Pages, Keynote, Numbers. See [Source Files and Asset Handling](/source-files-assets#supported-document-upload-formats). **REST example:** ```bash theme={null} # 1. Upload DOCX curl -X POST "https://api-integration.ollang.com/integration/upload/direct" \ -H "X-Api-Key: " \ -F "file=@./contract.docx" \ -F "name=contract" \ -F "sourceLanguage=en" \ -F "folderId=" # 2. Create document translation orders for ES, DE curl -X POST "https://api-integration.ollang.com/integration/orders/create" \ -H "X-Api-Key: " \ -H "Content-Type: application/json" \ -d '{ "orderType": "document", "level": 1, "projectId": "", "targetLanguageConfigs": [ { "language": "es" }, { "language": "de" } ] }' ``` **Tips:** * Attach **Folder-level Guidelines** (tone, formal/informal register, preserved terms) so every document under that folder picks them up automatically. See [Memory, Guidelines, and Custom Instructions](/memory-guidelines-custom-instructions). * Use **Memory** to enforce approved translations of recurring product names, legal terms, or trademarks. * Reruns retain previous versions — useful for contract amendments. See [Rerun Order](/apis/ollang-api-reference/rerun-order). *** ## 4. Visual Translation (Image-to-Image) **Goal:** Localize on-screen text inside banners, screenshots, presentation slides, or product visuals while preserving the original layout and design. **Recommended surface:** REST API or MCP. **Important:** Visual Translation runs through the `document` order type when the source is a JPEG, JPG, or PNG uploaded via Direct File Upload. There is no separate `visualTranslation` `orderType` enum. **Workflow:** ```bash theme={null} # 1. Upload image (JPEG/JPG/PNG) curl -X POST "https://api-integration.ollang.com/integration/upload/direct" \ -H "X-Api-Key: " \ -F "file=@./banner.png" \ -F "name=summer_sale_banner" \ -F "sourceLanguage=en" # 2. Create document order for FR, IT curl -X POST "https://api-integration.ollang.com/integration/orders/create" \ -H "X-Api-Key: " \ -H "Content-Type: application/json" \ -d '{ "orderType": "document", "level": 0, "projectId": "", "targetLanguageConfigs": [{ "language": "fr" }, { "language": "it" }] }' ``` **Other Visual Translation inputs:** Adobe After Effects project files and video-embedded visual text. See [Visual Translation](/order-types-workflows#visual-translation) in the user guides for the full input matrix. *** ## 5. Studio Dubbing Coordination **Goal:** Coordinate a multi-language dubbing campaign with external studios — Ollang manages the workflow, studios deliver vocals and final mixes. **Recommended surface:** Dashboard for setup + REST API for automation. **Workflow:** ```text theme={null} Upload video + dubbing script ↓ Create studioDubbing orders per language ↓ Studios receive assignment, record dubbed vocals ↓ Studios upload vocals / final mix / Mixmaster ↓ Ollang generates final delivery ↓ Download mixed masters ``` **Notes:** * Studios upload either complete final mixes **or** sufficient audio structure for Ollang to generate the Mixmaster — vocals-only uploads alone are not enough. See [Important Studio Dubbing Rule](/order-types-workflows#important-studio-dubbing-rule). * Studio onboarding (LSP hierarchy: Admin → PM → Linguist) is handled in the dashboard. See [Teams, Permissions, and LSP Hierarchy](/teams-permissions). *** ## 6. Accessibility — Audio Description **Goal:** Add narration describing on-screen visuals for accessibility compliance. **Recommended surface:** REST API or MCP. **Rules:** * Source language and target language are the same (e.g. English video with English Audio Description). * Use `orderType: aiDubbing` with `dubbingStyle: audioDescription`. **REST example:** ```bash theme={null} curl -X POST "https://api-integration.ollang.com/integration/orders/create" \ -H "X-Api-Key: " \ -H "Content-Type: application/json" \ -d '{ "orderType": "aiDubbing", "dubbingStyle": "audioDescription", "level": 0, "projectId": "", "targetLanguageConfigs": [{ "language": "en" }] }' ``` **Deliverables:** AD Mixed Audio (2.0 and 5.1), AD Narrator Audio (2.0 and 5.1), AD Mixed Video, Created M\&E, and Source Vocals-Only Audio. See [Audio Description Deliverables](/order-types-workflows#audio-description-deliverables). *** ## 7. Continuous Localization for App i18n Strings **Goal:** Translate `messages/*.json` (or other i18n string files) as new keys are added during development, and apply translations back to the codebase automatically. **Recommended surface:** Ollang SDK Asset Management. **Workflow:** ```text theme={null} ollang.config.ts defines source/target languages ↓ npx @ollang-dev/sdk start ↓ Scan project → Kanban board shows new/changed strings ↓ Select strings → submit for translation ↓ SDK creates document orders behind the scenes ↓ Translated values applied back to your JSON files ``` **Config example:** ```typescript ollang.config.ts theme={null} export default { projectRoot: ".", sourceLanguage: "en", targetLanguages: ["fr", "de", "ja", "es"], }; ``` **Why the SDK:** It handles file scanning, diffing, mapping translations back to the right JSON paths, and tracking which strings were sent for translation in a local kanban. See [SDK Features](/sdk/features). **CI integration:** Run the SDK in headless mode against your i18n folder as part of a release pipeline; gate releases on translation completion via the REST API. *** ## 8. Website / CMS Content Localization **Goal:** Localize content authored in a CMS (Strapi, custom headless) or content that lives on a live web page. **Recommended surfaces:** * **SDK Browser SDK** for in-browser CMS capture. * **MCP** for ad-hoc localization through an AI assistant. **Browser SDK flow:** 1. Add the Ollang Browser script to your CMS-powered site. 2. Visit the site with `?ollang-localize=true`. 3. Capture content via the debug panel as you navigate. 4. Submit captured content from the Asset Management control panel. See [SDK Quickstart — Browser CMS Capture](/sdk/quickstart#6-browser-cms-capture-optional). **MCP flow:** Configure the Ollang MCP server in your AI client, then ask: *"Localize the homepage hero copy from the Strapi CMS into French and Italian."* The assistant calls `uploadFile` and `createOrder` on your behalf. *** ## 9. AI Agent–Driven Localization (Skills + MCP) **Goal:** Let an AI coding agent (Cursor, Claude Code, Codex, Windsurf, Devin) trigger translations and check status from a single conversation — no dashboard switching, no custom prompts. **Recommended surfaces:** * **Skills** — file-based, no server. Best for editor-bound dev workflows. * **MCP** — hosted, OAuth-authenticated. Best when multiple humans / agents share the same Ollang account. **Example agent prompt:** ``` Upload the video at https://example.com/demo.mp4 to Ollang as English, then create AI dubbing orders for French and Japanese with overdub style and auto QC. Report the order IDs and check status in 60 seconds. ``` The agent calls `uploadFile`, then `createOrder`, then `getOrderById` — all via the same underlying REST endpoints. See [Skills Sub-Skills Reference](/skills/sub-skills) and [MCP Tools Reference](/mcp/tools) for the full tool list. *** ## Choosing the Right Pattern REST API with `curl`, or natural language via Skills/MCP. Skip callbacks; poll [Get Order by ID](/apis/ollang-api-reference/get-order-by-id). REST API or SDK, with `callbackUrl` for completion events. Idempotent callback handler. Folder-scoped workflows. See [Best Practices](/concepts/best-practices). MCP from Claude Desktop / Cursor / Devin. OAuth handles auth; users work in natural language. SDK Asset Management. Kanban board for visibility. Sync back to JSON. ## See Also * [Getting Started](/getting-started) — your first end-to-end call. * [How It All Connects](/concepts/how-it-all-connects) — the four integration surfaces in one diagram. * [Best Practices](/concepts/best-practices) — production guidance for callbacks, retries, pagination, and error handling. * [API Conventions](/concepts/api-conventions) — common patterns across the REST API. # Deliverables and Export Pipelines Source: https://api-docs.ollang.com/deliverables-exports Understand downloadable outputs, subtitle export formats, dubbing deliverables, and operational delivery workflows inside the Ollang Project Management Dashboard. ## Overview The Ollang Project Management Dashboard supports multiple deliverable types depending on: * workflow configuration, * Order type, * dubbing style, * subtitle requirements, * and operational delivery structure. Different workflows generate: * different downloadable assets, * different export formats, * and different operational outputs. For example: * Subtitle Translation workflows prioritize subtitle exports, * AI Dubbing workflows prioritize multilingual audio/video deliverables, * Audio Description workflows prioritize accessibility outputs, * and Studio Dubbing workflows prioritize Mixmaster coordination and studio delivery assets. *** # Deliverables by Workflow Type Generates subtitle exports such as SRT, VTT, ASS, SCC, STL, and broadcast-compatible formats. Generates dubbed audio, mixed video outputs, vocals-only files, and M\&E assets. Generates accessibility narration tracks and accessibility-focused multilingual audio outputs. Supports externally uploaded dubbing assets, Mixmaster coordination, and final delivery workflows. *** # Subtitle Deliverables ## Overview Subtitle workflows support: * multilingual subtitle exports, * broadcast-compatible subtitle formats, * localization review workflows, * and dubbing-support subtitle structures. These exports are commonly used for: * streaming platforms, * broadcasters, * accessibility workflows, * multilingual content distribution, * and subtitle editing operations. # Supported Subtitle Export Formats The platform currently supports: *** # Subtitle Format Explanations Standard subtitle format commonly used for streaming, YouTube, subtitle editing, and multilingual delivery workflows. WebVTT subtitle format commonly used for browser-based and HTML5 video workflows. Broadcast-oriented subtitle format used for television and enterprise media distribution. Captioning format commonly used for broadcast and closed-captioning workflows. Advanced subtitle format supporting styling, formatting, and advanced subtitle positioning behavior. Enhanced ASS workflow preserving subtitle styling and presentation formatting. Export optimized for voice actors, dubbing studios, and multilingual recording coordination. Operational export formats commonly used for review, auditing, reporting, and enterprise workflows. *** # FN Excluded Deliverables The platform additionally supports: * SCC-FN Excluded * SRT-FN Excluded * DFXP-FN Excluded * ASS-FN Excluded These specialized exports are commonly used for: * broadcast compliance, * subtitle formatting compatibility, * and enterprise delivery requirements. # Subtitle Export Operational Philosophy Different subtitle formats exist because different broadcasters, streaming platforms, and operational workflows require different subtitle structures. Examples: * streaming platforms may require SRT or VTT * broadcasters may require STL or SCC * advanced subtitle styling workflows may require ASS or Stylized ASS *** # AI Dubbing Deliverables ## Overview AI Dubbing workflows generate: * multilingual dubbed audio vocals, * mixed video output, * and downloadable production files. Depending on workflow configuration, AI Dubbing may generate: * audio-only outputs, * video outputs, * vocals-only files, * and M\&E-related deliverables simultaneously. C6 *** # Standard AI Dubbing Deliverables The platform may generate: Video output containing embedded localized subtitles. Final mixed video containing localized dubbed audio. Final dubbed audio output containing mixed operational audio. Dubbed vocals isolated from environmental audio layers. Generated or extracted Music & Effects track. Isolated source-language vocals extracted from original media. # Understanding M\&E Deliverables ## What is Created M\&E? Created M\&E refers to: * Music and Effects tracks generated or extracted from source media. These tracks preserve: * background music, * environmental sounds, * and non-dialogue audio, while removing: * spoken vocals. M\&E deliverables are especially important for: * AI Dubbing, * Studio Dubbing, * vocal replacement workflows, * and professional audio mixing operations. *** # Understanding Source Vocals Outputs Created Source Vocals Only Audio contains: * isolated source-language speech without environmental audio layers. These files are useful for: * dubbing review, * speech analysis, * timing verification, * and studio coordination workflows. *** # Audio Description Deliverables ## Overview When Audio Description dubbing style is selected, the platform may generate accessibility-focused outputs optimized for: * narration review, * accessibility playback, * and multilingual accessibility distribution. C7 *** # Audio Description Outputs The platform may generate: *** # Audio Description Deliverable Explanations Contains isolated Audio Description narration output used for accessibility review and narration validation. Contains Audio Description narration mixed with source media audio for accessibility playback workflows. Used for cinematic audio workflows, surround-sound environments, and professional media delivery. Used for stereo playback, web distribution, and lightweight accessibility delivery workflows. *** # Studio Dubbing Deliverables ## Overview Studio Dubbing workflows support: * externally generated dubbing deliverables, * studio-produced vocal assets, * and Mixmaster-oriented production workflows. Unlike AI Dubbing: * final voice recording occurs externally. The platform acts as: * the operational coordination and delivery layer. *** # Studio Dubbing Upload Workflows Studios and vendors may upload: * dubbing vocals, * final mixed outputs, * Mixmaster files, * and externally generated dubbing deliverables. The system can then: * coordinate operational delivery, * process audio workflows, * and manage final output generation. # Important Studio Dubbing Rule Studios **cannot** deliver isolated vocals-only files without sufficient operational audio structure. Delivery workflows require: * either final mixed outputs, * or sufficient audio assets for operational Mixmaster generation. *** # Embedded Subtitle Videos ## Overview Embedded Subtitle Videos contain: * subtitles permanently rendered into the video output which can be triggered either by an API operation or manually by pressing the download option inside the order deliverables as shown below:\\ C9 \ These deliverables are commonly used for: * social media localization, * marketing campaigns, * platform distribution, * and playback environments where external subtitle tracks are not supported. *** # Dubbing Scripts ## Overview Dubbing Script exports are optimized for: * voice actors, * dubbing studios, * linguists, * and recording coordination workflows. These scripts may contain: * subtitle timing, * dialogue segmentation, * speaker structures, * and localization references. *** # XLSX Deliverables ## Overview XLSX deliverables are commonly used for: * enterprise review, * subtitle auditing, * reporting, * translation review, * and workflow validation. These exports are especially useful for: * localization operations teams, * external reviewers, * and enterprise stakeholders. *** # Example AI Dubbing Delivery Workflow ```text theme={null} Source Video ↓ Speech-to-Text ↓ Subtitle Translation ↓ AI Voice Generation ↓ Audio Mixing ↓ Generated Deliverables: - Mixed Master Video - AI Dubbing Audio - M&E - Vocals Only - Embedded Subtitle Video ``` *** # Example Subtitle Delivery Workflow ```text theme={null} Source Video ↓ CC Generation ↓ French Subtitle Translation ↓ Linguist Review ↓ Generated Deliverables: - SRT - VTT - ASS - STL - DFXP ``` *** # Export Strategy by Use Case Common exports: * SRT * VTT * Embedded Subtitle Video Common exports: * STL * SCC * DFXP Common exports: * Dubbing Script * Vocals * M\&E * Mixed Master Common exports: * Audio Description Outputs * Narration Audio * Accessibility Video Deliverables *** # Operational Philosophy Different workflows intentionally generate different deliverables because localization operations vary significantly across media, accessibility, enterprise, and production environments. The platform is designed to support: * multilingual distribution, * accessibility operations, * enterprise localization, * professional dubbing, * and downstream media production pipelines. *** # Important Operational Notes Yes. Depending on workflow configuration, a single Order may generate multiple subtitle, audio, video, and operational deliverables simultaneously. Different broadcasters, streaming platforms, and operational workflows require different subtitle structures and compatibility standards. M\&E outputs preserve music and environmental audio while localized vocals replace original spoken dialogue during dubbing workflows. AI Dubbing Audio contains mixed operational audio, while Vocals Only outputs isolate speech from background audio layers. Yes. Studio Dubbing workflows support externally uploaded mixed outputs and studio-generated dubbing assets. # Getting Started Source: https://api-docs.ollang.com/getting-started Set up your Ollang account, make your first API call, and decide which integration path to use. # Getting Started This page walks you through the smallest end-to-end Ollang workflow: create an account, get an API key, upload a file, create a translation order, and read the result. You can then branch into the [REST API](/apis/ollang-api-reference/direct-file-upload), [MCP](/mcp/overview), [SDK](/sdk/overview), or [Skills](/skills/overview). ## Prerequisites * An [Ollang account](https://lab.ollang.com) (free to sign up). * An API key generated from the [Olabs Dashboard](https://lab.ollang.com). * `curl` (or your favorite HTTP client) for the examples below. * About **5 minutes**. Code samples on this page use generic placeholders — replace ``, ``, and `` with values from your account. Never commit API keys to source control. ## 1. Verify the API Is Reachable Run the unauthenticated health check to confirm connectivity from your environment: ```bash theme={null} curl https://api-integration.ollang.com/health ``` **Expected response:** ```json theme={null} { "time": 1704711600000, "status": "OK" } ``` Full reference: [Health Check](/apis/ollang-api-reference/health-check). If the health check fails, check [status.ollang.com](https://status.ollang.com) for an ongoing incident or scheduled maintenance before debugging your own environment. ## 2. Upload a Source File Send a file (video, audio, document, subtitle, or image for image-to-image translation) to Ollang. The endpoint returns a `projectId` you'll use to create orders. ```bash theme={null} curl -X POST "https://api-integration.ollang.com/integration/upload/direct" \ -H "X-Api-Key: " \ -H "Content-Type: multipart/form-data" \ -F "file=@./sample.mp4" \ -F "name=sample" \ -F "sourceLanguage=en" ``` **Expected response (`201`):** ```json theme={null} { "projectId": "" } ``` A few notes: * `sourceLanguage` uses ISO 639-1 codes — see [Supported Languages](/apis/ollang-api-reference/supported-languages). * `folderId` is optional; if omitted, uploads land in the default **API Uploads** folder. You can list folders with [Retrieve All Folders](/apis/ollang-api-reference/retrieve-all-folders). * Maximum sizes: **30 GB** for video, **100 MB** for documents (5 MB in the in-page API playground). Full reference: [Direct File Upload](/apis/ollang-api-reference/direct-file-upload). ## 3. Create a Translation Order With a `projectId`, create one or more orders. Each `targetLanguageConfigs` entry creates a separate order — the response is an array of order IDs. ```bash theme={null} curl -X POST "https://api-integration.ollang.com/integration/orders/create" \ -H "X-Api-Key: " \ -H "Content-Type: application/json" \ -d '{ "orderType": "subtitle", "level": 0, "projectId": "", "targetLanguageConfigs": [ { "language": "fr" }, { "language": "es" } ], "callbackUrl": "https://example.com/webhooks/ollang", "autoQc": true }' ``` **Expected response (`201`):** ```json theme={null} [ { "orderId": "" }, { "orderId": "" } ] ``` What the parameters mean: * **`orderType`** — `cc`, `subtitle`, `document`, `aiDubbing`, or `studioDubbing`. Full table at [Order Types](/apis/ollang-api-reference/order-types). * **`level`** — `0` for full-AI, `1` to add Ollang's human review gate. * **`callbackUrl`** *(optional)* — Ollang `POST`s the completed order payload here. Idempotent handlers recommended (10-second timeout). * **`autoQc`** *(optional)* — Run an AI QC evaluation automatically once the order completes. Full reference: [Create Order](/apis/ollang-api-reference/create-order). ## 4. Check Status (or Wait for the Callback) Poll the order until `status === "completed"`: ```bash theme={null} curl "https://api-integration.ollang.com/integration/orders/" \ -H "X-Api-Key: " ``` **Excerpted response:** ```json theme={null} { "orderId": "", "status": "completed", "targetLanguage": "fr", "orderDocs": [ { "type": "source_video", "name": "sample.mp4", "url": "https://example.com/..." }, { "type": "created_subtitle", "name": "fr.srt", "url": "https://example.com/..." } ], "vttUrl": "https://example.com/.vtt" } ``` All possible status values are listed in [Order Statuses](/apis/ollang-api-reference/order-statuses). Document type names (e.g. `created_subtitle`, `created_ai_dub_audio`) are listed in [Order Document Types](/apis/ollang-api-reference/order-doc-types). If you provided a `callbackUrl`, you don't need to poll — Ollang `POST`s the same payload to your URL when the order completes. Confirmation via [Get Order by ID](/apis/ollang-api-reference/get-order-by-id) is still a good safety net. ## 5. (Optional) Upgrade to Human Review Any AI-generated (Level 0) order can be escalated to Ollang-managed linguists after the fact: ```bash theme={null} curl -X POST "https://api-integration.ollang.com/integration/orders//human-review" \ -H "X-Api-Key: " \ -H "Content-Type: application/json" \ -d '{}' ``` Reference: [Request Human Review](/apis/ollang-api-reference/request-human-review). Need to back it out? See [Cancel Human Review](/apis/ollang-api-reference/cancel-human-review). ## What's Next Choose between REST API, MCP, SDK, or Skills — and learn how they overlap. End-to-end walkthroughs: AI dubbing, subtitle pipelines, document localization, visual translation, continuous i18n. Production guidance: callbacks, retries, pagination, folder structure, memory, and review gates. Base URL, authentication, pagination, errors, and webhook format in one place. Run the same workflow from Claude Desktop, Cursor, or Claude Code in 5 minutes. Scan a Next.js / React / Vue project for i18n strings and translate them. Give your AI agent natural-language access to Ollang — no MCP server needed. Folder, Project, Order, Level, Workflow, Review Gate, LSP, BYOK, QC — defined in one place. Auth errors, callback issues, retries, rate limits, and how to file a good bug. # Glossary Source: https://api-docs.ollang.com/glossary Definitions of the core concepts you'll see throughout Ollang docs — Folder, Project, Order, Level, Workflow, Review Gate, LSP, QC, BYOK, and more. # Glossary A quick reference for the terminology used across the Ollang platform and these docs. For full context, follow the links into the user guides. ## Platform Hierarchy The highest organizational layer in the platform. Folders are workflow-agnostic containers used to group related projects — by campaign, content type, team, or any operational grouping. Workflow overrides, custom instructions, anomaly detection, and review-gate configuration can all be scoped at the folder level. See [Platform Architecture](/platform-architecture) and [Workflows and Provider Architecture](/workflows-provider-architecture). Represents a single source asset (video, audio, document, image, or strings file) uploaded into Ollang. A project is created automatically when you call [Direct File Upload](/apis/ollang-api-reference/direct-file-upload) and is the parent of one or more orders. The actual localization workflow. An order has an **`orderType`** (e.g. `subtitle`, `aiDubbing`), a **`level`**, a **target language**, and references the parent project's source asset. Each target language in a [Create Order](/apis/ollang-api-reference/create-order) request creates a separate order with its own `orderId`. ## Order Types Multilingual dubbed audio + mixed video using AI voice synthesis. Supports `overdub`, `lipsync`, and `audioDescription` dubbing styles. TTS-first flows accept a `.txt` script with no source video. See [Order Types and Workflow Architecture](/order-types-workflows). Translate timed dialogue and subtitle assets. Produces SRT, VTT, ASS, STL, SCC, DFXP, ITT, DOCX, XLSX, and dubbing-script exports. See [Deliverables and Export Pipelines](/deliverables-exports). Generate closed captions or timecoded transcription from source media. Uses the `orderSubType` field to choose between `closedCaption` and `timecodedTranscription`. Localize DOCX, PDF, PPTX, XLSX, HTML, JSON, DITA, mobile strings (`.xml`, `.strings`, `.stringsdict`), AE projects, and JPEG/PNG image-to-image content. Versions are retained across reruns for rollback. Coordinate external dubbing studios — Ollang acts as the orchestration and delivery layer for studio-produced vocals, M\&E, and mixed outputs. See [Teams, Permissions, and LSP Hierarchy](/teams-permissions). Localize on-screen text inside videos, graphics, and visual assets. Preserves layout, positioning, and multilingual consistency. Visual Translation is a **platform capability**, not a separate API enum — image-to-image flows run through `orderType: document` when the source is JPEG / JPG / PNG uploaded via [Direct File Upload](/apis/ollang-api-reference/direct-file-upload). See [Visual Translation](/order-types-workflows#visual-translation). Localize website content, UI strings, and structured localization files across languages. Typically runs through `orderType: document` on extracted strings (JSON, XLIFF, PO, mobile string formats) — or via [SDK Browser SDK](/sdk/features#browser-sdk) for in-page CMS capture. Not a separate API enum. ## Workflow Concepts `0` = full AI output, no human in the loop. `1` = AI output passed through an Ollang Human Review gate. Set in [Create Order](/apis/ollang-api-reference/create-order). Level 0 orders can be escalated to Level 1 later via [Request Human Review](/apis/ollang-api-reference/request-human-review). Applies to AI Dubbing orders. One of `overdub`, `lipsync`, or `audioDescription`. Controls voice synthesis pacing, timing, and downstream deliverables. A reusable configuration that says, for a given language pair and order type, which AI providers and review gates to use. Workflows can be **Global** (account-wide default) or scoped to a **Folder**. Folder workflows override Global workflows. Project-level workflows are not currently supported. See [Workflows and Provider Architecture](/workflows-provider-architecture). A configurable step in a workflow that decides whether an order needs human review — based on, for example, an AI QC threshold (`qcThreshold`). Review modes are `Assignment` (auto-assign the order to a Team Tag member) or `Comment` (route to a tag for review-only). Re-execute a completed order against the current workflow. Useful when source content changes, the workflow is updated, or you want fresh output from newer AI models. See [Rerun Order](/apis/ollang-api-reference/rerun-order). When `true`, Ollang automatically runs a QC evaluation after the AI order completes. Only applies to top-level orders (child orders are excluded). Requires `enableQCThreshold` on the client. See [Run QC Evaluation](/apis/ollang-api-reference/run-qc-evaluation). ## People and Teams Internal Ollang account users — Owner, Admin, Project Manager, or Team Member — operating inside the [Project Management Dashboard](https://lab.ollang.com). They create orders, manage workflows, and review analytics. Operates inside the Editor interface. Sees only orders explicitly assigned to them — assignment is at the Order level, not Project level. An external translation vendor with its own internal hierarchy: * **LSP Admin** — manages localization operations and assigns orders. * **LSP Project Manager** — coordinates assignments and delivery pipelines. * **LSP Linguist** — edits assigned orders. Inviting an editor auto-promotes through the AI → Linguist → Admin flow. See [Teams, Permissions, and LSP Hierarchy](/teams-permissions). External vendors with their own internal users. Studio Dubbing vendors can upload dubbing vocals, final mixed outputs, and Mixmaster files. ## Quality and Memory Automated subtitle quality scoring across four built-in dimensions — **Accuracy**, **Fluency**, **Tone**, **Cultural Fit** — plus any custom criteria you define. Triggered manually, automatically (`autoQc`), or via [Run QC Evaluation](/apis/ollang-api-reference/run-qc-evaluation). Manual, linguist-driven quality tagging on subtitle segments. Categories include **Accuracy**, **Terminology**, **Hallucination**, **Verity**; severities are **Minor**, **Major**, **Critical**. A multilingual reference of approved terminology and translations that Ollang uses to improve consistency on future orders. Organizations can maintain multiple memories (e.g. legal, medical, brand). See [Memory, Guidelines, and Custom Instructions](/memory-guidelines-custom-instructions). Account-wide translation guidance applied when no folder or project guideline overrides it. Managed via [List](/apis/ollang-api-reference/list-custom-instructions) / [Create](/apis/ollang-api-reference/create-custom-instruction) / [Update](/apis/ollang-api-reference/update-custom-instruction) / [Delete](/apis/ollang-api-reference/delete-custom-instruction) endpoints, or surfaced as [Suggestions](/apis/ollang-api-reference/get-custom-instruction-suggestions). Folder- or project-scoped instructions controlling localization behavior for specific workflows. Take precedence over global Custom Instructions. ## Assets and Deliverables The source content being localized — a video, audio file, document, image, or strings file. Uploaded via [Direct File Upload](/apis/ollang-api-reference/direct-file-upload). Anything that helps the linguist or AI — guidelines, glossaries, character lists, reference videos, scripts. See [Source Files and Asset Handling](/source-files-assets). Background music and environmental audio extracted from the source media, used during dubbing so localized vocals can replace the original dialogue while preserving the surrounding soundscape. A video output with subtitles burned in. Triggered via API ([Request Subtitle Embedding](/apis/ollang-api-reference/request-subtitle-embedding)) or from the order page in the dashboard. A subtitle export optimized for voice actors and dubbing studios. Contains dialogue segmentation, speaker structure, and timing. ## Platform Capabilities Use your own LLM provider API keys for Ollang workflows. Plan-gated — check your subscription's BYOK feature flag. Keys are stored encrypted and applied per-workflow at runtime. Optional URL provided on [Create Order](/apis/ollang-api-reference/create-order) or [Rerun Order](/apis/ollang-api-reference/rerun-order). Ollang `POST`s the completed-order payload to your URL. 10-second timeout, IPv6 blocked at the SSRF guard. Treat handlers as idempotent. Detects unusual translation patterns (timing drift, unusually long segments, hallucinations) and surfaces them for review. Configurable at folder and project levels with cascade behavior. Endpoint to download source and deliverable assets for a translator or LSP dashboard in bulk, including Mux video URLs. Pull and push files between Ollang and external storage. Google Drive supports OAuth and shared drives; subtitle orders push back the burned subtitle video, VTT, and a comments xlsx. Other supported connectors include Dropbox, YouTube, Vimeo, Strapi, and TikTok (private release). # Introduction Source: https://api-docs.ollang.com/home Welcome to the Ollang documentation — APIs, MCP server, SDK, Skills, and platform concepts for AI-native localization. # Welcome to Ollang Ollang is an AI-native localization platform for video, audio, and document content. The platform orchestrates AI dubbing, subtitle translation, captions, transcription, document and visual translation, and human review workflows in one place — and exposes everything through APIs, an MCP server, an SDK, and agent Skills. These docs cover four ways to integrate with Ollang and a set of user guides for the concepts behind them: A short tour: account setup, your first upload + order, and where to go next. REST API, MCP, SDK, Skills, and workflows — when to use each and how they fit together. End-to-end walkthroughs: AI dubbing, subtitle pipelines, document localization, visual translation, audio description, continuous i18n. Production guidance: API keys, callbacks, retries, pagination, error handling, folder structure, memory. Base URL, authentication, request/response format, pagination, errors, and callbacks — in one reference page. Folders, Projects, Orders, Levels, Workflows, Review Gates, LSPs, QC, BYOK, and more. Common errors, debugging callbacks, retries, and what to send to support. ## What Ollang Does Ollang takes a source asset — a video, audio file, document, image, subtitle file, or strings file — and produces high-quality, multilingual, fully reviewable localization outputs. Multilingual dubbed audio and mixed video with optional Lip Sync or Audio Description. TTS-first flows accept a `.txt` script with no source video. Generate captions, translate them, and export SRT, VTT, ASS, STL, SCC, DFXP, ITT, DOCX, XLSX, and broadcast-compatible formats. DOCX, PDF, PPTX, XLSX, HTML, JSON, DITA, mobile strings (`.xml`, `.strings`, `.stringsdict`), AE projects, and JPEG/PNG image-to-image. On-screen text inside videos, graphics, and visual assets — preserving layout and positioning. Add a Level 1 review gate to any order to route output to Ollang-managed linguists or your own LSPs and editors. AI QC across accuracy, fluency, tone, and cultural fit; human QC annotations; QC score progression and human-edit-percentage analytics. ## Pick Your Integration Path Programmatic uploads, orders, projects, revisions, QC, human review, and webhooks. API-key authenticated. Hosted Model Context Protocol server (OAuth 2.0 + PKCE). Drop into Claude, Cursor, Claude Code, Devin, Replit, Windsurf, and more. TypeScript/Node.js SDK for asset scanning, i18n workflows, CMS capture, and a typed REST client. File-based [Agent Skills](https://skills.sh) (Cursor, Claude Code, Codex, Windsurf, Cline) — natural-language ops with no server to run. ## User Guides Conceptual documentation for the Ollang Project Management Dashboard — read these to understand the operational model before integrating: The Folder → Project → Order hierarchy and why it matters. AI Dubbing, Subtitle Translation, CC, Document, Studio Dubbing, Visual Translation, Website Translation. Primary vs supporting assets, M\&E, glossaries, guidelines, supported formats. Subtitle export formats, AI Dubbing outputs, Audio Description, Studio Dubbing. AI-only vs AI + Human Review, editor interface, assignments, QC annotations. Project Management roles, Editor / LSP hierarchy, agencies, and dubbing studios. Global vs Folder workflows, language-pair routing, provider selection. Every STT, translation, TTS, and audio provider you can select, and what each one is good at. Translation memories, custom instructions, folder- and project-level guidelines. Order analytics, QC progression, payment, credit, and edit-percentage insights. ## Stay Up to Date * **[Changelog](/changelog)** — New releases and improvements, updated regularly. * **[Service Status](https://status.ollang.com)** — Live availability of the Ollang platform and APIs, incident updates, and scheduled maintenance. * **[Trust Center](https://trust.ollang.com)** — Security, privacy, and compliance posture, plus how Ollang handles the content you send it. * **[Ollang Blog](https://blog.ollang.com/)** — Deeper write-ups and announcements. * **Support** — Email [info@ollang.com](mailto:info@ollang.com) or use the **Ollang Dashboard** link in the top bar. Code samples in these docs use generic placeholders (``, `customer_id`, `project_id`, `order_id`, `example.com`). Replace them with your own values from the [Olabs Dashboard](https://lab.ollang.com). # Airtable Source: https://api-docs.ollang.com/mcp/integrations/airtable Automate translation workflows by combining Ollang MCP with Airtable's official hosted MCP server. # Ollang MCP + Airtable Airtable operates this official hosted MCP server, separately from Ollang. An Airtable organization admin may need to allow-list the integration before users can authorize it. Use [Airtable's official MCP server](https://mcp.airtable.com/mcp) with Ollang MCP to build translation pipelines powered by your Airtable bases. Airtable also offers an official Claude connector in the Claude directory and an official ChatGPT app. ## Why Airtable + Ollang? Airtable is widely used for managing localization projects, tracking translation progress, and organizing multilingual content. By connecting both servers, your AI assistant can: * Pull content from Airtable records and submit it to Ollang * Track translation order statuses and update Airtable * Manage glossaries stored in Airtable * Create records with translated content ## Setup The Airtable server uses OAuth and supports Dynamic Client Registration. Add Airtable through **Settings → Connectors → Add Connector**, or choose Airtable from the official Claude connector directory. Add Ollang with `https://mcp.ollang.com/mcp`, then authorize both services. ```bash theme={null} claude mcp add --transport http ollang https://mcp.ollang.com/mcp claude mcp add --transport http airtable https://mcp.airtable.com/mcp ``` ```json .cursor/mcp.json theme={null} { "mcpServers": { "ollang": { "url": "https://mcp.ollang.com/mcp" }, "airtable": { "url": "https://mcp.airtable.com/mcp" } } } ``` Add both remote servers in **Settings > Integrations > MCP Servers**: ```json theme={null} { "mcpServers": [ { "name": "ollang", "url": "https://mcp.ollang.com/mcp", "transport": "http" }, { "name": "airtable", "url": "https://mcp.airtable.com/mcp", "transport": "http" } ] } ``` ```json .replit-mcp.json theme={null} { "mcpServers": { "ollang": { "url": "https://mcp.ollang.com/mcp", "transport": "http" }, "airtable": { "url": "https://mcp.airtable.com/mcp", "transport": "http" } } } ``` Add both remote servers via **Settings > Integrations > MCP Servers**: ```json lovable.json theme={null} { "mcp": { "servers": { "ollang": { "url": "https://mcp.ollang.com/mcp", "transport": "http" }, "airtable": { "url": "https://mcp.airtable.com/mcp", "transport": "http" } } } } ``` ## Airtable MCP Tools | Tool | Description | | - | - | | `list_bases` | List accessible Airtable bases | | `list_tables` | List tables in a base | | `list_records` | List records with optional filtering | | `search_records` | Search records by field values | | `create_record` | Create a new record | | `update_records` | Update existing records | | `delete_records` | Delete records | ## Example Workflows ### Batch translate Airtable content ``` Find records in the "Product Descriptions" table where Status is "Ready for Translation". Upload each English Description to Ollang and create French and German document orders. Write each order ID back to Airtable. ``` ### Track localization progress ``` Check my Ollang orders and update the matching Airtable translation records with their current status and delivered file links. ``` ### Build a glossary ``` Read approved terms from the Airtable Glossary base and create an Ollang custom instruction that preserves those terms in every future product localization order. ``` # Contentful Source: https://api-docs.ollang.com/mcp/integrations/contentful Localize Contentful entries with the official remote MCP server and Ollang. # Ollang MCP + Contentful The Contentful Remote MCP app must be installed in the environment. Space admins control which tools it exposes. Contentful operates the hosted server separately from Ollang. Use [Contentful's official remote MCP server](https://www.contentful.com/developers/docs/tools/mcp-server/) with Ollang MCP to localize structured content. The GA remote endpoint is `https://mcp.contentful.com/mcp`; EU spaces use `https://mcp.eu.contentful.com/mcp` and OAuth 2.1. ## Why Contentful + Ollang? By connecting Contentful and Ollang, your AI assistant can: * Read entries and content for localization * Create Ollang document translation orders * Prepare localized content for Contentful * Keep multilingual publishing workflows organized ## Setup Install the Contentful Remote MCP app in the environment and authorize access over OAuth 2.1. ```json theme={null} { "mcpServers": { "ollang": { "url": "https://mcp.ollang.com/mcp" }, "contentful": { "url": "https://mcp.contentful.com/mcp" } } } ``` Use `https://mcp.eu.contentful.com/mcp` for EU spaces. ```bash theme={null} claude mcp add --transport http ollang https://mcp.ollang.com/mcp claude mcp add --transport http contentful https://mcp.contentful.com/mcp ``` Use the EU endpoint for EU spaces. ```json .cursor/mcp.json theme={null} { "mcpServers": { "ollang": { "url": "https://mcp.ollang.com/mcp" }, "contentful": { "url": "https://mcp.contentful.com/mcp" } } } ``` Add both remote servers in **Settings > Integrations > MCP Servers**: ```json theme={null} { "mcpServers": [ { "name": "ollang", "url": "https://mcp.ollang.com/mcp", "transport": "http" }, { "name": "contentful", "url": "https://mcp.contentful.com/mcp", "transport": "http" } ] } ``` ```json .replit-mcp.json theme={null} { "mcpServers": { "ollang": { "url": "https://mcp.ollang.com/mcp", "transport": "http" }, "contentful": { "url": "https://mcp.contentful.com/mcp", "transport": "http" } } } ``` Add both remote servers via **Settings > Integrations > MCP Servers**: ```json lovable.json theme={null} { "mcp": { "servers": { "ollang": { "url": "https://mcp.ollang.com/mcp", "transport": "http" }, "contentful": { "url": "https://mcp.contentful.com/mcp", "transport": "http" } } } } ``` ## Contentful MCP Capabilities | Capability | Description | | - | - | | Remote access | Connect to Contentful over OAuth 2.1 | | Tool controls | Space admins choose which tools the app exposes | | EU endpoint | Use the EU host for EU spaces | ## Example Workflows ### Localize Contentful entries ``` Find published English entries for the product site, upload their translatable fields to Ollang, and create French and German document translation orders. ``` ### Translate help-center content ``` Find the English help-center entries updated this month, create Ollang orders for Japanese and Spanish, and prepare the delivered content for the corresponding Contentful locales. ``` ### Audit missing locales ``` Review the content environment for entries missing their required locales. Create an Ollang custom instruction for our CMS terminology and summarize the translation orders needed. ``` A local Contentful server is also available with `npx @contentful/mcp-server` and a CMA personal access token for clients that cannot use the hosted server. # Dropbox Source: https://api-docs.ollang.com/mcp/integrations/dropbox Manage translation files stored in Dropbox with Ollang MCP and Dropbox's hosted MCP servers. # Ollang MCP + Dropbox Dropbox operates the official remote MCP servers separately from Ollang. The main server is in open beta and uses OAuth. Dropbox also provides the read-only Dash server at `https://mcp.dropbox.com/dash` for search across connected content. Use the [Dropbox MCP server](https://help.dropbox.com/integrations/connect-dropbox-mcp-server) with Ollang MCP to pull documents from Dropbox, translate them, and save results back. ## Why Dropbox + Ollang? Dropbox is a file storage platform for teams. By connecting both servers, your AI assistant can: * Pull source documents, subtitles, and media from Dropbox * Upload files directly to Ollang for translation * Save translated files back to organized folders * Search connected content with the read-only Dash server ## Setup The main Dropbox server uses OAuth. Dynamic Client Registration is supported for Claude Code, Claude web, ChatGPT Codex, ChatGPT web, and Cursor; other clients register a Dropbox app manually. ```json claude_desktop_config.json theme={null} { "mcpServers": { "ollang": { "url": "https://mcp.ollang.com/mcp" }, "dropbox": { "url": "https://mcp.dropbox.com/mcp" } } } ``` ```bash theme={null} claude mcp add --transport http ollang https://mcp.ollang.com/mcp claude mcp add --transport http dropbox https://mcp.dropbox.com/mcp ``` ```json .cursor/mcp.json theme={null} { "mcpServers": { "ollang": { "url": "https://mcp.ollang.com/mcp" }, "dropbox": { "url": "https://mcp.dropbox.com/mcp" } } } ``` Add both remote servers in **Settings > Integrations > MCP Servers**: ```json theme={null} { "mcpServers": [ { "name": "ollang", "url": "https://mcp.ollang.com/mcp", "transport": "http" }, { "name": "dropbox", "url": "https://mcp.dropbox.com/mcp", "transport": "http" } ] } ``` ```json .replit-mcp.json theme={null} { "mcpServers": { "ollang": { "url": "https://mcp.ollang.com/mcp", "transport": "http" }, "dropbox": { "url": "https://mcp.dropbox.com/mcp", "transport": "http" } } } ``` Add both remote servers via **Settings > Integrations > MCP Servers**: ```json lovable.json theme={null} { "mcp": { "servers": { "ollang": { "url": "https://mcp.ollang.com/mcp", "transport": "http" }, "dropbox": { "url": "https://mcp.dropbox.com/mcp", "transport": "http" } } } } ``` ## Dropbox MCP Capabilities | Capability | Description | | - | - | | Browse files | Navigate folders and list files | | Search | Find files by name or content | | Download | Retrieve file contents | | Upload | Save files to Dropbox | | Manage | Create folders, move, and rename files | ## Example Workflows ### Translate documents from Dropbox ``` Find source documents in my Dropbox localization folder. Upload each to Ollang and create French, Spanish, and German document translation orders. Save the order IDs with the source file names. ``` ### Subtitle file workflow ``` Download the English subtitle file for the product demo from Dropbox, send it through Ollang's subtitle workflow, and create Japanese and Korean orders. ``` ### Search and localize content ``` Use Dropbox Dash to find the latest English launch assets, upload the matching files to Ollang, and create subtitle and AI dubbing orders for Spanish and Portuguese. ``` # Figma Source: https://api-docs.ollang.com/mcp/integrations/figma Localize Figma designs and UI content using Figma's remote MCP server and Ollang. # Ollang MCP + Figma Figma operates the hosted MCP server separately from Ollang. The remote server is preferred for shared workflows; Figma's desktop/local server is available at `http://127.0.0.1:3845/mcp` but is not required here. Use [Figma's remote MCP server](https://developers.figma.com/docs/figma-mcp-server/remote-server-installation/) with Ollang MCP to turn design context into localization work. ## Why Figma + Ollang? By connecting Figma and Ollang, your AI assistant can: * Scope a request to a Figma file or selected node * Extract design context for UI localization * Create Ollang document translation orders for locale content * Keep translated UI strings aligned with a design handoff ## Setup The remote Figma server is link-based. Pass a Figma file URL or a **Copy link to selection** node URL in your prompt to scope the request. Add both remote servers through your MCP settings: ```json theme={null} { "mcpServers": { "ollang": { "url": "https://mcp.ollang.com/mcp" }, "figma": { "url": "https://mcp.figma.com/mcp" } } } ``` ```bash theme={null} claude mcp add --transport http ollang https://mcp.ollang.com/mcp claude mcp add --transport http figma https://mcp.figma.com/mcp ``` Add `--scope user` to the Figma command to make it available in all projects. ```json .cursor/mcp.json theme={null} { "mcpServers": { "ollang": { "url": "https://mcp.ollang.com/mcp" }, "figma": { "url": "https://mcp.figma.com/mcp" } } } ``` Add both remote servers in **Settings > Integrations > MCP Servers**: ```json theme={null} { "mcpServers": [ { "name": "ollang", "url": "https://mcp.ollang.com/mcp", "transport": "http" }, { "name": "figma", "url": "https://mcp.figma.com/mcp", "transport": "http" } ] } ``` ```json .replit-mcp.json theme={null} { "mcpServers": { "ollang": { "url": "https://mcp.ollang.com/mcp", "transport": "http" }, "figma": { "url": "https://mcp.figma.com/mcp", "transport": "http" } } } ``` Add both remote servers via **Settings > Integrations > MCP Servers**: ```json lovable.json theme={null} { "mcp": { "servers": { "ollang": { "url": "https://mcp.ollang.com/mcp", "transport": "http" }, "figma": { "url": "https://mcp.figma.com/mcp", "transport": "http" } } } } ``` ## Figma MCP Capabilities | Capability | Description | | - | - | | Link-based context | Scope a request with a Figma file URL or selected-node URL | | Remote server | Connect to Figma at `https://mcp.figma.com/mcp` | ## Example Workflows ### Localize a design handoff ``` Use this Figma file URL: https://www.figma.com/design/FILE_ID/example. Identify the UI strings that need localization, upload them to Ollang, and create French, German, and Japanese document translation orders. ``` ### Translate a selected component ``` Use this Copy link to selection node URL from the settings screen: https://www.figma.com/design/FILE_ID/example?node-id=NODE_ID. Extract its user-facing strings and prepare an Ollang order for Spanish and Portuguese while preserving placeholders. ``` ### Check locale expansion ``` Review the selected checkout flow in Figma and identify labels likely to expand in German. Create an Ollang custom instruction for concise UI copy and use it for the related locale-file translation order. ``` # GitHub Source: https://api-docs.ollang.com/mcp/integrations/github Translate repository locale files and open localization pull requests with GitHub MCP and Ollang. # Ollang MCP + GitHub GitHub operates the hosted remote MCP server separately from Ollang. It requires a GitHub Copilot seat. Hosts that support OAuth can authorize it interactively; other clients can use a personal access token in an `Authorization: Bearer` header. Use [GitHub's hosted MCP server](https://github.com/github/github-mcp-server/blob/main/docs/remote-server.md) with Ollang MCP to localize repository content and return translated files through pull requests. ## Why GitHub + Ollang? By connecting GitHub and Ollang, your AI assistant can: * Work with locale files in repositories * Create Ollang translation orders and track their IDs * Prepare translated files for review * Open pull requests containing completed localization work ## Setup The hosted endpoint is Streamable HTTP: `https://api.githubcopilot.com/mcp/` GitHub also supports per-toolset URLs and a `/readonly` suffix for read-only access. A local/Docker server is available for hosts without remote MCP support. ```json theme={null} { "mcpServers": { "ollang": { "url": "https://mcp.ollang.com/mcp" }, "github": { "url": "https://api.githubcopilot.com/mcp/" } } } ``` ```bash theme={null} claude mcp add --transport http ollang https://mcp.ollang.com/mcp claude mcp add --transport http github https://api.githubcopilot.com/mcp/ ``` ```json .cursor/mcp.json theme={null} { "mcpServers": { "ollang": { "url": "https://mcp.ollang.com/mcp" }, "github": { "url": "https://api.githubcopilot.com/mcp/" } } } ``` Add both remote servers in **Settings > Integrations > MCP Servers**: ```json theme={null} { "mcpServers": [ { "name": "ollang", "url": "https://mcp.ollang.com/mcp", "transport": "http" }, { "name": "github", "url": "https://api.githubcopilot.com/mcp/", "transport": "http" } ] } ``` ```json .replit-mcp.json theme={null} { "mcpServers": { "ollang": { "url": "https://mcp.ollang.com/mcp", "transport": "http" }, "github": { "url": "https://api.githubcopilot.com/mcp/", "transport": "http" } } } ``` Add both remote servers via **Settings > Integrations > MCP Servers**: ```json lovable.json theme={null} { "mcp": { "servers": { "ollang": { "url": "https://mcp.ollang.com/mcp", "transport": "http" }, "github": { "url": "https://api.githubcopilot.com/mcp/", "transport": "http" } } } } ``` ## GitHub MCP Capabilities | Capability | Description | | - | - | | Remote access | Hosted Streamable HTTP server at `api.githubcopilot.com` | | Toolsets | Select toolsets with per-toolset URLs | | Read-only mode | Add `/readonly` for read-only access | ## Example Workflows ### Translate locale files and open a PR ``` Find changed locale source files under src/locales/en in this repository. Upload them to Ollang, create French and German document orders, and open a pull request with the delivered files when the orders complete. ``` ### Localize a release ``` Read the release notes and UI strings changed since the last release, create Ollang translation orders for Japanese and Spanish, and prepare a branch with the translated locale files for review. ``` ### Track localization in GitHub ``` Read localization-orders.json, check each Ollang order, and update the repository's localization tracking issue with completed files and links. ``` # Notion Source: https://api-docs.ollang.com/mcp/integrations/notion Translate Notion pages and databases using Ollang MCP and Notion's hosted MCP server. # Ollang MCP + Notion Notion operates its own hosted MCP server, separately from Ollang. Authorize your Notion workspace over OAuth when you connect for the first time. The open-source `@notionhq/notion-mcp-server` package is deprecated and no longer actively maintained. Use [Notion's hosted MCP server](https://mcp.notion.com/mcp) alongside Ollang MCP to translate Notion content and manage multilingual documentation. Notion also provides the SSE endpoint `https://mcp.notion.com/sse`; Streamable HTTP at `https://mcp.notion.com/mcp` is recommended. ## Why Notion + Ollang? Notion is a popular workspace for content creation, documentation, and knowledge management. By connecting both MCP servers, your AI assistant can: * Extract content from Notion pages and translate it via Ollang * Create localized copies of pages in different languages * Manage translation project briefs and content calendars in Notion * Sync translation statuses back to Notion databases ## Setup Add Notion as a remote connector through **Settings → Connectors → Add Connector** and enter: ``` https://mcp.notion.com/mcp ``` Add Ollang as another connector with `https://mcp.ollang.com/mcp`, then authorize both workspaces over OAuth. Add the hosted servers: ```bash theme={null} claude mcp add --transport http ollang https://mcp.ollang.com/mcp claude mcp add --transport http notion https://mcp.notion.com/mcp ``` ```json .cursor/mcp.json theme={null} { "mcpServers": { "ollang": { "url": "https://mcp.ollang.com/mcp" }, "notion": { "url": "https://mcp.notion.com/mcp" } } } ``` Add both remote servers in **Settings > Integrations > MCP Servers**: ```json theme={null} { "mcpServers": [ { "name": "ollang", "url": "https://mcp.ollang.com/mcp", "transport": "http" }, { "name": "notion", "url": "https://mcp.notion.com/mcp", "transport": "http" } ] } ``` ```json .replit-mcp.json theme={null} { "mcpServers": { "ollang": { "url": "https://mcp.ollang.com/mcp", "transport": "http" }, "notion": { "url": "https://mcp.notion.com/mcp", "transport": "http" } } } ``` Add both remote servers via **Settings > Integrations > MCP Servers**: ```json lovable.json theme={null} { "mcp": { "servers": { "ollang": { "url": "https://mcp.ollang.com/mcp", "transport": "http" }, "notion": { "url": "https://mcp.notion.com/mcp", "transport": "http" } } } } ``` ## Notion MCP Tools | Tool | Description | | - | - | | `search-content` | Search across Notion pages and databases | | `retrieve-a-page` | Get a specific page's content | | `create-a-page` | Create a new page | | `update-page-content` | Update page content | | `append-block-content` | Append blocks to a page | | `retrieve-a-database` | Get database schema and entries | | `query-data-source` | Query a database with filters | ## Example Workflows ### Translate a Notion page ``` Read the Notion page titled "Product Launch Announcement" and upload its content to Ollang for document translation into Spanish, French, and Portuguese. Once translation is complete, create a localized Notion page for each language. ``` ### Localize a content database ``` Query the "Blog Posts" database for entries with status "Published". Create Ollang document translation orders for Japanese and Korean, then track the returned order IDs in a Translation Tracker database. ``` ### Turn a brief into instructions ``` Read the "Translation Brief" page in Notion and create an Ollang custom instruction from its terminology and tone requirements before translating the related product documentation. ``` # Strapi Source: https://api-docs.ollang.com/mcp/integrations/strapi Localize Strapi CMS content using its built-in MCP server and Ollang. # Ollang MCP + Strapi Strapi's built-in MCP server is self-hosted and operated by the Strapi project, not Ollang. It is available from v5.47.0 and GA in v5.49.0. Enable it explicitly with `server.mcp.enabled` in the server config; it is false by default. Use Strapi's built-in MCP server at your Strapi instance's `/mcp` endpoint with Ollang MCP to automate CMS localization. The Streamable HTTP endpoint might look like `http://localhost:1337/mcp`. ## Why Strapi + Ollang? Strapi is an open-source headless CMS. By connecting both servers, your AI assistant can: * Pull content entries and translate them via Ollang * Create localized versions of blog posts and product pages * Update and publish translated content * Identify content missing translations ## Setup Enable `server.mcp.enabled` in the Strapi server config, then create an Admin API token in the Strapi admin panel. The token's permissions determine which CRUD tools are exposed for each content type. ```json claude_desktop_config.json theme={null} { "mcpServers": { "ollang": { "url": "https://mcp.ollang.com/mcp" }, "strapi": { "url": "http://localhost:1337/mcp", "headers": { "Authorization": "Bearer " } } } } ``` ```json .mcp.json theme={null} { "mcpServers": { "ollang": { "type": "http", "url": "https://mcp.ollang.com/mcp" }, "strapi": { "type": "http", "url": "http://localhost:1337/mcp", "headers": { "Authorization": "Bearer " } } } } ``` ```json .cursor/mcp.json theme={null} { "mcpServers": { "ollang": { "url": "https://mcp.ollang.com/mcp" }, "strapi": { "url": "http://localhost:1337/mcp", "headers": { "Authorization": "Bearer " } } } } ``` Add both servers in **Settings > Integrations > MCP Servers**: ```json theme={null} { "mcpServers": [ { "name": "ollang", "url": "https://mcp.ollang.com/mcp", "transport": "http" }, { "name": "strapi", "url": "http://localhost:1337/mcp", "transport": "http", "headers": { "Authorization": "Bearer " } } ] } ``` ```json .replit-mcp.json theme={null} { "mcpServers": { "ollang": { "url": "https://mcp.ollang.com/mcp", "transport": "http" }, "strapi": { "url": "http://localhost:1337/mcp", "transport": "http", "headers": { "Authorization": "Bearer " } } } } ``` Add both servers via **Settings > Integrations > MCP Servers**: ```json lovable.json theme={null} { "mcp": { "servers": { "ollang": { "url": "https://mcp.ollang.com/mcp", "transport": "http" }, "strapi": { "url": "http://localhost:1337/mcp", "transport": "http", "headers": { "Authorization": "Bearer " } } } } } ``` Self-hosted and local URLs need a client that can reach your Strapi instance. Claude's cloud-hosted connectors cannot reach `localhost`. ## Strapi MCP Tools | Capability | Description | | - | - | | Find | Find content entries | | Create | Create content entries | | Update | Update content entries | | Publish | Publish content | | Unpublish | Unpublish content | The Admin API token permissions determine which CRUD tools are exposed for each content type. ## Example Workflows ### Translate blog posts ``` Find English blog posts in Strapi, upload their content to Ollang, and create French and German document translation orders. Create localized entries when the translations are delivered. ``` ### Localize a product catalog ``` Find Product entries with missing Spanish and Portuguese locales. Send the description and features to Ollang, then update and publish the translated entries when the orders complete. ``` ### Audit CMS localization ``` List content types and identify entries missing their required locales. Create an Ollang summary report and offer translation orders for the gaps. ``` # TikTok One Source: https://api-docs.ollang.com/mcp/integrations/tiktok-one Create Ollang subtitle and AI dubbing orders from TikTok One with the Ollang browser extension. # Ollang + TikTok One This integration uses the [Ollang browser extension](https://chromewebstore.google.com/detail/ollang/efohejcejhfnelejokbjcciochklibbl) and an Ollang API key. It does not use the Ollang MCP server. The Ollang browser extension adds localization controls to the TikTok One (CreativeOne) surface at `ads.tiktok.com`. It is also available for Firefox. ## Setup Install **Ollang** from the [Chrome Web Store](https://chromewebstore.google.com/detail/ollang/efohejcejhfnelejokbjcciochklibbl), or install the Firefox version. Open the extension popup and paste an Ollang API key. The extension validates the key against the Ollang integration API and stores it locally in your browser. Visit a campaign page on `ads.tiktok.com`. The extension detects the video asset already loaded on the campaign page. ## Create Orders The extension injects a floating **Localize with Ollang** button. Select it to open a panel with a short TikTok campaign summary containing the campaign name, brand, creative brief, and requirements, read from the campaign-detail data already loaded by the page. Choose: * **Source Language**, which defaults to `en` for subtitle orders * One or more target languages * An Ollang **Folder**, defaulting to **Default (API Uploads)** * Optional order metadata: **Jira ticket**, **PO number**, and **Job name** * **Subtitle** and/or **AI Dubbing** services Click **Create Orders** to submit the selected services. Target languages can be saved per folder in the browser with **Save languages for folder**. Subtitle orders are created without auto-QC; AI dubbing orders have auto-QC enabled. Extension-created orders use the same public integration API endpoint, `/integration/orders/create`, as other API-key orders. They appear in the Ollang dashboard and are available through the REST API and MCP like any other order. # Tridion Source: https://api-docs.ollang.com/mcp/integrations/tridion Create and monitor Ollang document translation orders from RWS Tridion Docs and InfoShare. # Ollang + Tridion This integration uses the [Ollang browser extension](https://chromewebstore.google.com/detail/ollang/efohejcejhfnelejokbjcciochklibbl) and an Ollang API key. It does not use the Ollang MCP server. The Ollang browser extension injects ordering and order-management UI into [RWS Tridion Docs and InfoShare](https://www.rws.com/localization/products/tridion/). It is also available for Firefox. ## Setup Install **Ollang** from the [Chrome Web Store](https://chromewebstore.google.com/detail/ollang/efohejcejhfnelejokbjcciochklibbl), or install the Firefox version. Open the extension popup and paste an Ollang API key. The extension validates the key against the Ollang integration API and stores it locally in your browser. Visit Tridion Docs or InfoShare on a supported host: `tridion.com`, `*.tridion.com`, `*.sdl.com`, or `*.sdlproducts.com`. ## Document Translation Select an XML/DITA item in a list view and start the **Document Translation** order flow. The source language defaults to `en`; choose the target language explicitly. The selected item is uploaded with a `.dita` filename. Document orders are created without auto-QC. Selecting a publication analyzes its publications and creates orders for the publication batch. ## Ollang Orders The extension adds an **Ollang Orders** tab to the Tridion SecondaryNav alongside the built-in tabs. It lists recent DITA and document orders with filters for: * Status: Completed, Ongoing, Pending, Delivered, Revision, and Waiting for approve * Languages * Search by document file name An order detail view includes the order overview (status, created date, order ID, and project ID), Tridion CM metadata (logical ID, object key, CM version, publication batch, source language, and job name), and the Tridion push state. If a push was skipped, the view shows the skip reason and offers retry. The detail view also includes reviewers and comments with **Approved** or **Request Edits** actions, plus the **Latest QC Evaluation**. Extension-created orders use the same public integration API endpoint, `/integration/orders/create`, as other API-key orders. They appear in the Ollang dashboard and are available through the REST API and MCP like any other order. # Vimeo Source: https://api-docs.ollang.com/mcp/integrations/vimeo Localize Vimeo video content with subtitle translation and AI dubbing using Ollang MCP. # Ollang MCP + Vimeo Vimeo operates this official MCP server, currently in public beta, separately from Ollang. Vimeo recommends Pro or above, with Enterprise providing the best results. Destructive actions such as deleting videos are intentionally not exposed. Use [Vimeo's official MCP server](https://developer.vimeo.com/api/mcp-server) with Ollang MCP to build video localization workflows. Clients that require SSE, such as ChatGPT, can use `https://mcp.vimeo.com/sse`; the recommended remote endpoint is `https://mcp.vimeo.com/mcp`. ## Why Vimeo + Ollang? Vimeo is a video hosting platform used for marketing, training, and product content. By connecting both servers, your AI assistant can: * Work with Vimeo video metadata and captions * Create subtitle or closed caption translation orders in Ollang * Upload localized captions back to Vimeo * Order AI dubbing for Vimeo-hosted videos ## Setup Add both remote servers through your MCP settings: ```json theme={null} { "mcpServers": { "ollang": { "url": "https://mcp.ollang.com/mcp" }, "vimeo": { "url": "https://mcp.vimeo.com/mcp" } } } ``` Authorize Vimeo over OAuth when prompted. ```bash theme={null} claude mcp add --transport http ollang https://mcp.ollang.com/mcp claude mcp add --transport http vimeo https://mcp.vimeo.com/mcp ``` ```json .cursor/mcp.json theme={null} { "mcpServers": { "ollang": { "url": "https://mcp.ollang.com/mcp" }, "vimeo": { "url": "https://mcp.vimeo.com/mcp" } } } ``` Add both remote servers in **Settings > Integrations > MCP Servers**: ```json theme={null} { "mcpServers": [ { "name": "ollang", "url": "https://mcp.ollang.com/mcp", "transport": "http" }, { "name": "vimeo", "url": "https://mcp.vimeo.com/mcp", "transport": "http" } ] } ``` ```json .replit-mcp.json theme={null} { "mcpServers": { "ollang": { "url": "https://mcp.ollang.com/mcp", "transport": "http" }, "vimeo": { "url": "https://mcp.vimeo.com/mcp", "transport": "http" } } } ``` Add both remote servers via **Settings > Integrations > MCP Servers**: ```json lovable.json theme={null} { "mcp": { "servers": { "ollang": { "url": "https://mcp.ollang.com/mcp", "transport": "http" }, "vimeo": { "url": "https://mcp.vimeo.com/mcp", "transport": "http" } } } } ``` The community [galacoder/vimeo-mcp](https://github.com/galacoder/vimeo-mcp) server remains a fallback for clients that only support stdio. ## Vimeo MCP Tools Use the hosted server's video, metadata, and caption capabilities to retrieve source material and publish localized assets. Vimeo intentionally does not expose destructive video deletion actions. ## Example Workflows ### Translate video subtitles ``` Find the Vimeo video "Product Demo", retrieve its English captions, send them to Ollang, and create subtitle orders for French, German, and Japanese. ``` ### Localize a training catalog ``` List my training videos and identify those without Spanish captions. For each one, create Ollang subtitle and AI dubbing orders using the Vimeo URL. ``` ### QC and publish captions ``` Retrieve the French captions for the onboarding video, run an Ollang QC evaluation for accuracy and fluency, and publish them to Vimeo only if the evaluation passes. ``` # Webflow Source: https://api-docs.ollang.com/mcp/integrations/webflow Localize Webflow site content with Webflow's official MCP server and Ollang. # Ollang MCP + Webflow Webflow operates the official MCP server separately from Ollang. OAuth authorizes access to selected sites and workspaces. Use [Webflow's official MCP server](https://developers.webflow.com/mcp/reference/getting-started) with Ollang MCP to localize site content and publishing workflows. ## Why Webflow + Ollang? By connecting Webflow and Ollang, your AI assistant can: * Work with content from selected Webflow sites * Send site copy to Ollang for translation * Prepare localized content for review * Keep multilingual site updates organized ## Setup The recommended Streamable HTTP endpoint is `https://mcp.webflow.com/mcp`. Published examples commonly use the SSE endpoint `https://mcp.webflow.com/sse`. For a stdio-only client, bridge the SSE endpoint with `npx mcp-remote https://mcp.webflow.com/sse`. ```json theme={null} { "mcpServers": { "ollang": { "url": "https://mcp.ollang.com/mcp" }, "webflow": { "url": "https://mcp.webflow.com/mcp" } } } ``` Authorize the selected Webflow sites and workspaces over OAuth. ```bash theme={null} claude mcp add --transport http ollang https://mcp.ollang.com/mcp claude mcp add --transport http webflow https://mcp.webflow.com/mcp ``` ```json .cursor/mcp.json theme={null} { "mcpServers": { "ollang": { "url": "https://mcp.ollang.com/mcp" }, "webflow": { "url": "https://mcp.webflow.com/mcp" } } } ``` Add both remote servers in **Settings > Integrations > MCP Servers**: ```json theme={null} { "mcpServers": [ { "name": "ollang", "url": "https://mcp.ollang.com/mcp", "transport": "http" }, { "name": "webflow", "url": "https://mcp.webflow.com/mcp", "transport": "http" } ] } ``` ```json .replit-mcp.json theme={null} { "mcpServers": { "ollang": { "url": "https://mcp.ollang.com/mcp", "transport": "http" }, "webflow": { "url": "https://mcp.webflow.com/mcp", "transport": "http" } } } ``` Add both remote servers via **Settings > Integrations > MCP Servers**: ```json lovable.json theme={null} { "mcp": { "servers": { "ollang": { "url": "https://mcp.ollang.com/mcp", "transport": "http" }, "webflow": { "url": "https://mcp.webflow.com/mcp", "transport": "http" } } } } ``` ## Webflow MCP Capabilities | Capability | Description | | - | - | | Site access | Authorize selected Webflow sites and workspaces | | Streamable HTTP | Connect through `https://mcp.webflow.com/mcp` | | SSE compatibility | Use `https://mcp.webflow.com/sse` where required | ## Example Workflows ### Localize Webflow site copy ``` Read the English copy from the selected Webflow marketing site, upload it to Ollang, and create French, German, and Spanish document translation orders. ``` ### Prepare an i18n launch ``` Find the product pages that need Japanese localization, create Ollang orders for their content, and summarize the source URLs and order IDs for the release checklist. ``` ### Review localized content ``` Compare the delivered French content from Ollang with the selected Webflow site copy, run a QC evaluation for accuracy and tone, and list any edits needed before publishing. ``` # YouTube Source: https://api-docs.ollang.com/mcp/integrations/youtube Translate YouTube video transcripts and captions using Ollang MCP with a community YouTube server. # Ollang MCP + YouTube YouTube and Google do not provide an official YouTube MCP server as of now. The community servers described here are not developed, maintained, or affiliated with Ollang or YouTube. Review their source code, permissions, and API-key handling before use. Use a [YouTube MCP Server](https://github.com/ZubeidHendricks/youtube-mcp-server) alongside Ollang MCP to extract video transcripts and create translation orders. [kirbah/mcp-youtube](https://github.com/kirbah/mcp-youtube) (`@kirbah/mcp-youtube`) is an actively maintained community alternative that wraps YouTube Data API v3 with a Google API key. ## Why YouTube + Ollang? YouTube is a video platform with a large catalog of content. By connecting a community YouTube server with Ollang MCP, your AI assistant can: * Extract transcripts from YouTube videos * Create subtitle and closed caption translation orders * Prepare multilingual channel content * Order AI dubbing for video URLs ## Setup The examples below use the existing community server. Replace it with `@kirbah/mcp-youtube` when that package better fits your client. ```json claude_desktop_config.json theme={null} { "mcpServers": { "ollang": { "url": "https://mcp.ollang.com/mcp" }, "youtube": { "command": "npx", "args": ["-y", "zubeid-youtube-mcp-server"], "env": { "YOUTUBE_API_KEY": "" } } } } ``` ```json .mcp.json theme={null} { "mcpServers": { "ollang": { "type": "http", "url": "https://mcp.ollang.com/mcp" }, "youtube": { "type": "stdio", "command": "npx", "args": ["-y", "zubeid-youtube-mcp-server"], "env": { "YOUTUBE_API_KEY": "${YOUTUBE_API_KEY}" } } } } ``` ```json .cursor/mcp.json theme={null} { "mcpServers": { "ollang": { "url": "https://mcp.ollang.com/mcp" }, "youtube": { "command": "npx", "args": ["-y", "zubeid-youtube-mcp-server"], "env": { "YOUTUBE_API_KEY": "${YOUTUBE_API_KEY}" } } } } ``` Add Ollang in **Settings > Integrations > MCP Servers** and run the community YouTube server in a compatible local environment: ```json theme={null} { "mcpServers": [ { "name": "ollang", "url": "https://mcp.ollang.com/mcp", "transport": "http" } ] } ``` Configure Ollang remotely and run the community server with its Google API key: ```json .replit-mcp.json theme={null} { "mcpServers": { "ollang": { "url": "https://mcp.ollang.com/mcp", "transport": "http" }, "youtube": { "command": "npx", "args": ["-y", "@kirbah/mcp-youtube"], "env": { "YOUTUBE_API_KEY": "${YOUTUBE_API_KEY}" } } } } ``` Add Ollang through **Settings > Integrations > MCP Servers**. The community YouTube server requires a client that can run stdio: ```json lovable.json theme={null} { "mcp": { "servers": { "ollang": { "url": "https://mcp.ollang.com/mcp", "transport": "http" }, "youtube": { "command": "npx", "args": ["-y", "@kirbah/mcp-youtube"], "env": { "YOUTUBE_API_KEY": "${YOUTUBE_API_KEY}" } } } } } ``` Create a Google API key with access to YouTube Data API v3. Never commit the key; use an environment variable such as `YOUTUBE_API_KEY`. ## YouTube MCP Tools | Tool | Description | | - | - | | `get_video_details` | Get video metadata and info | | `get_transcript` | Extract transcript with timestamps | | `search_videos` | Search YouTube for videos | | `get_channel_info` | Get channel details | ## Example Workflows ### Translate a video's captions ``` Get the transcript for https://youtube.com/watch?v=VIDEO_ID, upload it to Ollang, and create subtitle translation orders for Spanish, French, German, and Japanese. ``` ### Localize a playlist ``` List videos in the "Product Tutorials" playlist, extract each English transcript, and create Ollang subtitle orders for Portuguese and Korean. ``` ### Create AI dubbing ``` Get the details for the company overview video, upload the video URL to Ollang, and create AI dubbing orders for Spanish, French, and Arabic. ``` Community YouTube MCP servers provide access to video data and transcripts. Upload translated captions through YouTube Studio or the YouTube Data API directly. # Ollang MCP Source: https://api-docs.ollang.com/mcp/overview Connect AI assistants to Ollang's translation platform using the Model Context Protocol (MCP). # Ollang MCP Server The Ollang MCP Server brings the full power of Ollang's translation and localization platform directly into your AI-powered development environment. Using the [Model Context Protocol](https://modelcontextprotocol.io/), any compatible AI assistant can upload files, create translation orders, manage projects, and run quality checks — all through natural language. Ollang MCP is also available in Claude's [Connectors Directory](https://claude.ai/directory), so you can use it directly inside Claude.ai. Get up and running in under 5 minutes. Explore the full set of tools exposed by the MCP server. Combine Ollang MCP with Airtable, Notion, Figma, GitHub, Contentful, Webflow, and more, or use the Ollang extension with Tridion and TikTok One. See workflows with Cursor, Claude Code, Hermes Agent, Grok Build, OpenClaw, and more. ## What is MCP? The **Model Context Protocol (MCP)** is an open standard that lets AI assistants interact with external tools and services. Instead of copying and pasting between your AI assistant and the Ollang dashboard, MCP enables the assistant to call Ollang APIs directly on your behalf. Ollang MCP is hosted on Cloudflare Workers and supports both SSE and HTTP streaming transports. No local installation required for the remote server. ## What Can You Do? With Ollang MCP, your AI assistant can: * **Upload files** — Videos, documents, subtitles, JSON, and DITA files (JPEG, JPG, and PNG via Direct Upload for Image to Image translation). Files upload from a URL, or directly as base64-encoded content for smaller binary files * **Create translation orders** — Subtitles, closed captions, AI dubbing, studio dubbing, and document translation * **Manage orders** — Track status, cancel, rerun, and request human review * **Run QC evaluations** — AI-powered quality checks for accuracy, fluency, tone, and cultural fit * **Handle revisions** — Create, view, and delete revision requests * **Manage projects** — Browse and inspect all uploaded projects * **Custom instructions** — Create reusable translation guidelines * **Read subtitle files** — Parse SRT, VTT, ASS, and SSA formats from URLs ## Authentication Ollang MCP uses **OAuth 2.0 with PKCE** for secure authentication. When you connect for the first time, you'll be redirected to sign in with your Ollang account. The server handles token management automatically. Add the Ollang MCP server URL to your AI client configuration. Your AI client will open a browser window for Ollang sign-in (email OTP or Google/GitHub OAuth). Once authenticated, the full set of Ollang MCP tools becomes available to your AI assistant. ## Supported AI Clients Ollang MCP works with any MCP-compatible client, including: | Client | Transport | Setup Guide | | - | - | - | | Claude.ai | HTTP Streaming | [Guide](/mcp/use-cases/claude-ai) | | Claude Desktop | SSE / HTTP Streaming | [Guide](/mcp/use-cases/claude-desktop) | | Claude Code | HTTP Streaming / SSE | [Guide](/mcp/use-cases/claude-code) | | Cursor | SSE / HTTP Streaming | [Guide](/mcp/use-cases/cursor) | | Devin | SSE | [Guide](/mcp/use-cases/devin) | | Replit | SSE | [Guide](/mcp/use-cases/replit) | | Lovable | SSE | [Guide](/mcp/use-cases/lovable) | | Hermes Agent | HTTP Streaming | [Guide](/mcp/use-cases/hermes) | | Grok Build | HTTP Streaming | [Guide](/mcp/use-cases/grok-build) | | OpenClaw | HTTP Streaming | [Guide](/mcp/use-cases/openclaw) | | Windsurf | HTTP Streaming | [Guide](/mcp/quickstart#other-mcp-clients) | | VS Code (GitHub Copilot) | HTTP Streaming | [Guide](/mcp/quickstart#other-mcp-clients) | | Gemini CLI | HTTP Streaming | [Guide](/mcp/quickstart#other-mcp-clients) | | Codex CLI | HTTP Streaming | [Guide](/mcp/quickstart#other-mcp-clients) | | Cline (VS Code) | HTTP Streaming | [Guide](/mcp/quickstart#other-mcp-clients) | | Continue.dev | SSE | Compatible | ## Browser Extension Integrations The [Ollang browser extension](https://chromewebstore.google.com/detail/ollang/efohejcejhfnelejokbjcciochklibbl) adds ordering workflows to supported web apps. These integrations use an Ollang API key and the public integration API, not the Ollang MCP server. Create and monitor DITA and document translation orders from Tridion Docs and InfoShare. Create subtitle and AI dubbing orders from TikTok One campaign pages. ## Architecture ``` ┌─────────────────┐ MCP Protocol ┌──────────────────┐ REST API ┌─────────────┐ │ AI Assistant │ ◄──────────────────► │ Ollang MCP │ ◄──────────────► │ Ollang API │ │ (Claude, Cursor) │ SSE / HTTP Stream │ (Cloudflare) │ X-Api-Key │ (ollang.com)│ └─────────────────┘ └──────────────────┘ └─────────────┘ │ OAuth 2.0 + PKCE │ ┌────────────────┐ │ Stytch Auth │ └────────────────┘ ``` # Quick Start Source: https://api-docs.ollang.com/mcp/quickstart Get started with Ollang MCP in under 5 minutes. # Quick Start Connect your AI assistant to Ollang's translation platform in three steps. ## Prerequisites * An [Ollang account](https://lab.ollang.com) (free to sign up) * An MCP-compatible AI client (Claude Desktop, Claude Code, Cursor, Hermes Agent, Grok Build, or OpenClaw) ## Setup Open your Claude Desktop configuration file: ```bash macOS theme={null} open ~/Library/Application\ Support/Claude/claude_desktop_config.json ``` ```bash Windows theme={null} notepad %APPDATA%\Claude\claude_desktop_config.json ``` ```bash Linux theme={null} nano ~/.config/Claude/claude_desktop_config.json ``` Add the Ollang MCP server: ```json claude_desktop_config.json theme={null} { "mcpServers": { "ollang": { "url": "https://mcp.ollang.com/mcp" } } } ``` Restart Claude Desktop to apply the changes. Run the following command in your terminal: ```bash theme={null} claude mcp add ollang --transport http https://mcp.ollang.com/mcp ``` Or add it to your project's `.mcp.json`: ```json .mcp.json theme={null} { "mcpServers": { "ollang": { "type": "http", "url": "https://mcp.ollang.com/mcp" } } } ``` Open Claude's [Connectors Directory](https://claude.ai/directory), find **Ollang**, and enable it. You can also open **Customize → Connectors** in [Claude](https://claude.ai/customize/connectors). Complete the Ollang OAuth sign-in. Once enabled, select Ollang in the search-and-tools menu in a normal Claude chat. Open **Settings > Cursor Settings > Tools & MCP**, click **"New MCP Server"**, and add: ```json .cursor/mcp.json theme={null} { "mcpServers": { "ollang": { "url": "https://mcp.ollang.com/mcp" } } } ``` Add Ollang to `~/.hermes/config.yaml`: ```yaml ~/.hermes/config.yaml theme={null} mcp_servers: ollang: url: "https://mcp.ollang.com/mcp" auth: oauth ``` Use `/reload-mcp` after changing the configuration. Add Ollang to `~/.grok/config.toml`: ```toml ~/.grok/config.toml theme={null} [mcp_servers.ollang] url = "https://mcp.ollang.com/mcp" ``` Run `grok inspect` to confirm that Grok discovered the server. Add Ollang under `mcp.servers` in the OpenClaw JSON5 configuration: ```json5 theme={null} { mcp: { servers: { ollang: { url: "https://mcp.ollang.com/mcp", transport: "streamable-http", auth: "oauth" } } } } ``` Claude Code now recommends HTTP for remote MCP servers. SSE remains supported for clients that require it. ## Authenticate When your AI client first connects to the Ollang MCP server, it will open a browser window for authentication. Enter your email to receive a one-time code, or sign in with Google or GitHub. Grant the MCP server access to your Ollang account. The browser will confirm the connection. Return to your AI assistant — Ollang tools are now available. ## Your First Translation Try asking your AI assistant: ``` Upload this video from https://example.com/video.mp4 and create a subtitle translation order to French and Spanish. ``` The assistant will: 1. Call `uploadFile` to upload the video to Ollang 2. Call `createOrder` with subtitle type and French + Spanish targets 3. Return the order details and status ## Example Prompts ``` Upload my-document.pdf from Dropbox and translate it to German, Japanese, and Korean. ``` ``` Show me all my recent Ollang orders and their statuses. ``` ``` Run a QC evaluation on order #12345 checking accuracy and fluency. ``` ``` Create a custom instruction called "Tech Docs Style" that says: Use formal tone, keep technical terms in English, and use metric units. ``` ``` Download and read the subtitles from this VTT file URL and check for any issues. ``` ## Other MCP Clients Add Ollang to the global `~/.codeium/windsurf/mcp_config.json`: ```json theme={null} { "mcpServers": { "ollang": { "serverUrl": "https://mcp.ollang.com/mcp" } } } ``` Windsurf uses `serverUrl` for remote servers; a plain `url` is silently ignored. Windsurf is global-config only. Press **Refresh** in the MCP toolbar after editing. Add `.vscode/mcp.json`: ```json theme={null} { "servers": { "ollang": { "type": "http", "url": "https://mcp.ollang.com/mcp" } } } ``` Run **MCP: List Servers** from the Command Palette. Add Ollang under `mcpServers` in `settings.json`: ```json theme={null} { "mcpServers": { "ollang": { "httpUrl": "https://mcp.ollang.com/mcp" } } } ``` `httpUrl` is for Streamable HTTP; `url` is for SSE. When both are present, `httpUrl` takes precedence. Run: ```bash theme={null} codex mcp add ollang --url https://mcp.ollang.com/mcp ``` Add a remote server through Cline's MCP settings UI using: ``` https://mcp.ollang.com/mcp ``` ## Next Steps See the full list of available tools. Combine Ollang with Airtable, Notion, Vimeo, and more. # Available Tools Source: https://api-docs.ollang.com/mcp/tools Complete reference for the tools exposed by the Ollang MCP server. # MCP Tools Reference The Ollang MCP server exposes the following tools, grouped by category. Each tool maps to one or more endpoints in the [Ollang Integration API](/apis/ollang-api-reference/direct-file-upload) — MCP simply gives your AI assistant a natural-language interface to them. ## File Management Upload files for processing and translation. Supports videos (MP4, AVI, MOV), documents (PDF, DOCX), images in JPEG, JPG, or PNG for Image to Image translation, audio files, subtitles, JSON, and DITA/XML content. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `name` | string | Yes | File name (e.g., `video.mp4`, `document.pdf`) | | `sourceLanguage` | string | Yes | Source language code (e.g., `en`, `es`, `fr`) | | `url` | string | No | URL to download the file from (presigned URLs supported) — fetched server-side, so any file size the API accepts works | | `base64Content` | string | No | Base64-encoded binary file content (e.g., a local PDF or DOCX) — best for smaller files | | `expectedSize` | number | No | Expected decoded size in bytes of `base64Content`; the upload fails on mismatch | | `sha256` | string | No | Expected SHA-256 hex digest of the decoded `base64Content`; the upload fails on mismatch | | `content` | string | No | JSON content as a string (not for binary files — use `base64Content`) | | `ditaContent` | string | No | DITA/XML content as a string | | `notes` | array | No | Array of order notes with `details` and optional `timeStamp` | | `folderId` | string | No | Folder ID to place the project in (must belong to the same client) | Provide exactly one of `url`, `base64Content`, `content`, or `ditaContent` — one source per upload. Base64 payloads travel through the AI assistant's context, so prefer `url` for files larger than a few megabytes, and pass `expectedSize` and/or `sha256` with `base64Content` so uploads fail loudly if the data is corrupted in transit. Upload a VTT subtitle file for a project, from WebVTT content or a URL. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `projectId` | string | Yes | The project ID to upload the VTT file for | | `name` | string | Yes | Name of the VTT file (e.g., `subtitles.vtt`) | | `vttContent` | string | No | WebVTT content as a string (must start with the `WEBVTT` header) | | `url` | string | No | URL to download the VTT file from | | `sourceLanguage` | string | No | Source language code of the subtitles | Provide exactly one of `vttContent` or `url`. Start an upload session for binary files too large to send inline in one tool call. Returns an `uploadId` plus a direct PUT `uploadUrl` — the preferred path is to PUT the raw file bytes to that URL with any HTTP client, so the file never passes through the AI assistant's context. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `name` | string | Yes | Name of the file (e.g., `document.pdf`) | | `sourceLanguage` | string | Yes | Source language code (e.g., `en`) | | `expectedSize` | number | Yes | Exact file size in bytes — verified before upload | | `sha256` | string | No | SHA-256 hex digest of the file — verified before upload, strongly recommended | | `totalChunks` | number | No | Only for the base64-chunk fallback: number of pieces to send via `appendUploadChunk`. Omit when using the PUT `uploadUrl` | | `notes` | array | No | Array of order notes | | `folderId` | string | No | Folder ID to place the project in | Sessions expire after 60 minutes. As a fallback when no HTTP client is available, send the file's base64 in pieces with `appendUploadChunk`, then call `finalizeChunkedUpload`. Send one base64 piece of a chunked upload session (fallback path). Chunks are consecutive substrings of the file's full base64 string. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `uploadId` | string | Yes | Session ID from `beginChunkedUpload` | | `chunkIndex` | number | Yes | 0-based position of this chunk | | `base64Chunk` | string | Yes | Consecutive piece of the file's base64 string, at most 4000 characters | | `chunkLength` | number | Yes | Character count of `base64Chunk` — the call fails on mismatch, catching truncation immediately | Assemble all chunks of an upload session, verify integrity (size and optional SHA-256), and upload the file to Ollang. Returns the new `projectId`. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `uploadId` | string | Yes | Session ID from `beginChunkedUpload` | Discard a chunked upload session and its stored chunks without uploading. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `uploadId` | string | Yes | Session ID from `beginChunkedUpload` | ## Order Management Create a new translation or transcription order. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `projectId` | string | Yes | Project ID from a previous file upload | | `orderType` | string | Yes | One of: `cc`, `subtitle`, `document`, `aiDubbing`, `studioDubbing` | | `level` | number | Yes | `0` = full AI, `1` = AI + human review | | `targetLanguageConfigs` | array | Yes | Array of `{ language: string, isRush?: boolean }` — `language` is an Ollang language code | | `orderSubType` | string | No | `cc` orders only: `closedCaption` or `timecodedTranscription` | | `dubbingStyle` | string | No | Dubbing orders only: `overdub`, `lipsync`, or `audioDescription` | | `selectedMemories` | array | No | Up to 20 translation memory IDs to apply (from `getMemories`) | | `autoQc` | boolean | No | Run a QC evaluation automatically once the AI order completes | | `callbackUrl` | string | No | HTTPS URL POSTed when the order completes | | `aiResultsReadyCallbackUrl` | string | No | HTTPS URL POSTed when AI results are ready, before human review | | `humanReviewProgressCallbackUrl` | string | No | HTTPS URL POSTed with human-review progress updates | | `metadata` | object | No | Integration-specific metadata persisted on the order | `language` should be a code from the [supported-languages catalogue](/apis/ollang-api-reference/supported-languages) — pass the exact code returned by `getSupportedLanguages` or `validateLanguageTag` rather than guessing a region subtag (Brazilian Portuguese is `pt`, not `pt-BR`; `pt-PT` is Portugal). Ollang's API itself accepts any well-formed [BCP-47](/apis/ollang-api-reference/supported-languages#bcp-47-support) tag beyond the catalogue and falls back to the closest supported match (typically the primary language subtag) when a regional variant isn't directly recognized — catalogue codes are the ones with verified full provider coverage. `proofreading`, `revision` and `other` are legacy or system-generated order types. They may appear on existing orders and are accepted by the `getOllangOrders` `type` filter, but they cannot be created through this tool. Fetch orders with pagination, search, sorting, and filters. Each order includes its `overallQualityScore` when a QC evaluation has completed. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `page` | number | No | Page number (default: 1) | | `take` | number | No | Items per page (1–50, default: 10) | | `search` | string | No | Search query | | `orderBy` | string | No | Sort field (default: `id`) | | `orderDirection` | string | No | `asc` or `desc` (default: `desc`) | | `type` | string | No | Only return orders of this order type | | `name` | string | No | Filter by order name | | `createdFrom` | string | No | Only orders created on or after this ISO-8601 date/time | | `createdTo` | string | No | Only orders created on or before this ISO-8601 date/time | Get detailed information about a specific order including QC results. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `orderId` | string | Yes | The order ID | Cancel an existing order. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `orderId` | string | Yes | The order ID to cancel | Re-run an order to regenerate the translation with current AI models. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `orderId` | string | Yes | The order ID to rerun | Request subtitle embedding for an order to burn (hardcode) the translated subtitles directly into the video file. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `orderId` | string | Yes | The order ID to request subtitle embedding for | Export video timestamps, transcriptions, and translations for an order as an XLSX spreadsheet. Returns a short-lived download URL (expires after 60 minutes) — the file bytes never pass through the AI assistant's context. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `orderId` | string | Yes | The order ID to export | ## Quality Control Run an AI-powered quality control evaluation on an order. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `orderId` | string | Yes | The order ID to evaluate | | `accuracy` | boolean | No | Evaluate translation accuracy (default: true) | | `fluency` | boolean | No | Evaluate fluency in target language (default: true) | | `tone` | boolean | No | Evaluate tone and style (default: true) | | `culturalFit` | boolean | No | Evaluate cultural appropriateness (default: true) | | `customPrompt` | string | No | Custom evaluation instructions | | `callbackUrl` | string | No | HTTPS URL POSTed when the evaluation completes, with `orderId`, `evalId`, `status`, `textSummary`, `scores` and `segmentEvals` | Check whether an order is paused at a review gate, and if so which team tag owns it, the review type (`comment` or `assignment`), when it entered review, and who can review it. Use this when an order sits in the `review` status to find out who is blocking it. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `orderId` | string | Yes | The order ID to inspect | Escalate an order for manual review by a human translator. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `orderId` | string | Yes | The order ID | Cancel an active human review request. Reverts a Level 1 (Human Review) order back to Level 0 (AI-only), refunds the human review credits, and disconnects the assigned translator. Only Level 1 orders with status `ongoing` can be cancelled. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `orderId` | string | Yes | The order ID to cancel human review for | ## Revisions Report issues or request changes to delivered content. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `orderId` | string | Yes | The order ID | | `type` | string | Yes | Issue type: `missingSubtitle`, `wrongSubtitle`, `syncError`, `formatError`, `other` | | `time` | string | Yes | Timestamp where the issue occurs (format: `HH:MM:SS`) | | `description` | string | No | Detailed description of what needs correction | Retrieve all revision requests for an order. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `orderId` | string | Yes | The order ID | Delete a specific revision request. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `orderId` | string | Yes | The order ID | | `revisionId` | string | Yes | The revision ID to delete | ## Projects Retrieve all projects with pagination, search, and sorting. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `page` | number | No | Page number (default: 1) | | `take` | number | No | Items per page (1–50, default: 10) | | `search` | string | No | Search query | | `orderBy` | string | No | Sort field (default: `id`) | | `orderDirection` | string | No | `asc` or `desc` (default: `desc`) | Get detailed information about a specific project. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `projectId` | string | Yes | The project ID | ## Custom Instructions Retrieve all custom translation instructions for your account. **Parameters:** None Create a new reusable translation guideline. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `title` | string | Yes | Title of the instruction | | `content` | string | Yes | The guideline content | Update an existing custom instruction. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `instructionId` | string | Yes | The instruction ID | | `title` | string | No | New title | | `content` | string | No | New content | Delete a custom instruction permanently. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `instructionId` | string | Yes | The instruction ID | Retrieve suggested preset custom instructions (templates) to adopt or adapt as starting points for your own. **Parameters:** None ## Folders Retrieve all folders with pagination, search, and sorting. Folders organize projects — use a folder's ID as the `folderId` parameter of `uploadFile` or `beginChunkedUpload` to place new projects in it. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `page` | number | No | Page number (default: 1) | | `take` | number | No | Items per page (1–50, default: 10) | | `search` | string | No | Search query | | `orderBy` | string | No | Sort field (default: `id`) | | `orderDirection` | string | No | `asc` or `desc` (default: `desc`) | Get the distinct source/target language pairs from eligible orders in a folder. Use `status=unassigned` (default) for pairs available to assign to a translator, or `status=assigned` for pairs available to unassign. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `folderId` | string | Yes | The folder ID to inspect | | `status` | string | No | `unassigned` (default) or `assigned` | Batch assign a translator to all eligible (unassigned, completed) orders in a folder, optionally filtered by language pair. Returns the number of orders assigned. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `folderId` | string | Yes | The folder ID whose orders to assign | | `translatorId` | string | Yes | The translator ID to assign | | `deadline` | string | No | Deadline in ISO 8601 format | | `sourceLanguage` | string | No | Only assign orders with this source language | | `targetLanguage` | string | No | Only assign orders with this target language | Batch unassign the translator from all eligible (assigned, ongoing) orders in a folder, optionally filtered by language pair. Returns the number of orders unassigned. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `folderId` | string | Yes | The folder ID whose orders to unassign | | `sourceLanguage` | string | No | Only unassign orders with this source language | | `targetLanguage` | string | No | Only unassign orders with this target language | Bulk export orders in folders as a single XLSX file with one sheet per order/language combination. Returns a short-lived download URL (expires after 60 minutes) — the file bytes never pass through the AI assistant's context. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `folderIds` | array | Yes | Folder IDs containing the orders to export | | `targetLanguages` | array | Yes | Target language codes to include (e.g., `["tr", "en"]`) | ## Content Management Export content translations as JSON, filtered by target language(s), tag(s), and order ID(s). Single-language exports return a flat key-value map; multi-language exports return a map grouped by language code. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `targetLanguage` | string | No | Filter by a single target language code (e.g., `tr`) | | `targetLanguages` | array | No | Filter by multiple target language codes | | `tag` | string | No | Filter by a single tag | | `tags` | array | No | Filter by multiple tags | | `orderIds` | array | No | Filter by one or more order IDs | Import translation units (source + target text pairs) into your content database. Useful for bulk-loading translations from external systems or TMS exports. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `targetLanguage` | string | Yes | Target language code (e.g., `tr`, `en`, `de`) | | `translations` | array | Yes | Array of `{ sourceText, targetText, elementId?, type? }` | ## Translation Memory A translation memory stores previously approved source/target pairs and reuses them on new orders. Create one, fill it with `importMemoryItems`, then pass its ID as `selectedMemories` on `createOrder`. Only document, subtitle/cc and Adobe AE orders consume them. List all translation memories on the account, each with its stored translation-unit count. **Parameters:** none. Create an empty translation memory. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `title` | string | Yes | Human-readable name (e.g. `Product documentation EN-FR`) | Retrieve a single translation memory, including how many translation units it stores. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `memoryId` | string | Yes | The translation memory ID | Rename a translation memory. Stored translation units are untouched. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `memoryId` | string | Yes | The translation memory ID | | `title` | string | Yes | New name for the memory | Permanently delete a translation memory and every translation unit in it. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `memoryId` | string | Yes | The translation memory ID to delete | This cannot be undone. Queue translation units for import into a memory. The import runs asynchronously through the same pipeline as dashboard uploads, including the vectorization that makes units available to semantic matching. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `memoryId` | string | Yes | The memory to import into | | `items` | array | Yes | Array of `{ sourceLanguage, targetLanguage, sourceText, targetText }` | The API accepts up to 1000 units per request, but MCP transports also cap a single tool call's input — send a few hundred units per call and repeat for larger corpora. Poll `getMemoryImportJob` with the returned `jobId` for progress. Check the progress of an import job. Reports both the import status and the separate vectorization step. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `jobId` | string | Yes | The job ID returned by `importMemoryItems` | Imported units are only available to semantic matching once `vectorizationStatus` is `completed`. ## Billing and Credits Both tools require the signed-in Ollang account to have the owner or billing-manager role (`client_owner` / `client_accessBillings`); other accounts receive a 403. Ollang MCP authenticates through [OAuth](/mcp/overview#authentication), so this is a property of the account you signed in with — there is no API key to configure. Get the account's AI credit wallet: total, remaining, and used credits with their USD equivalents. Use this to check the balance before starting expensive work, or to explain an out-of-credits error. **Parameters:** none. List AI credit consumption line items (one row per provider run) — the same data as the dashboard Consumption Breakdown export. Each line includes `creditsUsed`, `usdEquivalent`, `provider`, `service`, the requestor and program tags. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `page` | number | No | Page number (default: 1) | | `take` | number | No | Items per page (1–50, default: 10) | | `orderBy` | string | No | Sort field (default: `id`) | | `orderDirection` | string | No | `asc` or `desc` (default: `desc`) | | `search` | string | No | Search by order name | | `from` | string | No | Include consumption from this date onward, inclusive (ISO-8601) | | `to` | string | No | Include consumption up to this date, inclusive (ISO-8601) | | `provider` | string | No | Filter by provider key (e.g. `openai`, `gemini`, `elevenlabs`) | | `orderType` | string | No | Filter by order type | | `createdBy` | string | No | Filter by requestor — a user ID or an email address | | `orderId` | string | No | Filter by a single order ID | | `tag` | string | No | Filter by a single program tag value | ## Languages List the languages Ollang supports, each with its regional variants. Use this to resolve a customer's wording ("Brazilian Portuguese") into the exact code `createOrder` expects — which is `pt`, since `pt-PT` is Portugal. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `search` | string | No | Search by name, native name, or code (minimum 2 characters, e.g. `portu`). Omit to list all primary languages | Check a language code against the platform catalogue. Returns whether it is accepted, its parsed language and region, and the reasons it failed. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `tag` | string | Yes | Language code to check (e.g. `pt`, `pt-PT`, `es-MX`, `zh-Hant`) | `createOrder`, `uploadFile`, and project creation expect a code from the [supported-languages catalogue](/apis/ollang-api-reference/supported-languages) for guaranteed full coverage — check here whenever a code is uncertain, especially before assuming a region subtag such as `pt-BR` exists. Ollang's API also accepts any well-formed [BCP-47](/apis/ollang-api-reference/supported-languages#bcp-47-support) tag beyond the catalogue, falling back to the closest supported match (typically the primary language subtag) when a regional variant isn't directly recognized. ## Utilities Check the health status of the Ollang API. **Parameters:** None Download and parse subtitle files from URLs. Supports SRT, VTT, ASS, and SSA formats. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `url` | string | Yes | URL of the subtitle file | | `format` | string | No | Format hint: `auto`, `srt`, `vtt`, `ass`, `ssa` (default: `auto`) | Download and parse JSON files from URLs. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `url` | string | Yes | URL of the JSON file | Download and parse DITA/XML documentation files from URLs. **Parameters:** | Name | Type | Required | Description | | - | - | - | - | | `url` | string | Yes | URL of the DITA file (.dita, .ditamap, or .ditaval) | # Claude.ai Source: https://api-docs.ollang.com/mcp/use-cases/claude-ai Use Ollang MCP directly in Claude.ai through Claude's Connectors Directory. # Ollang MCP in Claude.ai [Claude.ai](https://claude.ai) can use Ollang MCP directly through Claude's **Connectors Directory**, shared across Claude.ai, Claude Desktop, mobile, Claude Code, and Cowork. ## Setup Browse the [Connectors Directory](https://claude.ai/directory), or open **Customize → Connectors** in Claude at [claude.ai/customize/connectors](https://claude.ai/customize/connectors). Select **Connectors**, search for `Ollang`, and add the **Ollang** connector. Complete the Ollang OAuth sign-in and authorization flow when prompted. Open a normal Claude chat and select Ollang in the search-and-tools menu. Ollang tools are now available for translation and localization tasks. Ollang is listed as a community connector in the directory. Remote connectors are available on paid Claude plans: Pro, Max, Team, and Enterprise. ## Custom Connector Fallback If Ollang is not visible in the directory, add it manually from **Settings → Connectors → Add custom connector**: ``` https://mcp.ollang.com/mcp ``` Claude connectors run from Anthropic's cloud infrastructure rather than your device, which the publicly hosted Ollang MCP server supports. ## Use Cases ### Localize product copy ``` Read the product copy in this chat, send it to Ollang, and create French, German, and Japanese document translation orders. Preserve placeholders and return the order IDs. ``` ### Translate an i18n file ``` Use Ollang to translate the attached en.json locale file into Spanish and Portuguese. Keep interpolation variables unchanged and summarize the created orders. ``` ### Localize video content ``` Create Ollang subtitle and AI dubbing orders for this video URL in Spanish and French. Apply a custom instruction to keep product names in English and report the order status. ``` Once the connector is enabled, you can invoke Ollang from ordinary Claude chats without managing a local MCP configuration file. # Claude Code Source: https://api-docs.ollang.com/mcp/use-cases/claude-code Use Ollang MCP with Claude Code CLI for terminal-based translation workflows. # Ollang MCP in Claude Code [Claude Code](https://docs.anthropic.com/en/docs/claude-code) is Anthropic's agentic CLI tool. Ollang MCP integrates seamlessly, giving you translation capabilities right in your terminal. ## Setup ### Option 1: CLI command ```bash theme={null} claude mcp add ollang --transport http https://mcp.ollang.com/mcp ``` ### Option 2: Project configuration Create `.mcp.json` at your project root: ```json .mcp.json theme={null} { "mcpServers": { "ollang": { "type": "http", "url": "https://mcp.ollang.com/mcp" } } } ``` Commit `.mcp.json` to your repository so your entire team can use Ollang MCP. Use `${VARIABLE}` syntax for secrets to avoid hardcoding tokens. ### Option 3: Global configuration Add to `~/.claude.json` for access in all projects: ```json ~/.claude.json theme={null} { "mcpServers": { "ollang": { "type": "http", "url": "https://mcp.ollang.com/mcp" } } } ``` ## Authentication On first use, Claude Code will open a browser window for Ollang authentication. Sign in with your email (OTP), Google, or GitHub account. ## Use Cases ### Automate i18n in CI/CD pipelines Use Claude Code in scripts to manage translations as part of your build process: ```bash theme={null} claude -m "Upload src/locales/en.json to Ollang and create document translation orders for French (fr), German (de), and Japanese (ja). Return the order IDs." ``` ### Batch translate project files ``` Find all .json files in src/locales/en/ and upload each one to Ollang for translation to Spanish, French, and German. Track all order IDs. ``` ### Quality check translations ``` Get all my completed Ollang orders. For each one, run a QC evaluation checking accuracy and fluency. Summarize any issues found. ``` ### Subtitle workflow ``` Read the subtitle file at https://example.com/captions.vtt using Ollang's subtitle parser. Create a subtitle translation order for Arabic, Hindi, and Chinese. ``` ### Manage custom instructions ``` List all my Ollang custom instructions. Update the "Marketing Copy" instruction to add: "Always use metric units for European markets." ``` ## Configuration Scopes Claude Code supports three configuration levels: | Scope | File | Use Case | | - | - | - | | Project (shared) | `.mcp.json` | Commit to repo, shared with team | | User (global) | `~/.claude.json` | Personal tools, all projects | | Local (private) | `.claude/settings.json` | Project-specific overrides | **Priority:** Local > Project > User ## Multi-Server Example ```json .mcp.json theme={null} { "mcpServers": { "ollang": { "type": "http", "url": "https://mcp.ollang.com/mcp" }, "dropbox": { "type": "http", "url": "https://mcp.dropbox.com/mcp" }, "airtable": { "type": "http", "url": "https://mcp.airtable.com/mcp" } } } ``` HTTP is the recommended Claude Code transport. SSE is still supported for clients that require it. # Claude Desktop Source: https://api-docs.ollang.com/mcp/use-cases/claude-desktop Use Ollang MCP with Claude Desktop for conversational translation management. # Ollang MCP in Claude Desktop [Claude Desktop](https://claude.ai/download) is Anthropic's desktop application for conversing with Claude. With Ollang MCP, you can manage your entire translation workflow through natural conversation. ## Setup ```bash macOS theme={null} ~/Library/Application Support/Claude/claude_desktop_config.json ``` ```bash Windows theme={null} %APPDATA%\Claude\claude_desktop_config.json ``` ```bash Linux theme={null} ~/.config/Claude/claude_desktop_config.json ``` ```json claude_desktop_config.json theme={null} { "mcpServers": { "ollang": { "url": "https://mcp.ollang.com/mcp" } } } ``` Quit and reopen Claude Desktop. You should see the Ollang tools available in the MCP tools menu (hammer icon). On first tool use, a browser window opens for Ollang sign-in. Complete authentication and return to Claude. ## Use Cases ### Conversational translation management Claude Desktop is ideal for managing translations through natural language: ``` What's the status of all my translation orders? Show me any that are completed and ready for download. ``` ### Upload and translate files ``` Upload this video from https://example.com/training-video.mp4 with source language English. Then create subtitle translation orders for French, Spanish, German, Italian, and Portuguese. ``` ### Review and iterate on translations ``` Get the details for order #12345. Run a QC evaluation checking accuracy, fluency, and tone. If there are issues with the French translation at timestamp 02:15:30, create a revision request. ``` ### Project overview ``` Show me all my Ollang projects. For the "Marketing Q1" project, list all associated orders and their current statuses. ``` ### Translation guidelines ``` Create a custom instruction called "Legal Documents" with the following guidelines: "Use formal register. Preserve legal terminology in the source language with translations in parentheses. Do not simplify complex sentence structures." ``` ## Adding More MCP Servers Extend your Claude Desktop with additional integrations: ```json claude_desktop_config.json theme={null} { "mcpServers": { "ollang": { "url": "https://mcp.ollang.com/mcp" }, "notion": { "command": "npx", "args": ["-y", "@notionhq/notion-mcp-server"], "env": { "NOTION_TOKEN": "ntn_XXXX" } }, "dropbox": { "url": "https://mcp.dropbox.com/mcp" } } } ``` Claude Desktop shows a hammer icon in the chat input when MCP tools are available. Click it to see all connected tools and their descriptions. # Cursor Source: https://api-docs.ollang.com/mcp/use-cases/cursor Use Ollang MCP inside Cursor IDE to translate content while you code. # Ollang MCP in Cursor [Cursor](https://cursor.com) is an AI-powered code editor built on VS Code. With Ollang MCP, you can manage translations directly from your development environment. ## Setup Go to **Settings > Cursor Settings > Tools & MCP** and click **"New MCP Server"**. Create or edit `.cursor/mcp.json` in your project root: ```json .cursor/mcp.json theme={null} { "mcpServers": { "ollang": { "url": "https://mcp.ollang.com/mcp" } } } ``` When Cursor connects to the server, a browser window opens for Ollang sign-in. Complete the authentication and return to Cursor. Open Cursor's AI chat (Cmd+L / Ctrl+L) and start asking about translations. ## Use Cases ### Localize i18n files during development When working on an internationalized app, you can translate JSON locale files on the fly: ``` Upload my en.json locale file to Ollang and create document translation orders for fr.json, de.json, and ja.json. Use the source language "en". ``` ### Translate code documentation ``` Take the JSDoc comments from src/api/client.ts, upload them to Ollang for document translation to Spanish, and show me the translated text. ``` ### Manage translation orders from your editor ``` Show me all my Ollang orders from the last week. Which ones are still in progress? ``` ### Create translation guidelines for your project ``` Create a custom instruction in Ollang called "Mobile App UI" with content: "Keep strings short for mobile screens. Use informal tone. Translate UI abbreviations contextually. Keep brand names in English." ``` ## Multi-Server Configuration Combine Ollang with other MCP servers for powerful workflows: ```json .cursor/mcp.json theme={null} { "mcpServers": { "ollang": { "url": "https://mcp.ollang.com/mcp" }, "notion": { "command": "npx", "args": ["-y", "@notionhq/notion-mcp-server"], "env": { "NOTION_TOKEN": "ntn_XXXX" } } } } ``` Cursor supports both project-scoped (`.cursor/mcp.json`) and global (`~/.cursor/mcp.json`) MCP configurations. Use project-scoped for team projects and global for personal tools. # Devin Source: https://api-docs.ollang.com/mcp/use-cases/devin Use Ollang MCP inside Devin, the autonomous AI software engineer, to manage translations as part of your development workflows. # Ollang MCP in Devin [Devin](https://devin.ai) is an autonomous AI software engineer by Cognition. With Ollang MCP, Devin can handle localization and translation tasks as part of its agentic coding workflows — no human intervention required. ## Setup Go to [app.devin.ai](https://app.devin.ai) and navigate to **Settings > Integrations > MCP Servers**. Click **"Add MCP Server"** and enter the following configuration: ```json theme={null} { "name": "ollang", "url": "https://mcp.ollang.com/mcp", "transport": "sse" } ``` Once connected, Devin will prompt for Ollang authentication during the first tool use. Complete the OAuth sign-in flow in your browser and return to Devin. In any Devin session, you can now delegate translation tasks directly. Devin will use Ollang MCP tools autonomously to complete them. ## Use Cases ### Automate i18n file translation during development Devin can manage your entire localization pipeline end-to-end: ``` In the repo, find all JSON locale files under src/locales/en/. Upload each file to Ollang and create document translation orders for French (fr), German (de), Spanish (es), and Japanese (ja). Save the returned order IDs to a file called localization-orders.json. ``` ### Translate code comments and documentation ``` Go through all TypeScript files in src/lib/. Extract all JSDoc comment blocks, upload them as a document to Ollang for translation to Arabic, then create a new file src/lib/docs-ar.md with the translated comments. ``` ### Monitor and download completed translations ``` Check the status of all Ollang orders listed in localization-orders.json. For any orders that are completed, download the translated files and place them in the correct src/locales/{lang}/ directories. ``` ### Integrate translation into CI workflows Devin can be used as part of automated pipelines. Example task: ``` When a new locale string is added to en.json, automatically create Ollang translation orders for all supported languages, wait for completion, and open a pull request with the translated locale files. ``` ## Multi-Server Configuration Combine Ollang with other MCP servers in Devin's settings for richer workflows: ```json theme={null} { "mcpServers": [ { "name": "ollang", "url": "https://mcp.ollang.com/mcp", "transport": "sse" }, { "name": "github", "url": "https://api.githubcopilot.com/mcp/", "transport": "sse" } ] } ``` Devin works best with Ollang when given clear success criteria — for example, "create orders and confirm order IDs are returned" rather than open-ended tasks. This helps Devin verify completion autonomously. # Grok Build Source: https://api-docs.ollang.com/mcp/use-cases/grok-build Use Ollang MCP from xAI's Grok Build terminal coding agent. # Ollang MCP in Grok Build [Grok Build](https://docs.x.ai/build/overview) is xAI's terminal coding agent, available through the `grok` CLI. With Ollang MCP, Grok can make localization part of development, release, and CI workflows. ## Setup Install the CLI: ```bash theme={null} curl -fsSL https://x.ai/cli/install.sh | bash ``` Grok Build requires SuperGrok or X Premium Plus. Create or edit the user-scope `~/.grok/config.toml`: ```toml ~/.grok/config.toml theme={null} [mcp_servers.ollang] url = "https://mcp.ollang.com/mcp" ``` The remote server also supports `headers` and `bearer_token_env_var` when your setup requires them. You can set common options such as `enabled`, `startup_timeout_sec`, `tool_timeout_sec`, and `tool_timeouts`. Run `grok inspect` to see the configuration sources and discovered MCP servers. On first use, Grok opens the Ollang OAuth 2.0 + PKCE sign-in flow in your browser. Ask Grok to use Ollang from an interactive session, or use `-p` for a headless script or CI job. ## Use Cases ### Keep locale files in sync ``` Compare src/i18n/en-US.json with the existing locale files. For every missing string, create an Ollang document translation order for fr-FR and ko-KR. Preserve ICU placeholders and report the order IDs in the pull request summary. ``` ### Localize a product launch video ``` Use Ollang to create subtitle orders for https://example.com/launch.mp4 in Spanish, French, and Italian, then create AI dubbing orders for Spanish and French. Apply the "Product Launch" custom instruction and show me the source and target languages for each order. ``` ### Make localization CI-friendly ``` In headless mode, check Ollang orders from localization-orders.json. For completed orders, download the translated files into the matching locale directories. If an order failed, report it without changing the repository. ``` Project-level `.grok/config.toml` files can contribute `[mcp_servers]`, `[plugins]`, and `[permission]` settings. Keep shared Ollang configuration in user scope when you want it available across projects, and use `grok inspect` before troubleshooting discovery. # Hermes Agent Source: https://api-docs.ollang.com/mcp/use-cases/hermes Use Ollang MCP from Nous Research's Hermes Agent for localization and translation workflows. # Ollang MCP in Hermes Agent [Hermes Agent](https://hermes-agent.nousresearch.com/) is an open-source agent from Nous Research. With Ollang MCP, Hermes can manage localization work and translation orders from a terminal-based workflow. ## Setup Install Hermes Agent using the standard installation instructions. MCP support ships with the standard install. Edit `~/.hermes/config.yaml` and add Ollang under `mcp_servers`: ```yaml ~/.hermes/config.yaml theme={null} mcp_servers: ollang: url: "https://mcp.ollang.com/mcp" auth: oauth ``` Start Hermes and make a request that uses Ollang. On the first connection, Hermes opens a browser for the remote OAuth flow. Complete Ollang sign-in and return to Hermes. After editing the configuration, run `/reload-mcp` in Hermes. You can restrict the server to selected tools with `tools: { include: [...] }`. ## Use Cases ### Localize an application release ``` Find the English JSON locale files in src/locales/en. Upload them to Ollang and create document translation orders for French, German, and Japanese. Use the "Mobile App UI" custom instruction: keep labels concise, preserve placeholders, and leave product names untranslated. Return the order IDs. ``` ### Prepare subtitles and dubbing for a video ``` Create Ollang subtitle and AI dubbing orders for the video at https://example.com/video.mp4. Use English as the source language and Spanish and Portuguese as targets. Report the order status and any available delivery files. ``` ### Run a focused quality check ``` Find my recently completed French subtitle orders in Ollang. Run QC evaluations for accuracy and fluency, summarize the scores, and flag any order below the quality threshold. ``` Hermes can migrate MCP servers from Claude Code with `hermes import-agent claude-code`, which reads `~/.claude.json` and its `mcpServers` configuration. Use the per-server `tools` filter when a Hermes workflow only needs a small part of Ollang. # Lovable Source: https://api-docs.ollang.com/mcp/use-cases/lovable Use Ollang MCP inside Lovable to translate and localize your AI-built web applications. # Ollang MCP in Lovable [Lovable](https://lovable.dev) is an AI-powered full-stack web app builder. With Ollang MCP, Lovable's AI agent can manage translations and localization directly within your app-building workflow — making it easy to ship multilingual products from day one. ## Setup Go to [lovable.dev](https://lovable.dev) and open your project. Navigate to **Settings > Integrations > MCP Servers**. Click **"Connect MCP Server"** and enter the Ollang server URL: ``` https://mcp.ollang.com/mcp ``` Or add it via the project configuration file: ```json lovable.json theme={null} { "mcp": { "servers": { "ollang": { "url": "https://mcp.ollang.com/mcp", "transport": "sse" } } } } ``` Lovable will open an Ollang sign-in page for OAuth authentication. Sign in with your email (OTP), Google, or GitHub account. In the Lovable AI chat, describe your translation needs. Lovable will call Ollang MCP tools to complete the task. ## Use Cases ### Translate your app's UI strings While building a web app in Lovable, localize it for global audiences: ``` My app currently has all UI strings in English in src/i18n/en.json. Upload that file to Ollang and create translation orders for French, Spanish, German, and Arabic. Once done, add the translated files to the project and wire them up with i18next. ``` ### Translate landing page content ``` Take the hero section copy and all marketing text from the landing page component. Upload it to Ollang for document translation into Portuguese and Italian. Apply the translated text to new locale versions of the page. ``` ### Set up translation guidelines for consistent brand voice ``` Create an Ollang custom instruction called "SaaS App UI" with the following guidelines: "Use second-person (you/your). Keep button labels under 3 words. Translate error messages clearly and avoid technical jargon. Keep brand name 'Lovable' in English." ``` ### Track and download completed translations ``` Check all my Ollang translation orders. For any that are complete, download the translated files and place them in src/i18n/{lang}.json with the correct locale codes. ``` ## Multi-Server Configuration Combine Ollang with other integrations in Lovable for end-to-end workflows: ```json lovable.json theme={null} { "mcp": { "servers": { "ollang": { "url": "https://mcp.ollang.com/mcp", "transport": "sse" }, "supabase": { "url": "https://mcp.supabase.com/sse", "transport": "sse" } } } } ``` Lovable works best with Ollang when you specify the target languages upfront. Example: "translate to French (`fr`), Spanish (`es`), and German (`de`)" — matching Ollang's [supported language codes](/apis/ollang-api-reference/supported-languages) avoids ambiguity when a language has multiple regional variants (e.g. `es` vs `es-MX`, `fr` vs `fr-CA`). Ollang also accepts other well-formed BCP-47 tags beyond the catalogue, falling back to the closest supported match (usually the primary language) when a specific regional variant isn't directly recognized. # OpenClaw Source: https://api-docs.ollang.com/mcp/use-cases/openclaw Connect OpenClaw chat channels to Ollang for conversational translation order workflows. # Ollang MCP in OpenClaw [OpenClaw](https://openclaw.ai) is an open-source, self-hosted personal-assistant gateway. It connects channels such as Slack, Telegram, WhatsApp, Discord, iMessage, Signal, and Teams to agents that can use Ollang for localization operations. ## Setup Add a remote server under `mcp.servers` in the OpenClaw JSON5 configuration: ```json5 theme={null} { mcp: { servers: { ollang: { url: "https://mcp.ollang.com/mcp", transport: "streamable-http", auth: "oauth" } } } } ``` Instead of editing the configuration by hand, add the server with the OpenClaw MCP command: ```bash theme={null} openclaw mcp add ollang \ --url https://mcp.ollang.com/mcp \ --transport streamable-http \ --auth oauth ``` Run `openclaw mcp login ollang`, or let the first connection open the browser-based OAuth 2.0 + PKCE flow. Complete Ollang sign-in and return to OpenClaw. Use `openclaw mcp list`, `openclaw mcp tools ollang`, or `openclaw mcp probe ollang` to inspect the server. The browser Control UI also exposes MCP settings at `/settings/mcp`. Use `openclaw mcp reload` after changing configuration. OpenClaw also provides `mcp add`, `mcp set`, and `mcp doctor` for managing and diagnosing servers. ## Use Cases ### Check orders from a chat channel ``` From this WhatsApp conversation, check my Ollang orders from the last seven days. Group them by status and tell me which subtitle, dubbing, or document deliveries need attention. ``` ### Send proactive completion notifications ``` Schedule a daily Ollang check. When an order for the folder "Campaign Assets" becomes completed, notify the localization team in Slack with the order ID, target languages, and delivered file links. Do not notify for orders that were already reported. ``` ### Start localization conversationally ``` Create an Ollang subtitle order for https://example.com/episode.mp4 from English to Spanish and Japanese, and an AI dubbing order to Spanish. Use the "Streaming Series" custom instruction and report the order IDs here. ``` ### Review a translation from a team channel ``` Find the completed French document order for the latest i18n release, download its deliverable, and run a QC evaluation for accuracy and fluency. Summarize the result in this channel and mention any revisions that should be requested. ``` OpenClaw's differentiator is access from the channels where teams already work: use scheduled checks, chat commands, and proactive notifications to keep Ollang orders visible without opening the dashboard. # Replit Source: https://api-docs.ollang.com/mcp/use-cases/replit Use Ollang MCP inside Replit Agent to handle translations directly within your cloud development environment. # Ollang MCP in Replit [Replit](https://replit.com) is a cloud-based IDE with an AI Agent that can build, run, and iterate on code autonomously. With Ollang MCP, Replit Agent gains translation capabilities — enabling localization workflows without leaving your development environment. ## Setup Go to [replit.com](https://replit.com) and open the project where you want to use Ollang MCP. In your project's `.replit` file, add an `[mcp]` section with the Ollang server: ```toml .replit theme={null} [mcp.servers.ollang] url = "https://mcp.ollang.com/mcp" transport = "sse" ``` Alternatively, create a `.replit-mcp.json` file at the project root: ```json .replit-mcp.json theme={null} { "mcpServers": { "ollang": { "url": "https://mcp.ollang.com/mcp", "transport": "sse" } } } ``` When Replit Agent first uses an Ollang tool, you will be prompted to authenticate. A browser tab will open for Ollang sign-in. Complete authentication and return to Replit. Open the **Agent** tab in Replit and describe your translation task. The agent will use Ollang MCP tools automatically. ## Use Cases ### Localize your app during prototyping While building an app in Replit, translate your UI strings on the fly: ``` Read the file src/i18n/en.json and upload it to Ollang. Create document translation orders for French, Spanish, and Portuguese. Once complete, save the translated files as fr.json, es.json, and pt.json in the same directory. ``` ### Translate README and documentation ``` Take the content of README.md and upload it to Ollang for document translation into Spanish and French. Save the results as README.es.md and README.fr.md. ``` ### Build a multilingual app faster ``` I'm building a language-learning app. Create an Ollang custom instruction called "Language Learning UI" with the guideline: "Use simple, clear language. Avoid idioms. Prefer formal register." Then use it to translate all strings in src/locales/en.json to Arabic, Chinese, and Hindi. ``` ### Check the status of ongoing translation orders ``` List all my current Ollang orders. Show me which ones are completed and which are still in progress. ``` ## Multi-Server Configuration Use Ollang alongside other tools in Replit Agent: ```json .replit-mcp.json theme={null} { "mcpServers": { "ollang": { "url": "https://mcp.ollang.com/mcp", "transport": "sse" }, "notion": { "command": "npx", "args": ["-y", "@notionhq/notion-mcp-server"], "env": { "NOTION_TOKEN": "${NOTION_TOKEN}" } } } } ``` Store API tokens as Replit **Secrets** (not hardcoded values) and reference them with `${SECRET_NAME}` in your MCP config. This keeps credentials secure across forks and collaborators. # Memory, Guidelines, and Custom Instructions Source: https://api-docs.ollang.com/memory-guidelines-custom-instructions Understand Memories, terminology management, custom instructions, folder-level guidelines, and project-level localization behavior inside the Ollang Project Management Dashboard. ## Overview The Ollang Project Management Dashboard supports three different mechanisms to improve localization quality and consistency: * Memories * Global Custom Instructions * Folder-Level and Project-Level Guidelines These systems work together to help organizations: * preserve terminology consistency, * maintain brand voice, * improve translation quality, * standardize localization behavior, * and operationalize multilingual content at scale. Each mechanism serves a different purpose. *** # Understanding the Difference Stores historical translations, approved terminology, and multilingual reference content. Global account-level guidance applied when no folder or project guidelines exist. Folder-level or Project-level instructions controlling localization behavior for specific workflows. *** # Memories ## Overview Memories help organizations preserve: * approved terminology, * historical translations, * brand language, * multilingual consistency, * and localization context. Instead of translating every Order from scratch: Ollang can reference previously approved linguistic material to improve translation consistency. This is especially important for: * enterprise localization, * recurring content, * regulated industries, * product localization, * media localization, * and brand-sensitive workflows. *** # How Memories Work Memories act as: * multilingual contextual references. Organizations can upload previously approved translation material which can then help guide future localization workflows. Example: ```text theme={null} Source: "Get Started" Approved Translation: "Commencer" ``` Future Orders involving similar content may reference this approved terminology. *** # Creating a Memory Project Management Users can create Memories directly from: * the Memories section inside: * the Ollang Project Management Dashboard. Memories can also be managed programmatically through the public API: create, rename, and delete memories, and import translation units into them. See [List Memories](/apis/ollang-api-reference/list-memories), [Create Memory](/apis/ollang-api-reference/create-memory), and [Import Memory Items](/apis/ollang-api-reference/import-memory-items). Workflow: ```text theme={null} Go to Memories ↓ Create New Memory ↓ Add Title ↓ Upload File ↓ Memory Becomes Available ``` Example: ```text theme={null} Memory Name: Brand Localization Glossary ``` *** # Multiple Memories Organizations are not limited to: * a single Memory. Users may create: * multiple Memories, * multiple terminology repositories, * and specialized localization references. Example: ```text theme={null} Memories - Brand Terminology - Legal Terminology - Medical Translation Memory - Product Localization Terms - UI Localization Memory ``` This enables: * department-specific localization, * content-type specialization, * and multilingual operational consistency. *** # Supported Memory Formats The platform currently supports: Translation Memory Exchange format commonly used in enterprise localization. Spreadsheet-based terminology and translation reference format. Structured terminology and multilingual reference files. Structured localization and multilingual data workflows. *** # Memory Matching Behavior Memories function as: * contextual linguistic guidance. When matching content: ```text theme={null} 100% Exact Match ↓ High-priority reference ``` ```text theme={null} Semantic Similarity ↓ Contextual localization guidance ``` This helps preserve: * consistency, * terminology quality, * and multilingual continuity. For the exact definitions of a full (exact) match, a fuzzy match, and how they feed the translation readiness score, see [Translation Readiness, Matching, and Context Assets](/translation-readiness-context-matching). *** # Where Memory Matches Are Shown Memory match visibility depends on context management being enabled for your workspace. Contact your Ollang account manager if you do not see the cards described below. With context management enabled, Project Management users can see: * **before the Order** — TM exact and TM fuzzy coverage on the [Translation readiness](/translation-readiness-context-matching#translation-readiness-score) card of the New Order form, * **after the Order** — which Memory (name and version) was used, how many segments it grounded, and the per-segment match evidence on the [Assets utilized](/translation-readiness-context-matching#assets-utilized) card of the Order details page. *** # Global Custom Instructions ## Overview Global Custom Instructions represent: * organization-wide localization guidance. These instructions are automatically applied when: * no Folder-level guideline exists, * and no Project-level guideline exists. Global Custom Instructions act as: * fallback localization behavior. *** # Typical Use Cases Global Custom Instructions are commonly used for: * brand tone, * writing style, * terminology preferences, * localization behavior, * and organization-wide standards. Example: ```text theme={null} Instructions: - Maintain professional tone - Keep product names untranslated - Avoid slang - Preserve English UI terminology ``` *** # Important Behavior Global Custom Instructions only apply when no Folder-level or Project-level Guidelines are configured. Hierarchy: ```text theme={null} Project-Level Guidelines ↓ Folder-Level Guidelines ↓ Global Custom Instructions ``` *** # Folder-Level Guidelines ## Overview Folder-Level Guidelines represent: * instructions uploaded to a specific Folder. These guidelines automatically apply to: * all Projects, * and all Orders inside that Folder. Unless: * a Project-level Guideline exists. *** # Example Use Case Example: ```text theme={null} Folder: French TV Series Guideline: - Formal French tone - Max subtitle length: 42 CPL - Preserve character naming - Avoid subtitle orphan words ``` All Projects inside the Folder inherit: * the same localization behavior. *** # Folder-Level Workflow ```text theme={null} Folder Guideline Uploaded ↓ Projects Created Inside Folder ↓ Orders Automatically Follow Folder Rules ``` *** # Managing Folder Guidelines Through the API Folder-level documents can also be managed programmatically, without the dashboard: * [List Folder Documents](/apis/ollang-api-reference/list-folder-documents) — `GET /integration/folder/{folderId}/docs` * [Attach Folder Document](/apis/ollang-api-reference/attach-folder-document) — `POST /integration/folder/{folderId}/docs` (by URL) * [Upload Folder Document](/apis/ollang-api-reference/upload-folder-document) — `POST /integration/folder/{folderId}/docs/upload` (the file itself, as `multipart/form-data`) * [Remove Folder Document](/apis/ollang-api-reference/delete-folder-document) — `DELETE /integration/folder/{folderId}/docs/{docId}` The three folder-level document types are `guideline`, `guideline_glossary`, and `character_list`. Documents attached through the API behave exactly as those uploaded in the dashboard: they apply to every project already in the folder and to projects created in it afterwards, including projects created through [Direct File Upload](/apis/ollang-api-reference/direct-file-upload). Removing a document detaches it from those projects as well. *** # Project-Level Guidelines ## Overview Project-Level Guidelines represent: * highly specific instructions uploaded to a particular Project. These Guidelines override: * Folder-Level Guidelines, * and Global Custom Instructions. Project-level guidance is used when: * one Project requires unique localization behavior. *** # Example Use Case Example: ```text theme={null} Folder: TV Show Season Folder Guideline: - Maintain neutral tone - Follow subtitle formatting Project: Episode 5 Project-Level Guideline: - Preserve slang - Use regional humor adaptation - Character-specific naming rules ``` Result: ```text theme={null} Episode 5 follows Project-Level Guideline ``` while: ```text theme={null} All other Episodes follow Folder-Level Guideline ``` *** # Override Hierarchy Guidelines are not merged. Only the highest-priority applicable guideline is used. Hierarchy: ```text theme={null} Project-Level Guidelines ↓ Folder-Level Guidelines ↓ Global Custom Instructions ``` Meaning: ### If Project Guideline exists: * Project Guideline is used. ### If Project Guideline does not exist: * Folder Guideline is used. ### If Folder Guideline does not exist: * Global Custom Instructions are used. *** # Supported Guideline Formats Guidelines may be uploaded in formats such as: Commonly used for localization instructions and style guides. Commonly used for structured guideline documentation. Lightweight instruction format for localization guidance. Structured terminology or instruction reference sheets. *** # Example Enterprise Localization Setup ```text theme={null} Global Custom Instructions ↓ Professional tone Keep UI terms in English Avoid slang Folder: Marketing Campaigns ↓ Friendly tone Modern language Short-form copy Project: Holiday Campaign ↓ Preserve seasonal references Follow regional promotions ``` Result: ```text theme={null} Holiday Campaign uses: Project-Level Guideline ``` *** # Memory vs Guidelines Helps preserve historical translations, terminology consistency, and multilingual reference material. Controls how localization should behave for a specific workflow or Project. # Best Practices Organizations typically achieve best results by combining: ```text theme={null} Memory + Guidelines + Custom Instructions ``` Example: ```text theme={null} Memory: Preserve approved terminology Folder Guideline: Maintain subtitle formatting Project Guideline: Use campaign-specific language ``` This helps improve: * consistency, * translation quality, * brand alignment, * and multilingual scalability. # Important Operational Notes Yes. Organizations can create multiple Memories for different content types, departments, or terminology domains. Memories are global and available organization-wide. Yes. Project-Level Guidelines always override Folder-Level Guidelines. No. Only the highest-priority applicable guideline is used. Not currently. Visibility into Memory source attribution is part of the future roadmap. The platform automatically applies active Global Custom Instructions. # Order Types and Workflow Architecture Source: https://api-docs.ollang.com/order-types-workflows Understand how AI Dubbing, Subtitle Translation, Video Captioning, Document Translation, and Studio Dubbing workflows operate inside the Ollang Project Management Dashboard. Order Type **Who this is for** — Product, operations, and engineering teams choosing which Order Type fits a use case, and developers calling [Create Order](/apis/ollang-api-reference/create-order). Each section below explains the workflow, deliverables, and configuration knobs for one Order Type. See [Order Types reference](/apis/ollang-api-reference/order-types) for the canonical `orderType` enum values. ## Overview Order Types define: * what localization workflow is being executed, * which AI orchestration pipeline is triggered, * what source assets are utilized, * what deliverables are generated, * and how reviewers, linguists, or studios interact with the output. Inside Ollang, an Order is not simply a translation request. Each Order activates: * AI orchestration, * provider routing, * workflow automation, * assignment logic, * deliverable generation, * and optional human review operations. Different Order Types may: * consume different AI providers, * expose different editing interfaces, * and generate different exportable outputs. *** # Available Order Types The Ollang Project Management Dashboard currently supports: Generate multilingual dubbed audio and localized video deliverables using AI voice synthesis workflows. Translate subtitle assets and timed dialogue into one or multiple target languages. Generate transcription and caption files from source media. Localize multilingual documents into one or multiple target languages. Coordinate external dubbing studios and professional voice production workflows. Localize on-screen text inside videos, graphics, presentations, and visual assets while preserving the original layout, positioning, and multilingual consistency. Localize website content, UI strings, and structured localization files across multiple languages. *** # AI Dubbing ## Overview AI Dubbing is Ollang’s multilingual AI voice localization workflow. The workflow automatically orchestrates: * speech-to-text, * subtitle generation, * translation, * voice synthesis, * audio processing, * and final deliverable generation. AI Dubbing workflows are commonly used for: * marketing videos, * educational content, * training materials, * YouTube content, * podcasts, * enterprise localization, * media distribution, * and accessibility operations. *** # Core AI Dubbing Pipeline A typical AI Dubbing workflow internally follows: ```text theme={null} Source Video / Audio ↓ Speech-to-Text (CC) ↓ Subtitle Translation ↓ Voice Synthesis (Text to Speech operations) ↓ Audio Mixing ↓ Order Deliverables (including the Final Mixmaster, Dubbed Vocals and Created M&E file) ``` Each stage may utilize: * different AI providers, * different workflow configurations, * and different orchestration logic. F8 *** # AI Dubbing Styles AI Dubbing contains multiple dubbing styles. Users select the dubbing style during Order configuration. Supported dubbing styles currently include: Replace original vocals with localized dubbed vocals. Preserve original audio underneath localized dubbed speech. Generate accessibility narration describing visual actions and environments. *** # Vocal Replacement ## Operational Behavior Vocal Replacement replaces: * the original source vocals, with: * localized/dubbed AI-generated vocals. The system attempts to preserve: * pacing, * speech timing, * speaker continuity, * and natural dialogue flow. This workflow is commonly used for: * multilingual training content, * enterprise localization, * dubbed media, * and multilingual distribution. *** ## Example Workflow ```text theme={null} English Source Video ↓ English to French AI Dubbing Order created ↓ Original English Vocals Removed ↓ French Vocals Become Primary Audio Layer in the final Mix file ``` *** # Overdub ## Operational Behavior Overdub workflows preserve: * the original source audio, while layering: * localized dubbed vocals on top. The original audio remains audible at reduced volume. This workflow is commonly used for: * documentaries, * interviews, * educational content, * and narration-heavy workflows *** ## Example ```text theme={null} Original English Speech (Low Volume) + Localized Spanish Dub (Primary Layer) ``` *** # Audio Description ## Overview Audio Description (AD) workflows generate narration describing: * visual actions, * environments, * scene transitions, * gestures, * and contextual visual information. This workflow is designed for: * accessibility localization, * visually impaired audiences, * compliance requirements, * and inclusive media distribution. # Rules For Audio Description workflows: * source language and target language are generally the same. Example: ```text theme={null} English Video ↓ English Audio Description ``` *** # Long-Form Audio Description Support The platform supports Audio Description workflows for: * short-form content, * episodic media, * enterprise training material, * educational libraries, * and long-form video content. Examples include: * 30-minute videos, * 1-hour episodes, * 2–3 hour productions, * and enterprise accessibility libraries. *** # AI Dubbing Deliverables AI Dubbing workflows may generate: *** # Audio Description Deliverables When Audio Description dubbing style is selected, additional outputs may include: * AD Mixed Audio 5.1 * AD Narrator Audio 2.0 * AD Narrator Audio 5.1 * AD Mixed Audio 2.0 * AD Mixed Video 2.0 * Created M\&E * Created Source Vocals Only Audio *** # Subtitle Translation ## Overview Subtitle Translation workflows localize subtitle content from: * source videos, * source subtitle files, * or transcription outputs F9 *** # Typical Subtitle Translation Workflow ```text theme={null} English Video ↓ English CC Generation ↓ French Subtitle Translation ↓ French Subtitle Editing (when the order has a Human in the Loop; otherwise the PM can edit the order after delivery via order assignment) ↓ Export Deliverables ``` *** # Subtitle Editing Capabilities Inside the Editor Interface, linguists can: * edit subtitle text, * modify timing, * split subtitle segments, * merge subtitle segments, * optimize CPS/CPL compliance, * reassign speakers, * and refine readability or subtitle timing consistency. F10 *** # Subtitle Export Formats Completed Subtitle Translation workflows support exports including: *** # FN Excluded Variants The platform additionally supports: * SCC-FN Excluded, * SRT-FN Excluded, * DFXP-FN Excluded, * and ASS-FN Excluded export variants. These specialized exports are commonly used for: * broadcast compatibility, * formatting workflows, * and enterprise subtitle distribution requirements. *** # Video Captioning (CC) ## Overview Video Captioning (CC) workflows generate: * timed transcription files, * subtitle-ready caption structures, * and foundational subtitle assets. CC workflows are frequently used before: * Subtitle Translation, * AI Dubbing, * or accessibility localization workflows. F13 *** # Speaker Diarization The platform supports: * speaker separation, * speaker labeling, * and timed segmentation. Speakers are internally labeled using structures such as: * Speaker A, * Speaker B, * Speaker C. For AI Dubbing workflows: * additional gender assignment logic may be utilized to improve voice synthesis quality. *** # Overlapping Speech Handling When multiple speakers speak closely together: * the system attempts to separate speakers into distinct timed segments. The workflow attempts to avoid: * combining multiple speakers into the same subtitle line whenever operationally possible. Editors can additionally: * split segments, * reassign speakers, * and manually refine subtitle structures. *** # Multi-Provider STT Orchestration Unlike platforms restricted to a single transcription provider, Ollang supports: * multiple speech-to-text workflows, * and configurable provider orchestration. F12 Organizations may configure providers such as: * **Agentic STT** — Ollang's multi-agent workflow, and the default, * **AssemblyAI** — general-purpose transcription with speech intelligence, * **ElevenLabs Scribe v2** — code-switching and under-resourced languages, * **Speechmatics** — accented and dialectal speech, with an LLM-steered variant, * **AWS Transcribe** — AWS-aligned enterprise pipelines, * **Visual STT** — on-screen text rather than speech. This allows organizations to optimize: * transcription quality, * diarization behavior, * and language-specific performance. Accuracy, language coverage, and hallucination risk for every transcription provider. *** # Document Translation ## Overview Document Translation workflows localize: * office documents, * structured localization resources, * multilingual documentation, * and software localization files. The workflow supports both: * simple office localization, * and advanced structured localization pipelines. F14 *** # Supported Document Formats The platform supports: *** # Structured Localization Support The platform supports structured localization formats including: * XLIFF, * SDLXLIFF, * JSON, * PO, * subtitle assets, * and HTML localization workflows. This allows: * engineering teams, * localization operations, * and product organizations to operationalize multilingual content pipelines directly inside Ollang. *** # Studio Dubbing ## Overview Studio Dubbing workflows are designed for: * professional dubbing studios, * external localization vendors, * enterprise voice teams, * and production-based dubbing operations. Unlike AI Dubbing: * voice recording occurs externally. The platform acts as: * the operational coordination layer. *** # Typical Studio Dubbing Pipeline ```text theme={null} CC Generation ↓ Subtitle Translation ↓ Studio Recording (On the basis of Dubbing SRT files from the previous step) ↓ Asset/Deliverables Upload ↓ Mixmaster Generation (Ollang System) ↓ Final Delivery (Output files can be downloaded from the PM Interface) ``` Studios and vendors can upload: * dubbing vocals, * final mixed outputs, * Mixmaster files, * and studio-generated deliverables. The system then: * processes audio assets, * coordinates operational workflows, * and manages final delivery generation. *** # Important Studio Dubbing Rule Studios cannot deliver isolated vocals-only files without the required audio structure. Delivery workflows require: * either final mixed outputs, * or sufficient audio structure for operational Mixmaster generation. *** # Visual Translation Visual Translation workflows localize text that appears visually inside media assets. Unlike traditional subtitle or dubbing workflows, Visual Translation focuses on: * on-screen text, * embedded graphics, * banners, * UI text, * product screenshots, * visual overlays, * and image-based language elements. This workflow is designed for: * marketing campaigns, * product videos, * social media content, * presentations, * e-learning material, * mobile app showcases, * and multilingual visual content operations. # Supported Visual Translation Inputs Visual Translation workflows support: Upload videos containing embedded visual text that requires multilingual localization. Upload Adobe After Effects project files for structured visual localization workflows. Translate visual text appearing directly inside images while preserving design structure. Localize banners, graphics, presentations, and visual marketing materials. *** # How Visual Translation Works Visual Translation workflows typically operate as: ```text theme={null} Source Video / Image / After Effects File ↓ Visual Text Detection ↓ Translation ↓ Text Replacement ↓ Localized Visual Output ``` The platform attempts to: * detect visual text, * preserve positioning, * maintain formatting consistency, * and localize embedded visual content. *** # Image-to-Image Translation Visual Translation also supports: * image-based text localization. This means: * words embedded directly inside images, * banners, * screenshots, * product visuals, * presentations, * or marketing assets can be localized into target languages. Example: ```text theme={null} Source Image: "Summer Sale" Localized Image: "Soldes d'été" ``` The workflow attempts to preserve: * layout, * design consistency, * positioning, * and visual readability. *** # Adobe After Effects Support Organizations may upload: * Adobe After Effects project files for structured localization workflows. This is especially useful for: * animated marketing videos, * multilingual motion graphics, * product launch campaigns, * and enterprise creative localization. The platform processes visual layers and localization workflows accordingly. F15 *** # Typical Visual Translation Use Cases Common use cases include: * multilingual marketing videos, * localized advertisements, * product demonstrations, * visual UI localization, * social media campaigns, * e-learning visuals, * and multilingual creative operations. *** # Website Translation ## Overview Website Translation workflows enable organizations to localize websites into multiple languages using Ollang’s orchestration and MCP-based architecture. Rather than manually exporting website files, organizations can connect website workflows directly through: Ollang MCP integrations. This enables scalable multilingual website localization. *** # How Website Translation Works Website Translation workflows typically operate as: ```text theme={null} Website Connection via MCP ↓ Website Content Extraction ↓ AI Translation ↓ Terminology & Memory Enforcement ↓ Localized Website Experience ``` Organizations can: * localize websites into multiple languages, * preserve multilingual consistency, * reuse terminology memory, * and operationalize global website localization. # Website Localization Capabilities Website Translation workflows can support localization of: * website copy * landing pages * product descriptions * metadata * UI text * multilingual navigation * structured localization resources * multilingual product experiences # Core Platform Architecture Source: https://api-docs.ollang.com/platform-architecture Understand how the Ollang Project Management Dashboard organizes localization workflows using Folders, Projects, and Orders. **Who this is for** — Localization leads, product/operations teams, and developers planning an Ollang integration. Read this once before configuring workflows or building automation; everything in the API reference, MCP, SDK, and Skills docs assumes the **Folder → Project → Order** model described below. ## Overview The Ollang Project Management Dashboard is built around a structured operational hierarchy designed to support enterprise-scale localization workflows across: * AI dubbing, * Subtitle localization, * Transcription, * Accessibility workflows, * Document translation, * and Studio Dubbing operations The platform is designed as an orchestration layer rather than a single-model localization tool. This means Ollang coordinates: * multiple AI providers, * multiple workflow types, * and multiple review structures inside one centralized operational environment. The foundation of the platform is a three-level hierarchy: ```text theme={null} Folder → Project → Order ``` Understanding this structure is critical because: * assignments, * permissions, * notifications, * deliverables, * analytics, * and localization workflows all operate through this hierarchy. *** # Understanding the Hierarchy Organizational containers used to group related localization initiatives. Represent the primary source asset that will be localized. The actual localization workflows executed inside the platform. *** # Folders ## What is a Folder? A Folder is the highest organizational layer inside the Ollang Project Management Dashboard. Folders are operational containers used to organize: * multilingual campaigns, * media collections, * training materials, * product launches, * accessibility projects, * legal localization batches, * or any grouped localization initiative. The platform is intentionally workflow-agnostic. This means folders are not limited to: * entertainment media, * subtitle workflows, * or AI dubbing projects. Organizations can structure folders however they operationally prefer. *** ## What Can a Folder Contain? A Folder contains Projects that can be assigned to Project Managers and can also be assigned an independent workflow. A Folder may contain: * one Project, * dozens of Projects, * or hundreds of Projects. *** ## Example Folder Structures ### Media Localization Example ```text theme={null} Folder: Nature Documentary Series ├── Project: Episode 1 ├── Project: Episode 2 ├── Project: Episode 3 ``` F1 F2 *** ### Marketing Localization Example ```text theme={null} Folder: Q4 Product Launch ├── Project: Product Demo Video ├── Project: Product Datasheet ├── Project: Training Material ``` *** ### Legal Localization Example ```text theme={null} Folder: International Compliance ├── Project: Privacy Policy ├── Project: Vendor Agreement ├── Project: Employee Handbook ``` *** # Folder-Level Notifications Notification behavior operates primarily at the Folder level. When a Project Manager is assigned to a Folder: * they receive notifications when orders inside the Folder are completed. * the user who created the order also receives notifications. This applies whether: * the order was completed by AI, * delivered by a linguist (In case of a Closed Captioning, Subtitle Translation, Document Translation or AI Dubbing order) * delivered by a Vendor (In case of a Studio Dubbing order) *** ## Example Notification Workflow ```text theme={null} Project Manager A assigned to Folder A ↓ Team Member B creates order ↓ Order completes ↓ Both users receive notification ``` *** # Folder Deletion Rules Folders containing active or completed orders cannot currently be deleted. This behavior exists to preserve: * localization history, * auditability, * workflow traceability, * and operational consistency. *** # Projects ## What is a Project? A Project represents: * one primary source asset intended for localization. The primary source asset acts as: * the operational source of truth for localization workflows. A Project may represent: * a source video, * a source audio file, * or a source document. *** # Primary Assets vs Supporting Assets One of the most important concepts inside Ollang is the distinction between: * the primary source asset, * and supporting localization assets. Every Project contains: * one primary source asset, but may additionally contain: * subtitle files (SRT), * source audio, * M\&E files, * glossaries, * guideline documents, * accessibility notes, * or any relevant supporting localization documents for the project. F3 *** ## Example Project Structure ```text theme={null} Project: Product Demo Video ├── Primary Source Video ├── English SRT ├── M&E File ├── Brand Guidelines ├── Translation Glossary ``` The system treats: * the primary video as the operational source of truth, while all other assets function as: * supporting operational references **Note**: All the associated supporting operational project files goes into the context window of the agent (that has been selected from the workflow on the basis of the language pair) who will be processing the order. *** # Multi-Asset Project Support A Project may contain: * both video and document assets, * subtitle references, * accessibility files, * and additional localization materials simultaneously. The order created by the user determines which asset becomes operationally relevant. *** ## Example ```text theme={null} Project contains: - Product Demo Video - PDF Script If user creates: - Subtitle Translation Order → video becomes operational source. - Document Translation Order → PDF becomes operational source ``` F5 *** # Orders ## What is an Order? Orders are the actual localization processing jobs created from Projects. A single Project can contain: one or multiple Orders simultaneously. F6 *** # Example Order Structure ```text theme={null} Project: Product Launch Video ├── CC Order (English) ├── Subtitle Translation (French) ├── Subtitle Translation (German) ├── AI Dubbing (French) ├── AI Dubbing (German) ``` Orders are independent operational units. Assignments, reruns, analytics, and deliverables all operate primarily at the Order level. F7 *** # Typical Order Lifecycle A Project Management User creates a localization order after configuring the workflow settings. The platform processes transcription, translation, and dubbing workflows depending on the order type. Orders may optionally be assigned to editors. Assigned users edit, review, and refine the generated output. Finalized outputs are delivered back into the Project Management Dashboard. Deliverables become available for export in supported formats. *** # Two Main Interfaces The Ollang ecosystem operates through two interconnected operational environments. Used for project organization, order creation, billing, analytics, workflow management, and operational visibility. Used for subtitle editing, dubbing review, localization delivery, and assignment-based execution. *** # Project Management Dashboard The Project Management Dashboard is used for: * creating localization orders, * managing folders, * organizing projects, * configuring workflows, * assigning teams, * reviewing deliverables, * and monitoring operations. Project Management Users can generally view: * all folders, * all projects, * and organizational workflow activity. *** # Editor / LSP Interface The Editor Interface is: * assignment-scoped, * and operationally focused. Editors do not automatically see: * all projects, * all folders, * or all organizational workflows. Editors only see: * explicitly assigned orders. *** ## Example Editor Visibility ```text theme={null} Folder contains: - 10 Projects - 200 Orders Editor assigned: - 5 Orders Result: - Editor only sees those 5 assigned Orders. ``` *** # Example End-to-End Workflow ```text theme={null} 1. Project Manager uploads source video ↓ 2. Subtitle Translation Order created ↓ 3. AI generates initial translation ↓ 4. Order assigned to an Editor (LSP Admin) ↓ 5. Editor assigns Linguist ↓ 6. Linguist edits subtitles ↓ 7. Linguist delivers order ↓ 8. Project Management Dashboard reflects final delivery ``` *** # Key Operational Concepts Orders are treated as independent operational units. This allows different linguists, studios, or reviewers to work on different workflows under the same Project simultaneously. Yes. A Folder can contain one, dozens, or hundreds of Projects depending on organizational needs. Yes. A Project may contain supporting assets such as subtitle files, M\&E files, glossaries, and guideline documents in addition to the primary source asset. No. Editors only see explicitly assigned Orders inside the Editor Interface. # Audio Processing Providers Source: https://api-docs.ollang.com/providers/audio-processing Stem separation in the Ollang dubbing pipeline — how the dialogue stem is isolated from music and effects, and what that means for the final mix. Audio processing runs in the `split` step, the first stage of an **AI Dubbing** Order. It separates the source audio into an isolated dialogue stem and a music-and-effects (M\&E) bed. That separation is what makes dubbing sound like dubbing rather than a voiceover. The dialogue stem feeds transcription; the M\&E bed is preserved and remixed under the synthesized target-language voice, so the score, ambience, and sound design survive localization intact. ```mermaid theme={null} flowchart LR A["Source audio"] --> B{"Stem separation"} B --> C["Dialogue stem"] --> D["Transcribe and translate"] D --> E["Synthesized voice"] B --> F["Music and effects bed"] --> G["Final mix"] E --> G ``` ## At a glance | Provider | Provider tag | Order types | Status | | - | - | - | - | | [LALAL.AI](#lalalai) | `lalalAi` | AI Dubbing | **Default** | It is the shortest step in the dubbing pipeline, and the one with the largest effect on whether the finished mix sounds professional. *** ## LALAL.AI A dedicated stem separation service built on a set of proprietary neural networks — **Phoenix**, **Orion**, **Perseus**, **Andromeda**, **Lyra**, and **Lynx** — capable of splitting a track into twelve distinct stem types. An `auto` option selects the most effective network for the requested stem. The **Orion** network takes a different approach from conventional separation. Rather than carving stems out of the mix with spectral masks, it **synthesizes** them, reconstructing the stem from what it has learned across many mixes. The practical result is markedly less of the artifact residue that betrays a dub: the watery, phase-smeared remainder where dialogue used to be. **Best for** — every AI Dubbing Order. Dialogue-over-music content benefits most, since that is where mask-based separation degrades hardest. **Strengths** * Direct-synthesis separation with lower cross-stem leakage than mask-based methods. * **Three noise-cancelling levels** on the voice stem, for source audio of varying quality. * **Dereverberation**, which removes room echo from the extracted voice. This matters beyond the mix: reverb in the source is one of the more reliable ways to degrade transcription accuracy, so cleaning it here improves every downstream step. * **Separate `voice` and `music` stems** — spoken voice is a distinct target from sung `vocals`, which is exactly the split a dubbing pipeline needs. * **Selectable extraction level** (`deep_extraction` or `clear_cut`), trading completeness of the extracted stem against cleanliness of what is left behind. * Finer stems — drums, bass, piano, guitar variants, synthesizer, strings, wind — for mixes that have to be partially rebuilt rather than simply split. **Considerations** * Separation quality tracks source quality. Heavily compressed audio, dialogue buried under a loud mix, or material already processed by another separation tool will produce a weaker M\&E bed. * Where the source has a clean dialogue stem available, supplying it directly will always beat separating it back out. **In Ollang** — `lalalAi` · AI Dubbing · Default. *** ## Related The voice engines that render into the preserved M\&E bed. Supported source formats and how audio is ingested. # AI Provider Catalog Source: https://api-docs.ollang.com/providers/overview How Ollang orchestrates AI providers, what each pipeline step does, and how to read provider status and order-type support. Ollang is an **orchestration layer**, not a single-vendor pipeline. Every Order is assembled from independent provider choices — one per pipeline step — so you can mix a best-in-class transcription model with an efficient translation model and a premium voice, and change any one of them without rebuilding the workflow. This catalog documents the providers that are **selectable in Workflows today** and what each is genuinely good at. 8 selectable transcription providers, from multi-agent to single-model. 27 translation engines and frontier LLMs across 10 model families. 6 voice synthesis engines for AI Dubbing and Audio Description. Stem separation that preserves music and effects under dubbed dialogue. *** ## The four pipeline steps Providers are grouped by the **step** they run in. An Order only runs the steps its Order Type needs. ```mermaid theme={null} flowchart LR A["Source media"] --> B["split
Audio Separation"] B --> C["transcribe
Speech-to-Text"] C --> D["translate
Translation"] D --> E["textToSpeech
Voice Synthesis"] E --> F["Deliverable"] ``` | Step | Internal key | What it produces | Used by | | - | - | - | - | | Audio Separation | `split` | Isolated dialogue stem plus a music-and-effects bed | AI Dubbing | | Speech-to-Text | `transcribe` | Timecoded transcript with speakers | Closed Captions, Subtitles, AI Dubbing | | Translation | `translate` | Localized text, subtitles, or dubbing script | Documents, Subtitles, AI Dubbing | | Voice Synthesis | `textToSpeech` | Synthesized target-language audio | AI Dubbing | A **Document Translation** Order touches only `translate`. A **Closed Captions** Order touches only `transcribe`. An **AI Dubbing** Order can run all four, so its provider selection is really four decisions rather than one. *** ## Reading a provider entry Every provider in this catalog carries the same three attributes. The stable machine identifier, for example `elevenlabs` or `anthropic/claude-opus-5`. This is the value returned by the [List Consumption](/apis/ollang-api-reference/list-consumption) endpoint and accepted by its `filter[provider]` parameter, so it is what you match on when you reconcile provider activity programmatically. Display names change; provider tags do not. One tag is reused across steps: `aws` identifies both Amazon Transcribe in the `transcribe` step and Amazon Translate in the `translate` step. Filtering on `aws` returns rows from both, so narrow with `filter[orderType]` or check the service field. Which Order Types can select the provider. Most translation engines serve `document`, `subtitle`, and `aiDubbing`, but there are real exceptions — DeepL is document and subtitle only, and Llama 4 is not available for dubbing scripts. See [Order Types](/apis/ollang-api-reference/order-types) for the full enum. **Default** — the provider Ollang uses for that step when a Workflow does not override it. **New** — recently added and fully supported. **Experimental** — available for evaluation, behavior may change, and output should be reviewed before it goes to production. *** ## Defaults If you never configure a Workflow, Orders run on these: | Step | Default provider | | - | - | | Audio Separation | [LALAL.AI](/providers/audio-processing) | | Speech-to-Text | [Agentic STT](/providers/speech-to-text#agentic-stt) | | Translation | [Agentic Localization](/providers/translation#ollang-agentic) | | Voice Synthesis | [ElevenLabs Multilingual V2](/providers/text-to-speech#elevenlabs-multilingual-v2) | These defaults favor quality and robustness. Each catalog page also identifies the efficiency-oriented alternatives that suit high-volume or lower-stakes content. *** ## Choosing a provider Leaderboard position rarely predicts localization quality for *your* material. Clean studio narration, noisy field audio, and code-switched conversation reward completely different models. This is the most common reason a Workflow has to be reconfigured. Coverage across the catalog ranges from 7 languages to well over 100, and the highest-accuracy tier of a provider is often narrower than its headline language count. Configure one organization-wide default that is safe for most content, then override per Folder where a specific team or content type needs something different. See [Workflows and Provider Architecture](/workflows-provider-architecture). Run the same source through two Folders with different providers and compare AI QC scores and human edit distance. This is the only measurement that reflects your content and your reviewers. The catalog moves fast — several entries here did not exist six months ago. A provider decision that was correct last quarter is worth re-testing rather than assumed. Changing a Workflow only affects **future** Orders. Orders already created keep the providers they were created with, so a provider swap is never retroactive and never changes a deliverable you have already reviewed. *** ## Scope of this catalog The pages in **STT APIs**, **Translation APIs**, **TTS APIs**, and **Audio Operations** also document engines from the wider localization ecosystem that Ollang can integrate with on request. Those reference pages are useful background, but only the providers listed in this catalog are selectable in Workflows without a custom integration. If you need an engine that is documented but not in the catalog, contact your account team — adding a provider to a workspace is a configuration change, not a product change. # Speech-to-Text Providers Source: https://api-docs.ollang.com/providers/speech-to-text Compare the transcription engines available in Ollang Workflows — accuracy, language coverage, code-switching behavior, and which content type each one suits. Speech-to-text runs in the `transcribe` step. It produces the timecoded, speaker-attributed transcript that Closed Captions ship directly, that Subtitle Orders translate, and that AI Dubbing turns into a dubbing script. Transcription is the step where errors do the most damage, because everything downstream inherits them. A mistranscribed proper noun becomes a mistranslated proper noun and then a mispronounced one. ## At a glance | Provider | Provider tag | Languages | Best for | Status | | - | - | - | - | - | | [Agentic STT](#agentic-stt) | `ollangAITranscribe` | — | Complex multi-speaker media, noisy audio, mixed languages | **Default** | | [Agentic STT-1.2](#agentic-stt-12) | `ollang-stt-1.2-exp` | — | Same workloads, next-generation agent orchestration | Experimental | | [Visual STT](#visual-stt) | `agentic-visual-transcription` | — | Silent video, on-screen text, kinetic typography | Experimental | | [AssemblyAI](#assemblyai) | `assemblyai` | 99 | General-purpose transcription with speech intelligence | Available | | [ElevenLabs Scribe v2](#elevenlabs-scribe-v2) | `elevenlabs-scribe-v2` | 90+ | Under-resourced languages, 32-speaker diarization, audio events | Available | | [Speechmatics](#speechmatics) | `speechmatics` | 70+ | Accented and dialectal speech, automatic language switching | Available | | [Speechmatics with LLM](#speechmatics-with-llm) | `speechmatics-llm` | 70+ | Same, plus custom guidelines and instructions | Available | | [AWS Transcribe](#aws-transcribe) | `aws` | 100+ locales | AWS-aligned enterprise pipelines, nine English locales | Available | | [Whisper](#whisper) | `whisper` | 90+ | — | Not currently selectable | The Ollang agentic providers orchestrate several underlying models rather than exposing a fixed language list, so no single coverage figure applies to them. The counts shown are the vendor-published figures for the single-model providers. AWS is listed in locales rather than languages — nine of its entries are English variants and three are Spanish. AssemblyAI and ElevenLabs Scribe v2 are the single-model workhorses of this catalog — the natural first stop for a large backlog of reasonable-quality audio. Reserve Agentic STT for content where the audio is genuinely difficult, since that is where a multi-agent pass earns its extra processing. *** ## Agentic STT Ollang's own multi-agent transcription workflow, and the default for every transcription step. Rather than sending audio to a single ASR model, Agentic STT runs a collaborative agent pass that reconciles competing hypotheses, resolves speaker attribution across the whole timeline, and uses surrounding context — including non-speech audio cues — to decide between plausible readings. **Best for** — video and audio with multiple language streams, several speakers, background noise, or diverse accents; anything where a single-pass ASR model produces a transcript that reads plausibly but is wrong. **Strengths** * Superior handling of noisy audio, overlapping speech, and accent diversity compared with single-model ASR. * Contextual interpretation of audio cues, which matters for localization workflows where the transcript becomes a dubbing script. * Consistent speaker attribution across long-form content. **Trade-offs** * A multi-agent pass does more work than a single model call, which shows up in turnaround on large batches. On clean, single-speaker studio audio it buys very little over the single-model providers. **In Ollang** — `ollangAITranscribe` · Closed Captions, Subtitles, AI Dubbing · Default. *** ## Agentic STT-1.2 The next iteration of the agentic transcription workflow, available for evaluation alongside the current default. It targets the same content profile as Agentic STT — multi-stream, noisy, accent-diverse media — with revised agent orchestration. **Best for** — teams that want to benchmark the next generation against their existing Agentic STT baseline before it becomes the default. Experimental. Behavior may change between releases. Run it in a benchmarking Folder alongside Agentic STT rather than switching a production Global Workflow to it. **In Ollang** — `ollang-stt-1.2-exp` · Closed Captions, Subtitles, AI Dubbing · Experimental. *** ## Visual STT A different kind of transcription: instead of listening, it reads. Visual STT extracts on-screen text from video frames and turns it into editable, timecoded text content. **Best for** — silent video, social-first content where the message lives in burned-in captions, product demos with UI text, title cards, lower thirds, and kinetic typography. **Strengths** * Recovers content that audio-only transcription cannot see at all. * Produces editable text, so on-screen copy can be localized rather than left in the source language. **Trade-offs** * It transcribes what is *displayed*, not what is *said*. For content that has both meaningful speech and meaningful on-screen text, you will want a separate audio transcription pass as well. * Preview quality. Review output before it reaches a deliverable. **In Ollang** — `agentic-visual-transcription` · Closed Captions, Subtitles, AI Dubbing · Experimental. *** ## AssemblyAI A general-purpose speech AI platform, and the broadest language coverage of any transcription provider in the catalog. AssemblyAI's model line splits along a breadth-versus-accuracy axis: | Model | Languages | Notable | | - | - | - | | **Universal-2** | 99 | Broad coverage for general transcription | | **Universal-3.5 Pro** | 21 (18 base plus regional variants) | Highest accuracy tier, with native code-switching including English–Spanish | **Best for** — batch transcription of podcasts, meetings, interviews, and broadcast content, where audio quality is reasonable and language breadth matters. **Strengths** * **99 languages** on Universal-2 — the highest published language count in this catalog. * Native code-switching on the Pro tier, for speakers who move between languages mid-sentence. * Custom vocabulary support, which measurably improves handling of product names, people names, and domain jargon. * Speaker diarization and speech intelligence — sentiment, topic detection, PII redaction — produced alongside the transcript rather than in a separate pass. **Trade-offs** * The highest-accuracy tier covers 21 languages, not the full 99. Confirm which tier serves your language before assuming top-tier accuracy. * Accuracy drops on heavily accented speech and messy conversational audio, as it does for every single-pass model. That is where the agentic providers earn their premium. **In Ollang** — `assemblyai` · Closed Captions, Subtitles, AI Dubbing. *** ## ElevenLabs Scribe v2 ElevenLabs' transcription model, and the most transparent provider in the catalog about where it is and is not accurate. Scribe v2 transcribes **90+ languages**, and ElevenLabs publishes a **per-language accuracy tier** for every one of them — from *Excellent* (5% word error rate or below) through *Moderate* (25–50% WER). That published breakdown is the most useful thing about it: you can check your specific language before committing a Workflow rather than discovering the answer in review. **Best for** — content in languages outside the mainstream 30, and any workflow that needs non-speech events labeled rather than dropped. **Strengths** * **Speaker diarization up to 32 speakers** — the highest documented ceiling in the catalog, which matters for panels, roundtables, and large meetings. * **Dynamic audio tagging** — non-speech events such as laughter and applause are captured as `audio_event` entries, which feeds accessibility caption requirements directly. * **Entity detection across 65 types** and **keyterm prompting with up to 1,000 terms**, for enforcing domain vocabulary. * Precise word-level timestamps, giving subtitle segmentation more to work with. * A realtime variant transcribes 90+ languages at roughly 150 ms latency. **Trade-offs** * **Accuracy varies widely by language**, from under 5% WER to over 25%. Check ElevenLabs' published tier for your language rather than assuming the headline figure applies. * On unclear or silent passages, transcription models of this class can produce fluent text that was never spoken. That failure mode does not look like an error in the transcript, so budget a validation pass for anything going straight to a deliverable. **In Ollang** — `elevenlabs-scribe-v2` · Closed Captions, Subtitles, AI Dubbing. *** ## Speechmatics A speech recognition specialist whose focus is accent and dialect coverage rather than benchmark position on clean, standard-accent English. That focus is why it holds up on audio that degrades generic models most. Speechmatics covers **70+ individual languages**, plus **7 bilingual language packs** for media where two languages appear in the same file. | Model | What it is for | | - | - | | **Enhanced** | Highest-accuracy operating point; supports translation | | **Standard** | Faster operating point; supports translation | | **Melia 1** | Multilingual model that switches between languages automatically, with no language selection; does not support translation | **Best for** — batch transcription where speakers have strong regional accents, where lesser-resourced dialects appear, or where speakers move between languages spontaneously. **Strengths** * **Melia 1 handles spontaneous language switching without a declared source language** — the cleanest answer in the catalog for genuinely multilingual speakers. * Consistently good on accented and dialectal speech, which is where generic models degrade most. * Speaker diarization and custom dictionary for domain vocabulary. * Smart formatting applied by default — numbers, dates, currencies, and measurements converted to conventional written forms — plus profanity tagging, disfluency removal, and regex-based word replacement. * Translation from English into 34 target languages on the Enhanced and Standard models. **Trade-offs** * Little advantage over AssemblyAI or Scribe v2 on clean, standard-accent audio — its strengths only show up on the material that defeats generic models. * Melia 1's automatic language switching and translation are mutually exclusive — pick the model that matches the job. * 70+ languages is narrower than AssemblyAI's 99 or Scribe's 90+. **In Ollang** — `speechmatics` · Closed Captions, Subtitles, AI Dubbing. *** ## Speechmatics with LLM Speechmatics transcription with an LLM post-processing pass that accepts **custom guidelines and instructions**. Everything true of [Speechmatics](#speechmatics) applies here, plus the ability to steer the output — enforce terminology, apply formatting conventions, or follow style guidance — instead of correcting it downstream. Speechmatics' own formatting controls are rule-based; this variant adds instruction-driven judgment on top. **Best for** — recurring content with a house style: consistent speaker labels, fixed product terminology, specific number and date formatting, or client-mandated caption conventions. **Trade-offs** * Adds a post-processing stage, so it only earns its place when you would otherwise be making the same corrections by hand every week. **In Ollang** — `speechmatics-llm` · Closed Captions, Subtitles, AI Dubbing. *** ## AWS Transcribe Amazon's managed ASR service, strongest as an option for organizations already standardized on AWS. Amazon Transcribe covers **more than 100 languages and locale variants** across batch and streaming, though feature support varies sharply by language. **Best for** — enterprise pipelines that need transcription to sit inside an existing AWS footprint, with English variants and Spanish as the primary working languages. **Strengths** * **Nine English locales** — US, British, Australian, Indian, Irish, New Zealand, Scottish, South African, and Welsh — plus three Spanish locales, so regional variants are recognized rather than approximated. * Batch and streaming modes with automatic language identification, including audio containing multiple languages. * Custom vocabulary and acronym handling across most supported languages. * PII redaction and Call Analytics for regulated material. * AWS-native integration — IAM, VPC, KMS, and regional controls apply without additional plumbing. **Trade-offs** * **No general accuracy advantage** over the other single-model providers on ordinary media content — its case rests on AWS alignment and locale depth. * **Custom language models cover only seven locales**: en-AU, en-GB, en-US, es-US, de-DE, ja-JP, and hi-IN (batch only). The customization story is narrower than it first appears. * **Redaction is limited to English, French, Italian, Portuguese, and Spanish.** * Streaming is unavailable for some languages and in some AWS regions. **In Ollang** — `aws` · Closed Captions, Subtitles, AI Dubbing. *** ## Whisper Whisper is **not currently selectable** in Workflows. It remains documented because it is the reference open-source baseline that most comparisons in this catalog are measured against, and because self-hosted Whisper deployments are common in customer-side pipelines. OpenAI's open-source ASR model, trained on 680,000 hours of multilingual audio. It handles noisy, multilingual, and poor-quality recordings well for an openly available model, and it can be self-hosted, which matters for data-residency-constrained workloads. Its well-documented weakness is hallucination on silence and low-quality segments — it will confidently emit text for audio that contains none. That failure mode is the reason the hosted providers above are preferred for deliverable-grade output. **In Ollang** — `whisper` · Not currently available for selection. *** ## Related Pipeline steps, provider tags, and status definitions. How to configure these providers at global and folder level. # Text-to-Speech Providers Source: https://api-docs.ollang.com/providers/text-to-speech Compare the voice synthesis engines available for AI Dubbing in Ollang — model versions, language and voice coverage, expressive control, and which content each one suits. Text-to-speech runs in the `textToSpeech` step and serves **AI Dubbing** Orders, including Lip Sync and Audio Description. It takes the translated dubbing script and produces target-language audio. This is the step audiences judge most directly. A translation error is invisible until someone reads carefully; a wrong-sounding voice is obvious in two seconds. ## At a glance | Provider | Provider tag | Languages | Voices | Best for | Status | | - | - | - | - | - | - | | [ElevenLabs Multilingual V2](#elevenlabs-multilingual-v2) | `elevenlabs` | 29 | Cloneable | Premium narration, cross-language voice identity | **Default** | | [Cartesia Sonic 3.6](#cartesia-sonic-36) | `cartesia` | 44 | Cloneable | Natural conversational delivery, fast turnaround | Available | | [Gemini TTS](#gemini-tts) | `geminiElevenlabs` | 99 | 30 | Widest language reach, multi-speaker dialogue | Available | | [Azure + ElevenLabs](/apis/tts-apis/azure-elevenlabs) | `azureElevenlabs` | 90+ locales | 200+ | Voice variety, SSML timing control, custom voices | Available | | [Deepgram TTS](#deepgram-tts) | `deepgram` | 7 | 88 | Deep English and Spanish accent coverage | Available | | [OpenAI TTS](#openai-tts) | `openaiTts` | 50+ | 13 | Instruction-steered delivery at high volume | Available | Language coverage and voice count measure different things. Gemini TTS reaches the most languages; Azure offers the most individual voices and the finest delivery control; ElevenLabs and Cartesia offer voice cloning, so their catalog is effectively unbounded but their language list is shorter. Decide which axis your program is actually constrained by. *** ## ElevenLabs Multilingual V2 The default voice engine, and still the reference point for natural-sounding synthetic speech. Eleven Multilingual v2 is ElevenLabs' emotionally-aware model for content work, covering **29 languages** with a 10,000-character request limit. Its most useful property for localization is not raw naturalness but **voice consistency**: a voice keeps its identity, personality, and accent across every language it speaks, which is what lets one character sound like the same person in eight dubs. **Best for** — voiceover, audiobook, and narrative content in widely spoken languages, where expressiveness and voice consistency carry the deliverable. **Strengths** * Among the most natural-sounding output available in its main languages. * Voice cloning, so a specific character or brand voice can be carried across an entire catalog. * Stability and similarity settings trade consistency against expressiveness per project. * Pronunciation dictionaries for brand and technical terms. **Trade-offs** * **29 languages is the second-narrowest coverage in the catalog**, ahead of only Deepgram. Cartesia covers 44 and Gemini TTS reaches 99. * Quality falls off outside the main languages, where the model loses subtlety and can drift in tone within a render. **In Ollang** — `elevenlabs` · AI Dubbing · Default. ElevenLabs' current model line also includes **Eleven v3**, documented at 70+ languages and positioned for emotional dialogue and multi-speaker audiobook work, and **Eleven Flash v2.5** at 32 languages with roughly 75 ms latency. Ollang's `elevenlabs` provider runs Multilingual v2. *** ## Cartesia Sonic 3.6 The current front-runner on independent voice evaluation. Sonic-3.6 covers **44 languages** — Odia and Urdu were added in this release, and Hinglish is explicitly supported — with sub-90 ms stated latency. Cartesia reports it as **number one on Artificial Analysis's Speech Arena leaderboard**. Model IDs are `sonic-3.6` for the continuously updated version and `sonic-3.6-2026-08-27` for a pinned snapshot. **Best for** — conversational and dialogue-heavy content, high-volume dubbing where turnaround matters, and language sets that reach past the ElevenLabs 29. **Strengths** * **15 more languages than ElevenLabs**, including South Asian languages that most premium engines do not serve. * Interprets emotional subtext from the transcript and calibrates delivery automatically, so an undirected line still lands with appropriate affect. * Non-verbal expressions — laughter, sighs, disfluencies — written directly into the transcript rather than requiring separate markup. * Contextual pacing, correct alphanumeric read-out, and heteronym handling: the three places synthesized narration most often gives itself away. * Instant voice cloning from roughly 10 seconds of reference audio. **Trade-offs** * Newer model line, so there is less accumulated production history behind it than ElevenLabs at studio-narration quality. * Published latency is model latency, not end-to-end round trip. **In Ollang** — `cartesia` · AI Dubbing. The in-product description for this provider still references an earlier Sonic generation with 15 languages. Sonic 3.6 supports 44. *** ## Gemini TTS The broadest language reach in the catalog, and the strongest option for scripted multi-speaker content. Google's Gemini TTS models cover **99 languages with 30 voices** on the Gemini API, and support **multi-speaker synthesis** — up to two distinct speakers rendered into a single generation, each holding its own tone, pitch, and style across the exchange. Delivery is directed with natural-language prompts covering style, accent, pace, tone, and emotion. Three model versions are documented, all in preview: | Model | Single speaker | Multi-speaker | Notes | | - | - | - | - | | `gemini-3.1-flash-tts-preview` | Yes | Yes | Newest; the only version supporting streaming audio | | `gemini-2.5-pro-preview-tts` | Yes | Yes | High control for structured workflows | | `gemini-2.5-flash-preview-tts` | Yes | Yes | Efficient generation for everyday volume | **Best for** — rich narrative content, dramatized or two-character scenes, and any program whose language list runs past what Cartesia or ElevenLabs cover. **Strengths** * **99 languages** — the widest coverage of any engine in this catalog. * Genuine multi-speaker output in one generation, with per-character voice consistency. * Prompted delivery: direction is written in natural language rather than encoded in parameters. * Code-switching within sentences with appropriate intonation. **Trade-offs** * All TTS model versions are in preview; behavior can change between releases. * A TTS session carries a 32k-token context limit, and multi-speaker generation is capped at two speakers. * Expressiveness depends on prompting — undirected output sits closer to the field than the ceiling suggests. **In Ollang** — `geminiElevenlabs` · AI Dubbing. *** ## Azure + ElevenLabs A combined route that pairs Microsoft Azure neural text-to-speech with ElevenLabs in a single provider option. Azure's contribution is **catalog depth**: over 200 neural voices across 90+ locales, spread across several quality tiers, with the finest delivery control of any engine here. | Tier | What it adds | | - | - | | Standard Neural | Baseline natural speech, broadest locale coverage | | Neural HD (`DragonHDLatestNeural`) | Higher naturalness and expressiveness on major languages | | Neural HD Omni (`DragonHDOmniLatestNeural`) | Multilingual with contextual awareness on select locales | | Neural HD Flash | Fast HD variant | | MAI-Voice-2 | 18+ emotional styles — angry, confused, determined, excited, fearful, whispering, and more | | Multilingual voices | One voice speaking across languages, with automatic emotional-cue detection | **Best for** — programs that need a specific locale, a specific age or gender profile, or a named speaking style that the single-vendor engines do not offer; and dubbing where lines must be fitted to a fixed timing budget. **Strengths** * **The largest individual voice catalog here**, with named speaking styles (newscast, customer service, chat, empathetic, whispering) and role variants including child voices. * Full SSML control over pronunciation, intonation, pauses, and pacing. For dubbing this is the practical mechanism for fitting a line to picture rather than re-recording it. * Custom Neural Voice and Personal Voice for a consistent brand or character voice. * Enterprise compliance posture inherited from Azure. **Trade-offs** * Baseline neural voices are reliable rather than expressive. On the major languages every provider covers, Cartesia and ElevenLabs sound better. **In Ollang** — `azureElevenlabs` · AI Dubbing. *** ## Deepgram TTS Deepgram's Aura-2 line, built for low-latency enterprise voice rather than performance. Aura-2 offers **88 voices across 7 languages**, and its distribution is unusual: it is deep rather than wide. | Language | Aura-2 voices | | - | - | | English | 38 | | Spanish | 17 | | Italian | 10 | | Dutch | 9 | | German | 7 | | Japanese | 5 | | French | 2 | English covers American, British, Australian, Irish, and Filipino accents; Spanish covers Mexican, Peninsular, Colombian, and Latin American. Voices are addressed as `[model]-[voice]-[language]`, for example `aura-2-thalia-en`. **Best for** — dubbing confined to these seven languages, especially English and Spanish programs where regional accent needs to be cast precisely. **Strengths** * **38 English and 17 Spanish voices** — more choice inside those two languages than any other engine here offers. * Speaking styles spanning warm conversational, confident professional, and characterful storytelling. * Low latency at scale, which translates into fast batch throughput for dubbing. **Trade-offs** * **Seven languages is the narrowest coverage in the catalog.** Confirm your language pair before selecting it — this is the most common reason a Deepgram Workflow has to be reconfigured. French in particular has only two voices. * Tuned for voice agents and IVR; accurate rather than expressive on performed content. **In Ollang** — `deepgram` · AI Dubbing. *** ## OpenAI TTS The most directly steerable engine in the catalog. `gpt-4o-mini-tts` is **steerable**: alongside the text you supply an instruction describing how it should be delivered, and the model adjusts accent, emotional range, intonation, impressions, speed of speech, tone, and whispering accordingly. It ships 13 voices — alloy, ash, ballad, coral, echo, fable, nova, onyx, sage, shimmer, verse, marin, and cedar — and outputs MP3, Opus, AAC, FLAC, WAV, or PCM. **Best for** — high-volume dubbing workloads, internal and training content, and first-pass drafts where delivery needs directing but a bespoke voice does not. **Strengths** * Instruction-based steering gives real delivery control without per-voice tuning; for dubbing it is the practical substitute for line-by-line direction. * Low latency, which keeps large dubbing batches moving. * Broad format support for downstream mixing. **Trade-offs** * **Preset voices only.** No cloning and no custom voice identity, so a character cannot be carried across a series the way ElevenLabs, Cartesia, or Azure custom voices allow. * Language support broadly follows Whisper's 50+ languages, but **the voices are optimized for English** — quality outside English is less consistent than the language count suggests. * Narrower expressive ceiling than Gemini TTS or Cartesia on performed content. **In Ollang** — `openaiTts` · AI Dubbing. *** ## Related Pipeline steps, provider tags, and status definitions. How AI Dubbing, Lip Sync, and Audio Description Orders are processed. # Translation and LLM Providers Source: https://api-docs.ollang.com/providers/translation Every translation engine selectable in Ollang Workflows — Ollang Agentic, OpenAI, Claude, Gemini, DeepL, Amazon, Cohere, Mistral, Qwen, and Llama — with capability notes and order-type support. Translation runs in the `translate` step and serves three very different jobs: **document** localization, **subtitle** translation against timed dialogue, and **dubbing script** generation where the output has to fit a timing budget and sound speakable. The catalog spans purpose-built machine translation (DeepL, Amazon), frontier general-purpose LLMs (OpenAI, Claude, Gemini), efficient open-weight models (Llama, Qwen, Mistral), and Ollang's own agentic localization workflow. They are not interchangeable — they differ in language coverage, context window, steerability, and which Order Types they serve. ## Choosing by job | If your priority is… | Start with | | - | - | | Maximum localization quality, culturally aware | [Agentic Localization](#ollang-agentic) | | High-volume documents with fast turnaround | [DeepL](#deepl) or [Agentic Turbo](#ollang-agentic) | | Frontier capability on quality-critical content | [GPT-5.6-Sol](#openai), [Claude 5 Opus](#anthropic-claude), [Gemini 3.1 Pro](#google-gemini) | | The hardest source material | [Claude 5 Fable](#anthropic-claude) | | Fast, efficient throughput at scale | [GPT-5.6-Luna](#openai), [Gemini 3.7 Flash](#google-gemini) | | Strict terminology under enterprise controls | [Cohere Command A](#cohere), [Amazon](#amazon-translate) | | Documents with diagrams, screenshots, or scans | [Gemini](#google-gemini), [DeepL Extended](#deepl) | | Chinese–English and long-tail languages | [Qwen3](#qwen) | | Long-form consistency across a document set | [Claude](#anthropic-claude) | | Subtitle output constrained to a length budget | [Amazon](#amazon-translate) | Language coverage across this catalog ranges from 12 to over 240. Check the family's coverage before committing a Workflow — it is the most common reason one has to be reconfigured. *** ## Ollang Agentic Ollang's own localization workflow, and the only provider in this catalog that is a *pipeline* rather than a single model. It selects and combines agents per segment based on content type, domain, and structural complexity, then reconciles their output. | Model | Provider tag | Order types | Status | | - | - | - | - | | Agentic Localization | `ollangAITranslate` | Document, Subtitle, AI Dubbing | **Default** | | Agentic Turbo | `agentic-turbo` | Document, Subtitle, AI Dubbing | Experimental | **Agentic Localization** covers end-to-end localization of text, documents, subtitles, and dubbing scripts across 100+ languages. It is the default because localization quality — not translation accuracy alone — is what most Orders are judged on. **Agentic Turbo** is the same shape of workflow tuned for throughput, aimed at high-volume pipelines that still need contextual quality rather than raw machine translation. Agentic Turbo is experimental. Benchmark it against your existing provider in a separate Folder before moving a production Global Workflow onto it. *** ## OpenAI The widest model ladder in the catalog. The current generation is **GPT-5.6**, which ships as Luna, Terra, and Sol in ascending capability. All three carry a **1.05M-token context window and 128K max output** — the tiers differ in capability, not in how much text they can hold. Ollang exposes the two ends of that range. | Model | Provider tag | Context | Status | | - | - | - | - | | GPT-5.6-Sol | `openai/gpt-5.6-sol` | 1.05M | **New** | | GPT-5.6-Luna | `openai/gpt-5.6-luna` | 1.05M | **New** | | GPT-5.4 | `openai/gpt-5.4` | \~1M | **New** | | GPT-5.2 | `openai/gpt-5.2` | 400K | Available | | GPT-5 | `openai/gpt-5` | — | Available | | GPT-4.1 | `openai` | 1M | Available | | o4-mini | `openai/o4-mini` | — | Available | All OpenAI models serve Document, Subtitle, and AI Dubbing Orders. **GPT-5.6-Sol** is OpenAI's most capable model, for complex translation and localization where nuance, terminology accuracy, consistency, and reliable instruction-following all have to hold at once. It supersedes the earlier 5.x tiers on capability. **GPT-5.6-Luna** is the efficiency tier of the same generation, built for everyday translation at volume with minimal latency — while carrying the same 1.05M context window as Sol. That combination is unusual: whole-document context on a throughput-oriented tier. **GPT-5.4**, **GPT-5.2**, **GPT-5**, **GPT-4.1**, and **o4-mini** are earlier tiers, retained for Workflows already benchmarked against them. GPT-5.4 brought roughly 1M-token context and configurable reasoning effort; GPT-4.1 remains a sensible mid-tier workhorse; o4-mini is the compact reasoning option with an efficient tokenizer for non-English text. Luna and Sol share a context window and a generation. A Global Workflow on Luna with Sol overridden at Folder level for customer-facing content is the configuration that gets the most out of this family. *** ## Anthropic Claude Consistently the strongest family for long-form coherence, register control, and terminology consistency across a document — the qualities that show up in human review rather than in automatic scores. The current lineup all carry a **1M-token context window with 128K max output** and adaptive thinking. On Anthropic's current tokenizer, 1M tokens is roughly 555,000 words. | Model | Provider tag | Anthropic positioning | Status | | - | - | - | - | | Claude 5 Fable | `anthropic/claude-fable-5` | Highest available capability; next-generation intelligence for long-running agents | **New** | | Claude 5 Opus | `anthropic/claude-opus-5` | Complex agentic and enterprise work | **New** | | Claude 5 Sonnet | `anthropic/claude-sonnet-5` | Best combination of speed and intelligence | **New** | | Claude 4.7 Opus | `anthropic/claude-opus-4.7` | Legacy | Available | | Claude 4.5 Opus | `anthropic/claude-opus-4.5` | Legacy | Available | | Claude 4.5 Sonnet | `anthropic/claude-4.5-sonnet` | Legacy | Available | | Claude 4 Sonnet | `claude` | Superseded | Available | All Claude models serve Document, Subtitle, and AI Dubbing Orders, and all support text and image input. **Claude 5 Fable** is Anthropic's highest-capability model. Its thinking is adaptive and always on, and its comparative latency is the slowest in the lineup. Reserve it for genuinely hard content — dense technical or legal source, structurally ambiguous material, or work where a second human pass would otherwise be needed. **Claude 5 Opus** offers the same 1M context and 128K output with the most recent knowledge cutoff in the family, and is the sensible default within Claude for quality-critical localization. **Claude 5 Sonnet** is positioned by Anthropic as the best combination of speed and intelligence. If a Workflow currently runs Claude 4 or 4.5 Sonnet, this is a straight upgrade. The **4.x tiers** remain available for existing benchmarks, each now matched or beaten by its Claude 5 equivalent. *** ## Google Gemini The most natively multimodal family in the catalog — text, images, audio, video, and PDF as first-class inputs — with million-token context windows across the current generation. | Model | Provider tag | Status at Google | Ollang status | | - | - | - | - | | Gemini 3.1 Pro Preview | `google/gemini-3.1-pro-preview` | Preview | **New** | | Gemini 3.7 Flash | `google/gemini-3.7-flash` | Stable | **New** | | Gemini 3 Pro Preview | `google/gemini-3-pro-preview` | Superseded | Available | | Gemini 2.5 Pro | `gemini` | Stable | Available | All Gemini models serve Document, Subtitle, and AI Dubbing Orders. **Gemini 3.7 Flash** is now a **stable** release rather than a preview. It carries a 1M-token context window with 64K output, accepts text, images, audio, and video, and has a knowledge cutoff of March 2026 — the most recent of any model in this catalog. It is the default recommendation within Gemini for most localization work. **Gemini 3.1 Pro Preview** is the reasoning flagship, with a 1M-token input window and a three-tier thinking control that trades latency against reasoning depth. Suited to very large documents and mixed-media source material processed in a single pass. **Gemini 2.5 Pro** remains stable and available. **Gemini 3 Pro Preview** has been superseded in Google's current model list by the 3.1 and 3.x Flash releases; it is retained here for Workflows already benchmarked against it. Gemini's multimodal input is the differentiator worth designing around: for Document Orders containing diagrams, screenshots, or scanned pages, it reads what text-only models silently skip. *** ## DeepL Purpose-built neural machine translation rather than a general-purpose LLM, across **240+ languages and variants** — the widest language coverage in the catalog. | Model | Provider tag | Order types | Status | | - | - | - | - | | DeepL | `deepl` | Document, Subtitle | Available | | DeepL Extended | `deepl_extended` | Document, Subtitle | Experimental | DeepL is the one family in this catalog that does **not** serve AI Dubbing Orders. Dubbing scripts need timing-aware, speakable output, which is outside what a pure NMT engine produces. DeepL is more steerable than "NMT" suggests. Its API supports **glossaries** (up to five per request), **translation memory** with adjustable matching thresholds, **style rules**, **formality** control, XML and HTML **tag handling**, a **context** parameter for text that influences the translation without being translated, and **custom instructions** — up to ten per request, 300 characters each. A `model_type` parameter selects between quality-optimized and latency-optimized behavior. Document translation preserves formatting across **docx, pptx, xlsx, pdf, html, txt, xliff, srt, idml, xml, json, dita,** and **mif**. **DeepL Extended** adds translation of **images embedded inside documents** — the difference between a translated PDF whose diagrams are still in the source language and one that is genuinely localized. *** ## Amazon Translate Neural machine translation across **75 languages and variants**, with the enterprise controls that come with AWS. | Model | Provider tag | Order types | | - | - | - | | Amazon AWS | `aws` | Document, Subtitle, AI Dubbing | Its case rests on four output controls rather than on model capability: **Custom Terminology**, which forces specific renderings of brand, product, and industry terms; **Active Custom Translation**, which adapts the engine using your own parallel data; **Formality**, which selects register in the languages that support it; and **Brevity**, which constrains output length — genuinely useful for subtitle work, where character limits bind and expansion into a longer target language breaks reading rates. **Profanity masking** is available where content standards require it. For organizations with a mature translation memory and hard terminology requirements, that combination is often worth more than a higher-capability general model that has to be re-steered on every Order. *** ## Cohere Enterprise-oriented models built for secure deployment, low latency, and predictable behavior in regulated environments. | Model | Provider tag | Context | Order types | | - | - | - | - | | Cohere Command-A | `cohere/command-a` | 256K | Document, Subtitle, AI Dubbing | Command A carries a **256K-token context window** and is built for tool use, agents, retrieval-augmented generation, and multilingual work. It covers the **23 languages of global business**: English, French, Spanish, Italian, German, Portuguese, Japanese, Korean, Arabic, Chinese, Russian, Polish, Turkish, Vietnamese, Dutch, Czech, Indonesian, Ukrainian, Romanian, Greek, Hindi, Hebrew, and Persian. Its strongest fit is **cross-lingual RAG** — pipelines where a translation must be grounded in and traceable to an internal source of truth. Its Arabic, Hebrew, Persian, and Central and Eastern European coverage is a genuine strength relative to models that treat those as long tail. Cohere also publishes **Command A Translate** (`command-a-translate-08-2025`), a dedicated machine translation model covering the same 23 languages. Ollang's `cohere/command-a` provider runs the general Command A model. *** ## Mistral | Model | Provider tag | Context | Order types | | - | - | - | - | | Mistral Medium 3.1 | `mistralai/mistral-medium-3.1` | 130K | Document, Subtitle, AI Dubbing | Mistral Medium 3.1 delivers translation and content generation across 50+ languages with a 130K-token context window and multimodal text-plus-image input. Its position here is efficiency — an instruction-following LLM tuned for throughput, which makes it a capable subtitle-translation workhorse for European language pairs. Mistral has **deprecated Medium 3.1 and 3.2** in favor of **Mistral Medium 3.5** (`mistral-medium-3505`), with retirement dates scheduled through mid-2026. Plan a migration for Workflows that depend on this provider. *** ## Qwen | Model | Provider tag | Context | Order types | | - | - | - | - | | Qwen3 | `qwen/qwen3-235b-a22b` | 262K | Document, Subtitle, AI Dubbing | Qwen3-235B-A22B is a mixture-of-experts model: **235B total parameters, 22B active per token**, routing across 128 experts with 8 activated at a time. It carries a **262,144-token native context window** — native rather than extended, so long-document behavior is what the model was trained for — and the Qwen3 family is trained across **119 languages and dialects**. Qwen reports substantial gains in long-tail knowledge coverage across multiple languages, which is the characteristic that matters for translation outside the top 20. The clearest reason to select it is **Chinese–English** work and long-tail language coverage. *** ## Llama | Model | Provider tag | Order types | | - | - | - | | Llama 4 | `llama` | Document, Subtitle | Llama 4 does not serve AI Dubbing Orders. Meta's first natively multimodal, mixture-of-experts open-weight generation. **Scout** runs 17B active parameters across 16 experts (109B total) with a **10M-token context window**; **Maverick** runs 17B active across 128 experts (400B total) with 1M. Both accept multilingual text and images and produce multilingual text and code. The constraint to design around is that official language support covers only 12 languages: Arabic, English, French, German, Hindi, Indonesian, Italian, Portuguese, Spanish, Tagalog, Thai, and Vietnamese. Outside those, quality falls off sharply against the 100+ language providers. Its knowledge cutoff is also the oldest here, at August 2024. *** ## Related Pipeline steps, provider tags, and status definitions. Steer any of these models with glossaries, guidelines, and translation memory. # Review, Editing, and Human Review Workflows Source: https://api-docs.ollang.com/review-editing-workflows Understand AI-only workflows, AI + Human Review workflows, assignment behavior, editing operations, and delivery logic inside the Ollang Project Management Dashboard. ## Overview The Ollang Project Management Dashboard supports both: * AI-only workflows, * and AI + Human Review workflows. This allows organizations to: * fully automate localization, * integrate internal reviewers, * assign external linguists, * onboard dubbing studios, * or combine AI and human review pipelines. The workflow selected during Order creation determines: * how the Order is processed, * who can review it, * and how final delivery occurs. *** # Workflow Types Fully AI-generated localization workflow that remains editable and assignable after generation. Workflow where human linguists or editors review, refine, and deliver the generated output. *** # AI-only Workflow ## Overview AI-only workflows generate localization outputs using AI orchestration pipelines without automatically assigning a human reviewer. However: * AI-only Orders remain editable, * rerunnable, * and assignable after generation. This means organizations can still: * internally review outputs, * assign linguists later, * or reprocess workflows if needed. *** # AI-only Workflow Behavior ```text theme={null} Source Asset ↓ AI Processing ↓ Generated Output ↓ Editable / Assignable / Downloadable ``` *** # Important Clarification AI-only does not mean the Order is locked or non-editable. Project Management Users can still: * edit outputs, * rerun workflows, * assign editors, * assign linguists, * or deliver outputs manually. *** # AI + Human Review Workflow ## Overview AI + Human Review workflows combine: * AI-generated localization, * with human editing and review operations. This workflow is commonly used for: * enterprise localization, * accessibility workflows, * high-visibility media, * regulated industries, * and premium localization pipelines. C11 *** # AI + Human Review Pipeline ```text theme={null} Source Asset ↓ AI Processing ↓ Human Assignment ↓ Editing / Review ↓ Final Delivery ``` *** # Human Review Assignment Logic Human review assignments will involve Ollang-managed reviewers. Organizations can request human review support from Ollang. *** # Example Assignment Workflow ```text theme={null} Project Manager creates Order ↓ AI generates output ↓ Ollang's Project assigns the order to a Linguist ↓ Linguist edits and delivers Order ``` *** # Editor Interface Editors and linguists perform operational review inside the: * Editor Interface. The Editor Interface supports: * subtitle editing, * transcription editing, * timing adjustments, * dubbing review, * speaker management, * and multilingual delivery operations. *** # Subtitle Editing Capabilities Editors can: * edit subtitle text, * modify timing, * split subtitle segments, * merge subtitle segments, * optimize CPS/CPL, * adjust readability, * and refine localization quality. *** # Dubbing Editing Workflows For AI Dubbing workflows, editors can: * review generated translations, * refine dialogue, * optimize pacing, * modify localized text, * and rerun synthesis workflows. Depending on the workflow: * resynthesis (Text-To-Speech Operations) may occur after edits. *** # Segment-Level Editing Behavior If a subtitle or dubbing segment is split: * edits operate at segment level. Example: ```text theme={null} Original segment: "Welcome to the platform." Segment split into: - "Welcome" - "to the platform." If one segment changes later: - only the edited segment may require regeneration. ``` *** # Human Delivery Workflow After editing is completed: * editors or linguists deliver the Order. Delivery updates: * Order status, * Project visibility, * and downstream operational workflows. The finalized outputs then appear inside: * the Project Management Dashboard. C1 *** # Review Visibility Rules Project Management Users generally have visibility into: * all organizational Projects, * all Folders, * and operational workflows. Editors and linguists only see: * explicitly assigned Orders. *** # Example Visibility Structure ```text theme={null} Folder contains: - 10 Projects - 200 Orders Editor assigned: - 5 Orders Result: - Editor only sees assigned Orders. ``` *** # AI QC and Human Review Human review workflows may operate alongside: * AI QC evaluation, * QC thresholds, * and workflow automation rules. Organizations may configure workflows such as: ```text theme={null} If QC score < threshold ↓ Automatically assign linguist ``` This enables: * scalable review operations, * automated escalation, * and multilingual QA workflows. C15 *** # Rerun Workflows Orders may be rerun after: * subtitle edits, * workflow changes, * translation refinements, * or synthesis adjustments. Rerunning may regenerate: * subtitles, * translations, * dubbing outputs, * or downstream deliverables. C16 *** # Studio Dubbing Review Workflows Studio Dubbing workflows support: * externally managed recording operations, * uploaded dubbing assets, * and final delivery coordination. Studios may: * upload final mixes, * upload dubbing vocals, * or coordinate delivery assets inside the platform. *** # AI QC Evaluation ## Overview AI QC Evaluation allows Project Management Users to automatically evaluate subtitle localization quality using configurable AI-based quality assessment. This workflow is currently available for: * Subtitle Translation Orders. The feature helps organizations: * evaluate localization quality, * identify linguistic weaknesses, * benchmark translation performance, * and improve multilingual consistency before delivery. *** # How AI QC Evaluation Works Project Management Users can run an AI-powered quality evaluation directly from the Order interface. C18 Workflow: ```text theme={null} Subtitle Order ↓ Click "QC Evaluation" ↓ Configure Evaluation Settings ↓ Select Model + Prompt ↓ Run Evaluation ↓ QC Results Generated ``` The system evaluates subtitle quality based on: * predefined evaluation criteria, * optional custom criteria, * selected evaluation model, * and prompting instructions. # Default Evaluation Criteria The platform currently includes four built-in evaluation dimensions: Evaluates whether the translation preserves the intended meaning of the source content. Evaluates readability, grammar, and natural language quality. Evaluates whether tone, voice, and intent remain consistent with the original content. Evaluates whether localized content feels contextually and culturally appropriate for the target audience. # Custom Evaluation Criteria Organizations may optionally define: * custom evaluation criteria. This allows teams to evaluate content based on: * brand guidelines, * legal requirements, * subtitle standards, * accessibility expectations, * or domain-specific localization rules. Example: ```text theme={null} Custom Criteria: "Medical Terminology Compliance" Prompt: Evaluate whether approved medical terminology was consistently preserved. ``` # AI QC Results Once evaluation is completed: The system generates: * QC scoring, * evaluation reasoning, * criteria-level analysis, * and quality observations. These results help organizations: * validate localization quality, * identify problem areas, * and decide whether human review is required. C19 *** # Human QC Annotation ## Overview Human QC Annotation enables linguists and editors to evaluate AI-generated subtitle output using structured quality tags. Unlike AI QC Evaluation: * Human QC Annotation is performed manually by a linguist during review. This workflow allows organizations to: * audit AI quality, * identify recurring issues, * benchmark linguistic weaknesses, * and improve future localization workflows. # When Human QC Annotation Happens Human QC Annotation occurs: ```text theme={null} AI generates subtitle Order ↓ Order assigned to linguist/editor ↓ Linguist reviews segments ↓ Annotations added where needed ↓ Order delivered ↓ Annotation Summary generated ``` This workflow is available only when: * Human QC Annotation is enabled in configuration settings. C20 C21 *** # Important Operational Behavior Linguists do not need to annotate every subtitle segment. Annotations are only added: * to segments where issues are identified. This keeps the workflow: * efficient, * scalable, * and operationally practical. C22 C23 # Human QC Categories Editors can tag subtitle segments using predefined categories: Used when translated meaning is incorrect or incomplete. Used when approved terminology or glossary usage is inconsistent. Used when AI introduces fabricated, missing, or unsupported content. Used when factual correctness or contextual truthfulness is affected. # Severity Levels Each annotation can additionally include: * severity classification. Available severity levels include: Small issue with limited localization impact. Significant issue affecting localization quality or readability. Severe issue requiring immediate correction. *** # Example Annotation Workflow Example subtitle segment: ```text theme={null} Source: "We launched the feature globally." AI Translation: "We launched the bug globally." ``` Human QC Annotation: ```text theme={null} Category: Accuracy Severity: Major Issue: Incorrect translation altered intended meaning. ``` *** # Annotation Summary Once the linguist delivers the Order: Project Management Users can access: * Human QC Annotation results. The platform generates an annotation summary including: * number of annotated segments, * category distribution, * severity distribution, * top recurring issues, * and localization quality insights. C24 C25 # Example Annotation Summary ```text theme={null} Human QC Annotation Summary Segments Reviewed: 245 Annotated Segments: 18 Category Distribution: - Accuracy: 8 - Terminology: 5 - Hallucination: 3 - Verity: 2 Severity Distribution: - Minor: 10 - Major: 6 - Critical: 2 ``` # Exporting Annotation Reports Human QC Annotation reports can be downloaded as: * Excel (.xlsx) This enables: * enterprise auditing, * vendor benchmarking, * linguist performance reviews, * and multilingual quality reporting. *** # AI QC vs Human QC Annotation Automated evaluation using configurable prompts, models, and quality criteria. Manual linguist-driven quality tagging performed during subtitle review. Organizations commonly combine both workflows to benchmark AI quality while also collecting human linguistic feedback. # Important Operational Notes Yes. AI-only Orders remain editable, rerunnable, and assignable to the inner team members after generation. Yes. Orders may be assigned internally or externally depending on operational workflows. Yes. Organizations may onboard their own editors, linguists, agencies, or dubbing studios. Yes. Human review support can also be coordinated through Ollang-managed linguists. No. Editors only see explicitly assigned Orders. Yes. Orders may be rerun after workflow modifications, translation changes, or dubbing refinements. # Review Gates Source: https://api-docs.ollang.com/review-gates ## What are Review Gates? Review Gates allow you to introduce human review checkpoints into your localization workflow before an order proceeds to the next processing stage. Instead of automatically moving from one step to the next, the order pauses for review and resumes only after the configured review gate has been completed. Review Gates can be configured after: * Closed Caption (CC) generation * Subtitle Translation generation Review Gates can be configured globally, at the folder level, or within Workflow Templates. *** # Types of Review Gates There are two primary types of Review Gates: 1. **Assignment Review Gate** 2. **Comment Review Gate** *** # Assignment Review Gate Assignment Review Gates are used when a reviewer needs to **edit and deliver** the order before the workflow continues. Typical examples include: * Subtitle review * Closed Caption review Unlike Comment Review Gates, reviewers actively modify the content and deliver the order. *** ## Assignment Routing Options Assignment Review Gates support two routing methods. ### 1. QC Threshold The system first performs an AI Quality Check (QC) on the generated output. The resulting QC score is compared against the configured threshold. Example: QC Threshold = **80** * QC Score = 91 → Review Gate is skipped and the workflow continues automatically. * QC Score = 74 → Order is assigned for human review. ### Forcing Human Review Many customers configure the QC Threshold as **100%**. Since an order cannot exceed a QC score of 100, this effectively forces every order through the Assignment Review Gate. This is currently the recommended approach when every transcription or subtitle order must be reviewed before the workflow continues. ### 2. LLM Judge Instead of evaluating translation quality, the system can use an LLM to decide whether an order requires human review. You define your own prompt describing the conditions that require review. Example: > "If the translated content contains medical terminology, pharmaceutical language, or regulatory content, assign the order to the Medical Review Team." Another example: > "If the translated content relates to sports, assign the order to the Sports Reviewer." The LLM evaluates the completed order against the prompt. If the condition is met, the order is assigned for review. Otherwise, the Review Gate is skipped and the workflow continues automatically. This routing method is ideal when review decisions depend on the content itself rather than a quality score. *** # LSP Assignment Workflow When an Assignment Review Gate is assigned to an LSP reviewer, the workflow behaves as follows. ## Step 1 – Order enters Review After the configured workflow step completes (for example, Subtitle Translation), the order enters **Review** status. The order is automatically assigned to the configured LSP reviewer tag. Initially, the order appears in the **LSP Admin's** queue. Image Image ## Step 2 – Assign to an LSP Linguist The **LSP Admin** or the **LSP Project Manager** can assign the order to an **LSP Linguist**. Image Image Once assigned: * The linguist receives an email notification. Image * The order appears in their assigned work queue. * The linguist can open the editor and begin reviewing or editing the content. *** ## Step 3 – LSP Linguist completes the review The LSP Linguist reviews the content, makes any necessary edits, and delivers the order. Image Image At this point, the review is **not yet complete**. Instead, the order returns to the **LSP Admin** or **LSP Project Manager** for final approval. Image *** ## Step 4 – Final approval The **LSP Admin** or **LSP Project Manager** reviews the linguist's work and delivers the order. Only after this approval is the Assignment Review Gate considered complete. The workflow then automatically proceeds to the next configured stage. *** # Comment Review Gate Comment Review Gates are designed for reviewers who only need to provide **feedback or approval**, without editing the order itself. Image Typical use cases include: * Creative Review * Medical Review * Legal Review * Brand Approval * Client Approval Instead of editing the content, reviewers open the order, review it, and submit their comments or approval. Once the required comment or approval is submitted, the Comment Review Gate is completed and the workflow automatically proceeds to the next review stage or processing step. Image Example workflow: ```text theme={null} Subtitle Translation ↓ Creative Review ↓ Medical Review ↓ AI Dubbing ``` *** # Combining Assignment and Comment Review Gates Review Gates can be chained together to support multi-stage review workflows. For example: ```text theme={null} Subtitle Translation ↓ Assignment Review (LSP) ↓ Creative Review ↓ Medical Review ↓ AI Dubbing ``` Workflow: 1. AI completes Subtitle Translation. 2. The Assignment Review Gate routes the order to the LSP. 3. The LSP Linguist reviews the content. 4. The LSP Admin or Project Manager performs the final approval. 5. The order automatically proceeds to the Creative Review. 6. After Creative Review is completed, the order proceeds to the Medical Review. 7. Once all review gates have been completed, the workflow continues to AI Dubbing Image # Understanding Order Status One common question is: **"Why does my order still show 'Review' even though the LSP has already completed their work?"** This is expected behavior. The Assignment Review Gate may be complete, but the workflow can still contain additional review stages. For example: ```text theme={null} Subtitle Translation ↓ LSP Review ✓ ↓ Creative Review (Current) ↓ Medical Review ``` From the LSP's perspective, their work has been completed. However, because the order is currently being reviewed by another reviewer (for example, the Creative Reviewer), the overall order status remains **Review**. Only after **all configured Review Gates** have been completed will the workflow continue to the next processing stage or reach the **Completed** status. *** # Best Practices * Use **Assignment Review Gates** whenever reviewers need to edit or approve content before the workflow continues. * Use **Comment Review Gates** when reviewers only need to provide feedback or approval. * Configure a **QC Threshold of 100%** if every order must undergo human review. * Use **LLM Judge** when review decisions depend on the content rather than translation quality. * For AI Dubbing workflows, place an Assignment Review Gate after Subtitle Translation to ensure subtitles are reviewed before audio generation begins. # Features Source: https://api-docs.ollang.com/sdk/features Ollang Asset Management, Browser CMS capture, and Node.js API capabilities. # Ollang SDK Features The SDK provides three main entry points: the **Ollang Asset Management** for local project workflows, the **Browser SDK** for CMS content capture, and the **Node.js API** for programmatic access. ## Ollang Asset Management The Asset Management combines a local Node.js server with a React control panel to manage translations for your codebase. It works with i18n JSON files, hardcoded strings, videos, images, and audio. ### What Asset Management Does | Feature | Description | | - | - | | **Project Scan** | Detects i18n strings, hardcoded text, videos, images, and audio in your project. | | **Folder-Based Workspaces** | Create separate folders (e.g., "local-project", "cms-content") to keep content isolated. | | **Kanban Workflow** | Track items through Scanned → Translating → Translated → Submitted. | | **Sync with Codebase** | Apply translations back to JSON files; detect manual changes and sync status. | | **Multi-Language** | Translate to multiple target languages in one flow. | ### Running the Asset Management UI The Asset Management server hosts a web control panel. When you run `npx @ollang-dev/sdk start`, it: 1. Starts the Node server (default port **5972**) 2. Opens `http://localhost:5972` in your browser 3. Serves the control panel where you can scan, translate, and apply The server runs from your project root. Set `OLLANG_API_KEY`, `OLLANG_PROJECT_ID`, and optionally `ollang.config.ts` for source/target languages and project root. ### Configuration Configure Asset Management via environment variables or `ollang.config.ts` in your project root: ```typescript ollang.config.ts theme={null} export default { projectRoot: "/xxx/xxx/xxx/xxx/xxx", sourceLanguage: "en", targetLanguages: ["tr", "ko", "es"], video: { translationType: "aiDubbing" as "aiDubbing" | "subtitle", }, }; ``` *** ## Browser SDK The Browser SDK captures CMS content (e.g., Strapi, custom headless CMS) directly from your live site. It injects a script into your page and intercepts API calls to detect translatable content. ### How It Works 1. Add the Ollang Browser script to your CMS-powered site. 2. Append `?ollang-localize=true` to the URL to enable capture mode. 3. The script shows a debug panel and captures content as you navigate. 4. Push content to Ollang from the control panel. ### Including the Browser SDK ```html theme={null} ``` Or with a config object: ```html theme={null} ``` ### Opening CMS Capture Mode 1. Run Asset Management server: `npx @ollang-dev/sdk start` 2. Open the control panel at `http://localhost:5972` 3. Create or select a **CMS folder** from the folder dropdown 4. Open your CMS site in another tab with `?ollang-localize=true` appended 5. The debug panel appears; content is captured as you browse *** ## Node.js API For programmatic use, import `@ollang-dev/sdk` and use the Ollang client: ```typescript theme={null} import { Ollang } from '@ollang-dev/sdk'; const ollang = new Ollang({ apiKey: process.env.OLLANG_API_KEY, baseUrl: 'https://api-integration.ollang.com', }); // Upload a source file, which creates the project for it const upload = await ollang.uploads.direct({ file: new Blob([bytes]), filename: 'video.mp4', name: 'My Video', sourceLanguage: 'en', }); // Create translation orders against it const order = await ollang.orders.create({ orderType: 'subtitle', level: 0, projectId: upload.projectId, targetLanguageConfigs: [{ language: 'fr', isRush: false }], }); // Manage projects const projects = await ollang.projects.list(); // Scan sessions for Asset Management const session = await ollang.scans.getOrCreateSession(projectId, folderName); ``` See [Node.js Library](/sdk/node) for the full surface, including how the uploaded file's name is chosen. ### Available Modules | Module | Purpose | | - | - | | `ollang.orders` | Create, list, cancel, review and export translation orders | | `ollang.projects` | Create, list and inspect projects | | `ollang.uploads` | Upload source files (video, document, VTT; JPEG/JPG/PNG for Image to Image) | | `ollang.folders` | Browse folders and act on all their orders at once | | `ollang.revisions` | Create and manage revision requests | | `ollang.memories` | Translation memories and their items | | `ollang.customInstructions` | Manage translation guidelines | | `ollang.content` | Import and export translation units | | `ollang.billing` | Credit wallet and consumption history | | `ollang.locales` | Resolve and validate language codes | | `ollang.figma` | Import Figma files and track their orders | | `ollang.scans` | Get/create scan sessions, create/update scans (Asset Management backend) | | `ollang.cms` | CMS-specific endpoints | *** ## Folder-Based Workflows Asset Management supports multiple folders per project. Use them to separate: * **Local project** — i18n, hardcoded strings, local media * **CMS content** — Content pushed from the browser (Strapi, custom CMS) Each folder has its own scan state and Kanban board. Content does not mix between folders. *** ## Next Steps Install, configure, and run your first scan. REST API for orders, uploads, and projects. # Java Library Source: https://api-docs.ollang.com/sdk/java Official Java client library for the Ollang API. # Java Library The official Java library wraps the whole Ollang integration API — projects, uploads, orders, folders, revisions, translation memories, custom instructions, content, billing, locales and Figma — using the JDK's built-in HTTP client, with [Gson](https://github.com/google/gson) as the only runtime dependency. Source code lives in the [`java/` directory of the SDK repository](https://github.com/ollang/sdk/tree/main/java). Requires Java 11+. ## Installation Maven: ```xml theme={null} com.ollang ollang-sdk 0.2.1 ``` Gradle: ```groovy theme={null} implementation 'com.ollang:ollang-sdk:0.2.1' ``` ## Authentication 1. Sign up or log in at [Olabs](https://lab.ollang.com) 2. Create or select a project 3. Generate an API key from project settings ```java theme={null} import com.ollang.sdk.Ollang; Ollang ollang = Ollang.builder() .apiKey(System.getenv("OLLANG_API_KEY")) .build(); ``` ## Quick Start ```java theme={null} import com.google.gson.JsonElement; import com.google.gson.JsonObject; import com.google.gson.JsonParser; import com.ollang.sdk.Ollang; import java.nio.file.Path; Ollang ollang = Ollang.builder() .apiKey(System.getenv("OLLANG_API_KEY")) .build(); // Upload a file (creates a project) JsonElement upload = ollang.uploads().direct(Path.of("video.mp4"), "My Video", "en"); String projectId = upload.getAsJsonObject().get("projectId").getAsString(); // Create an order JsonObject params = new JsonObject(); params.addProperty("orderType", "cc"); params.addProperty("level", 1); params.addProperty("projectId", projectId); params.add("targetLanguageConfigs", JsonParser.parseString( "[{\"language\":\"fr\",\"isRush\":false},{\"language\":\"de\",\"isRush\":false}]")); JsonElement orders = ollang.orders().create(params); // Check order status String orderId = orders.getAsJsonArray().get(0).getAsJsonObject().get("orderId").getAsString(); JsonElement status = ollang.orders().get(orderId); System.out.println(status); ``` ### Naming the uploaded file The platform takes the stored file's extension from the name the file is sent under, and rejects an upload it cannot get one from. The `Path` overloads use the file's own name; the in-memory overload takes it as an argument: ```java theme={null} ollang.uploads().direct(bytes, "en.json", "App strings", "en", null); ``` The third argument is the display name for the created project; it does not need an extension of its own. ### Uploading VTT subtitles The VTT overloads take a source project ID and a display name, replacing the old order ID argument. Source language comes from the project; the response contains `projectId`. ```java theme={null} ollang.uploads().vtt(Path.of("subtitles.vtt"), projectId, "Subtitles"); ollang.uploads().vtt(bytes, "subtitles.vtt", projectId, "Subtitles"); ``` ## Resources | Resource | Description | | - | - | | `ollang.projects()` | Create, read and list projects | | `ollang.uploads()` | Upload files, or register remote ones by URL | | `ollang.orders()` | Create, track, review and export orders | | `ollang.folders()` | Browse folders and act on all their orders at once | | `ollang.revisions()` | Request revisions on completed orders | | `ollang.memories()` | Translation memories and their items | | `ollang.customInstructions()` | Set custom translation instructions | | `ollang.content()` | Import and export translation units | | `ollang.billing()` | Credit wallet and consumption history | | `ollang.locales()` | Resolve and validate language codes | | `ollang.figma()` | Import Figma files and track their orders | All methods return the parsed JSON response as a Gson `JsonElement`. Non-2xx responses throw `OllangApiException`, which carries the HTTP status code and the response body (raw and parsed). ## More Examples ```java theme={null} import com.ollang.sdk.resources.Orders; // List orders with pagination and filters JsonElement page = ollang.orders().list( new Orders.ListOptions().page(1).take(20).status("completed")); // Request a revision on an order ollang.revisions().create("ORDER_ID", "wrongSubtitle", "00:01:23", "Fix the terminology here"); // Custom instructions ollang.customInstructions().create("tone", "Formal, brand-safe tone", null); ``` ### Resolve a language code Order and project creation match language codes exactly, so resolve anything uncertain instead of guessing at a region subtag. ```java theme={null} JsonElement matches = ollang.locales().search("portu"); JsonElement check = ollang.locales().validate("pt-PT"); ``` ### Translation memories ```java theme={null} JsonElement memory = ollang.memories().create("Brand terms"); String memoryId = memory.getAsJsonObject().get("id").getAsString(); JsonElement job = ollang.memories().importItems( memoryId, List.of(Map.of( "sourceLanguage", "en", "targetLanguage", "fr", "sourceText", "Sign in", "targetText", "Se connecter"))); // Importing is asynchronous — poll the job for progress String jobId = job.getAsJsonObject().get("jobId").getAsString(); JsonElement progress = ollang.memories().getImportJob(jobId); ``` ### Folders ```java theme={null} import com.ollang.sdk.resources.Folders; JsonElement folders = ollang.folders().list(new Folders.ListOptions().page(1).take(20)); JsonElement pairs = ollang.folders().orderLanguagePairs("FOLDER_ID", "completed"); // Assign a translator to every French order in the folder ollang.folders().assignTranslator("FOLDER_ID", "TRANSLATOR_ID", "2026-06-01", null, "fr"); ``` ### Billing ```java theme={null} import com.ollang.sdk.resources.Billing; JsonElement wallet = ollang.billing().credits(); JsonElement usage = ollang.billing().consumption( new Billing.ConsumptionOptions().page(1).take(20).from("2026-01-01").provider("deepl")); ``` ### Large remote files `createByUrl` hands the platform a URL to fetch server-side, so the bytes never pass through your process and there is no practical size ceiling. ```java theme={null} JsonElement project = ollang.projects().createByUrl( "https://example.com/video.mp4", "Launch video", "en"); ``` ### XLSX exports The export endpoints return raw bytes. Each has a `...ToFile` companion that writes the workbook to a path, creating parent directories as needed. ```java theme={null} byte[] data = ollang.orders().exportXlsx("ORDER_ID"); ollang.orders().exportXlsxToFile("ORDER_ID", Path.of("out/order.xlsx")); ollang.folders().exportXlsxToFile( List.of("FOLDER_ID"), List.of("fr", "de"), Path.of("out/folders.xlsx")); ``` The underlying HTTP client stays available for anything not wrapped yet: `ollang.client().get("/integration/orders")`. See the full [API reference](/apis/ollang-api-reference/direct-file-upload) for every endpoint. # Node.js Library Source: https://api-docs.ollang.com/sdk/node Use the official TypeScript/Node.js SDK as an API client for the Ollang API. # Node.js Library The official TypeScript/Node.js package, `@ollang-dev/sdk`, doubles as a plain API client for the whole Ollang integration API — projects, uploads, orders, folders, revisions, translation memories, custom instructions, content, billing, locales and Figma — with full TypeScript types. This page covers that programmatic use; the [Quick Start](/sdk/quickstart) and [Features](/sdk/features) pages cover the Asset Management UI and Browser SDK that ship in the same package. Source code lives in the [SDK repository](https://github.com/ollang/sdk). Node.js 18+ is recommended. ## Installation ```bash theme={null} npm install @ollang-dev/sdk ``` ## Authentication 1. Sign up or log in at [Olabs](https://lab.ollang.com) 2. Create or select a project 3. Generate an API key from project settings ```typescript theme={null} import { Ollang } from "@ollang-dev/sdk"; const ollang = new Ollang({ apiKey: process.env.OLLANG_API_KEY! }); ``` ## Quick Start ```typescript theme={null} import { readFile } from "node:fs/promises"; import { Ollang } from "@ollang-dev/sdk"; const ollang = new Ollang({ apiKey: process.env.OLLANG_API_KEY! }); // Upload a file (creates a project) const upload = await ollang.uploads.direct({ file: new Blob([await readFile("./video.mp4")]), filename: "video.mp4", name: "My Video", sourceLanguage: "en", }); // Create an order const order = await ollang.orders.create({ orderType: "cc", level: 1, projectId: upload.projectId, targetLanguageConfigs: [ { language: "fr", isRush: false }, { language: "de", isRush: false }, ], }); // Check order status const status = await ollang.orders.get(order.id); console.log(status); // Download links, once the order completes for (const doc of status.orderDocs ?? []) { console.log(doc.type, doc.name, doc.url); } ``` `Ollang` is a named export. It is also the default export, so `import Ollang from "@ollang-dev/sdk"` works too — but versions up to 0.4.0 only exported it by name, and the default import threw `Ollang is not a constructor` there. `import { Ollang }` works on every version. ### Naming the uploaded file The platform takes the stored file's extension from the name the file is sent under, and rejects an upload it cannot get one from. A `File` carries its own name; a bare `Blob` does not, so pass `filename` alongside it: ```typescript theme={null} await ollang.uploads.direct({ file: new Blob([JSON.stringify(strings)]), filename: "en.json", name: "App strings", sourceLanguage: "en", }); ``` `Blob` with `filename` is the portable form. `File` is only a global from Node 20 onwards — on Node 18 `new File(...)` throws `ReferenceError: File is not defined`, and importing `File` from `node:buffer` is not a substitute here, as it does not satisfy the parameter's TypeScript type. A global `File` works fine where it exists, and its own name is used when `filename` is omitted. `name` is the display name for the created project. The extension is appended to it if it does not already end in one, so `name: "App strings"` above is stored as `App strings.json`. ### Uploading VTT subtitles Pass the source `projectId` returned by the upload and a `name`, rather than an order ID. The response contains `projectId`. Source language defaults to the project's language; Node and Python also accept an explicit override. ```typescript theme={null} const subtitles = await ollang.uploads.vtt({ file: new Blob([await readFile('./subtitles.vtt')]), projectId: upload.projectId, name: 'Subtitles', }); console.log(subtitles.projectId); ``` ## Resources | Resource | Description | | - | - | | `ollang.projects` | Create, read and list projects | | `ollang.uploads` | Upload files, or register remote ones by URL | | `ollang.orders` | Create, track, review and export orders | | `ollang.folders` | Browse folders and act on all their orders at once | | `ollang.revisions` | Request revisions on completed orders | | `ollang.memories` | Translation memories and their items | | `ollang.customInstructions` | Set custom translation instructions | | `ollang.content` | Import and export translation units | | `ollang.billing` | Credit wallet and consumption history | | `ollang.locales` | Resolve and validate language codes | | `ollang.figma` | Import Figma files and track their orders | | `ollang.scans` | Scan sessions used by Asset Management | | `ollang.cms` | CMS integration endpoints | All methods return typed, parsed JSON responses. Non-2xx responses reject with the underlying HTTP error, which carries the response status and body. ## More Examples ```typescript theme={null} // List orders with pagination and filters const page = await ollang.orders.list({ pageOptions: { page: 1, take: 20 }, filter: { status: "completed" }, }); for (const order of page.data) { console.log(order.id, order.status); } // Request a revision on an order await ollang.revisions.create("ORDER_ID", { type: "other", time: "00:01:23", description: "Fix the terminology in this segment", }); // Custom instructions await ollang.customInstructions.create({ key: "tone", value: "Formal, brand-safe tone for all marketing content", }); ``` ### Resolve a language code Order and project creation match language codes exactly, so resolve anything uncertain instead of guessing at a region subtag. ```typescript theme={null} const matches = await ollang.locales.search("portu"); const check = await ollang.locales.validate("pt-PT"); ``` ### Translation memories ```typescript theme={null} const memory = await ollang.memories.create("Brand terms"); const job = await ollang.memories.importItems(memory.id, [ { sourceLanguage: "en", targetLanguage: "fr", sourceText: "Sign in", targetText: "Se connecter", }, ]); // Importing is asynchronous — poll the job for progress const progress = await ollang.memories.getImportJob(job.jobId); // Reuse a memory when creating an order await ollang.orders.create({ orderType: "document", level: 1, projectId: "PROJECT_ID", targetLanguageConfigs: [{ language: "fr" }], selectedMemories: [memory.id], }); ``` ### Folders ```typescript theme={null} const folders = await ollang.folders.list({ pageOptions: { page: 1, take: 20 } }); const pairs = await ollang.folders.orderLanguagePairs("FOLDER_ID", "completed"); // Assign a translator to every French order in the folder await ollang.folders.assignTranslator("FOLDER_ID", { translatorId: "TRANSLATOR_ID", targetLanguage: "fr", deadline: "2026-06-01", }); ``` ### Billing ```typescript theme={null} const wallet = await ollang.billing.credits(); const usage = await ollang.billing.consumption({ pageOptions: { page: 1, take: 20 }, filter: { from: "2026-01-01", provider: "deepl" }, }); ``` ### Large remote files `createByUrl` hands the platform a URL to fetch server-side, so the bytes never pass through your process and there is no practical size ceiling. ```typescript theme={null} const project = await ollang.projects.createByUrl({ url: "https://example.com/video.mp4", name: "Launch video", sourceLanguage: "en", }); ``` ### XLSX exports The export endpoints resolve to a `Buffer` rather than JSON. Each has a `...ToFile` companion that writes the workbook to a path, creating parent directories as needed. ```typescript theme={null} const data = await ollang.orders.exportXlsx("ORDER_ID"); await ollang.orders.exportXlsxToFile("ORDER_ID", "out/order.xlsx"); await ollang.folders.exportXlsxToFile( { folderIds: ["FOLDER_ID"], targetLanguages: ["fr", "de"] }, "out/folders.xlsx" ); ``` The underlying HTTP client stays available for anything not wrapped yet: `ollang.getClient().get("/integration/orders")`. See the full [API reference](/apis/ollang-api-reference/direct-file-upload) for every endpoint. # Ollang SDK Source: https://api-docs.ollang.com/sdk/overview Official TypeScript/Node.js SDK for Ollang – Translation Management, Browser CMS Capture, Orders, and API Integration. # Ollang SDK The **Ollang SDK** (`@ollang-dev/sdk`) is the official TypeScript/Node.js library for integrating Ollang's translation and localization platform into your projects. Use it to scan i18n files, manage translations, capture CMS content in the browser, and programmatically create orders. Install, configure, and run your first scan in minutes. Asset Management, Browser SDK, Node API, and more. ## What's Included The SDK provides three main integration points: | Component | Use Case | Package | | - | - | - | | **Ollang Asset Management** | Scan i18n files, translate, apply to codebase | `@ollang-dev/sdk` | | **Browser SDK** | Capture CMS content (Strapi, etc.) in the browser | `@ollang-dev/sdk/browser` | | **Node API Client** | Create orders, manage projects, upload files programmatically | `@ollang-dev/sdk` | ## Key Features * **Local i18n scanning** — Detect hardcoded strings, i18n keys, videos, images, and audio in your codebase * **Translation workflow** — Translate selected items via Ollang, apply results back to files * **CMS content capture** — Integrate with Strapi or custom CMS; capture content in-browser for translation * **Folder-based organization** — Keep local and CMS content separate with named folders * **Kanban-style UI** — Visual dashboard (Scanned → Translating → Translated → Submitted) * **REST API client** — Orders, projects, folders, uploads, revisions, memories, custom instructions, content, billing, locales and Figma ## Prerequisites * **Node.js** 16 or higher * An [Ollang account](https://lab.ollang.com) and API key * For Asset Management: a project with i18n files (Next.js, React, Vue, or custom) * For Browser: a website with CMS content (e.g., Strapi) ## Architecture ```mermaid theme={null} flowchart TD subgraph Project["Your Project"] direction LR subgraph SDK["@ollang-dev/sdk"] NodeAPI["Node API Client
(Asset Management)"] end subgraph BrowserSDK["@ollang-dev/sdk/browser"] Browser["Browser SDK
(CMS Capture)"] end subgraph LocalServer["npx @ollang-dev/sdk start"] Server["Local Server"] end end Project -->|X-Api-Key auth| OllangAPI["Ollang Integration API
(orders, uploads, etc.)"] NodeAPI -.-> Server Browser -.-> Server ``` ## Next Steps Get the Asset Management running and perform your first scan. Deep dive into Asset Management, Browser SDK, and Node API. # Python Library Source: https://api-docs.ollang.com/sdk/python Official Python client library for the Ollang API. # Python Library The official Python library wraps the whole Ollang integration API — projects, uploads, orders, folders, revisions, translation memories, custom instructions, content, billing, locales and Figma — in a simple, Pythonic client. Source code lives in the [`python/` directory of the SDK repository](https://github.com/ollang/sdk/tree/main/python). ## Installation ```bash theme={null} pip install ollang-sdk ``` Requires Python 3.8+. The only dependency is `requests`. ## Authentication 1. Sign up or log in at [Olabs](https://lab.ollang.com) 2. Create or select a project 3. Generate an API key from project settings ```python theme={null} from ollang import Ollang client = Ollang(api_key="your-api-key") ``` ## Quick Start ```python theme={null} from ollang import Ollang client = Ollang(api_key="your-api-key") # Upload a file (creates a project) upload = client.uploads.direct( "./video.mp4", name="My Video", source_language="en", ) # Create an order orders = client.orders.create( order_type="cc", level=1, project_id=upload["projectId"], target_language_configs=[ {"language": "fr", "isRush": False}, {"language": "de", "isRush": False}, ], ) # Check order status status = client.orders.get(orders[0]["orderId"]) print(status) # Download links, once the order completes for doc in status.get("orderDocs", []): print(doc["type"], doc["name"], doc["url"]) ``` ### Naming the uploaded file The platform takes the stored file's extension from the name the file is sent under, and rejects an upload it cannot get one from. A path supplies it; raw bytes and in-memory streams do not, so pass `filename` alongside them: ```python theme={null} client.uploads.direct( json.dumps(strings).encode(), name="App strings", source_language="en", filename="en.json", ) ``` `name` is the display name for the created project; it does not need an extension of its own. ### Uploading VTT subtitles Pass `project_id` and `name` instead of the old `order_id` argument. The API attaches subtitles to a project and returns `projectId`; source language defaults to the project's language. ```python theme={null} subtitles = client.uploads.vtt( './subtitles.vtt', project_id=upload["projectId"], name="Subtitles" ) print(subtitles["projectId"]) ``` ## Resources | Resource | Description | | - | - | | `client.projects` | Create, read and list projects | | `client.uploads` | Upload files, or register remote ones by URL | | `client.orders` | Create, track, review and export orders | | `client.folders` | Browse folders and act on all their orders at once | | `client.revisions` | Request revisions on completed orders | | `client.memories` | Translation memories and their items | | `client.custom_instructions` | Set custom translation instructions | | `client.content` | Import and export translation units | | `client.billing` | Credit wallet and consumption history | | `client.locales` | Resolve and validate language codes | | `client.figma` | Import Figma files and track their orders | All methods return the parsed JSON response as plain dicts and lists. Non-2xx responses raise `ollang.OllangAPIError`, which carries `status_code` and the parsed error `body`. ## More Examples ```python theme={null} # List orders with pagination and filters page = client.orders.list(page=1, take=20, status="completed") for order in page["data"]: print(order["id"], order.get("status")) # Request a revision on an order client.revisions.create( order_id="ORDER_ID", type="wrongSubtitle", time="00:01:23", description="Fix the terminology in this segment", ) # Custom instructions client.custom_instructions.create( key="tone", value="Formal, brand-safe tone for all marketing content", ) ``` ### Resolve a language code Order and project creation match language codes exactly, so resolve anything uncertain instead of guessing at a region subtag. ```python theme={null} matches = client.locales.search("portu") check = client.locales.validate("pt-PT") ``` ### Translation memories ```python theme={null} memory = client.memories.create("Brand terms") job = client.memories.import_items( memory["id"], [ { "sourceLanguage": "en", "targetLanguage": "fr", "sourceText": "Sign in", "targetText": "Se connecter", } ], ) # Importing is asynchronous — poll the job for progress print(client.memories.get_import_job(job["jobId"])["status"]) # Reuse a memory when creating an order client.orders.create( order_type="document", level=1, project_id="PROJECT_ID", target_language_configs=[{"language": "fr"}], selected_memories=[memory["id"]], ) ``` ### Folders ```python theme={null} folders = client.folders.list(page=1, take=20) pairs = client.folders.order_language_pairs("FOLDER_ID", status="completed") # Assign a translator to every French order in the folder client.folders.assign_translator( "FOLDER_ID", translator_id="TRANSLATOR_ID", target_language="fr", deadline="2026-06-01", ) ``` ### Billing ```python theme={null} wallet = client.billing.credits() usage = client.billing.consumption(page=1, take=20, from_="2026-01-01", provider="deepl") ``` ### Large remote files `create_by_url` hands the platform a URL to fetch server-side, so the bytes never pass through your process and there is no practical size ceiling. ```python theme={null} project = client.projects.create_by_url( url="https://example.com/video.mp4", name="Launch video", source_language="en", ) ``` ### XLSX exports The export endpoints return raw `bytes`. Each has a `..._to_file` companion that writes the workbook to a path, creating parent directories as needed. ```python theme={null} data = client.orders.export_xlsx("ORDER_ID") client.orders.export_xlsx_to_file("ORDER_ID", "out/order.xlsx") client.folders.export_xlsx_to_file(["FOLDER_ID"], ["fr", "de"], "out/folders.xlsx") ``` The underlying HTTP client stays available for anything not wrapped yet: `client.client.get("/integration/orders")`. See the full [API reference](/apis/ollang-api-reference/direct-file-upload) for every endpoint. # Quick Start Source: https://api-docs.ollang.com/sdk/quickstart Get Ollang SDK running locally in under 5 minutes. # Quick Start This guide walks you through installing the Ollang SDK, configuring your project, starting the Asset Management interface, and (optionally) enabling the browser CMS capture. ## 1. Install the SDK ```bash theme={null} npm install @ollang-dev/sdk ``` Or with yarn: ```bash theme={null} yarn add @ollang-dev/sdk ``` ## 2. Get Your API Key 1. Sign up or log in at [Olabs](https://lab.ollang.com) 2. Create or select a project 3. Generate an API key from project settings 4. Set it in your environment: ```bash theme={null} export OLLANG_API_KEY="your-api-key" ``` ## 3. Configure Your Project In your project root, create `ollang.config.ts`: ```typescript theme={null} // ollang.config.ts export default { projectRoot: "/xxx/xxx/xxx/xxx/xxx", sourceLanguage: "en", targetLanguages: ["tr", "ko", "es"], video: { translationType: "aiDubbing" as "aiDubbing" | "subtitle", }, }; ``` ## 4. Start the Asset Management Interface From your project root, run: ```bash theme={null} npx @ollang-dev/sdk start ``` This starts the Ollang Asset Management server. The control panel opens automatically in your browser at: ``` http://localhost:5972 ``` If the browser doesn't open automatically, visit [http://localhost:5972](http://localhost:5972) manually. ### What the Asset Management Does * **Scans** your i18n files (JSON, YAML), hardcoded strings, videos, images, and audio * **Shows** a Kanban board (Scanned → Translating → Translated → Submitted) * **Sends** selected items to Ollang for translation * **Applies** translations back to your codebase ## 5. Run Your First Scan 1. In the Asset Management UI, enter your API key if prompted 2. Select a **folder** (or create one, e.g. `local-test`) for local project content 3. Click **Scan Project** 4. Wait for the scan to complete — items appear in the Scanned column 5. Select items, choose a target language, and click **Translate** ## 6. Browser CMS Capture (Optional) For CMS content (e.g., Strapi), add the Browser SDK to your site. ### Install the script Add to your HTML, before ``: ```html theme={null} ``` Or configure programmatically: ```html theme={null} ``` ### Open the browser for CMS capture 1. Visit your site with `?ollang-localize=true` in the URL 2. The debug panel appears; use it to capture CMS content 3. Push content to Ollang; it appears in the Asset Management under the CMS folder ## Ports and URLs | Service | Default URL | | - | - | | Asset Management Control Panel | [http://localhost:5972](http://localhost:5972) | | Asset Management API (internal) | [http://localhost:5972/api/\\](http://localhost:5972/api/\\)\* | Use `ASSET_MANAGEMENT_PORT` to change the port: ```bash theme={null} ASSET_MANAGEMENT_PORT=8080 npx @ollang-dev/sdk start ``` ### CORS and allowed origins By default, the Asset Management server allows common local dev origins such as `http://localhost:3000`, `http://127.0.0.1:3000`, `http://localhost:4200`, and `http://127.0.0.1:4200`. If you run your frontend on a different origin (for example `http://127.0.0.1:4200` or a custom dev domain), add it via the `TMS_CORS_ORIGINS` environment variable when starting the SDK: ```bash theme={null} TMS_CORS_ORIGINS=http://127.0.0.1:4200 npx @ollang-dev/sdk start ``` You can specify multiple origins, comma-separated: ```bash theme={null} TMS_CORS_ORIGINS=http://127.0.0.1:4200,http://localhost:1234 npx @ollang-dev/sdk start ``` ## Troubleshooting Ensure you run `npx @ollang-dev/sdk start` from your project root where `ollang.config.ts` (or env vars) is set. Run `npm run build` in the SDK package if you're developing from source. Verify your key at [Olabs](https://lab.ollang.com). Ensure `OLLANG_API_KEY` is set or entered in the Asset Management UI. Manually visit [http://localhost:5972](http://localhost:5972). On some systems, the `open` package may not launch a browser. Check `includePaths` and `includePatterns` in your config. Ensure your i18n files match the configured paths (e.g., `messages/*.json`, `locales/**/*.json`). ## Next Steps Learn about Asset Management folders, Browser SDK, and Node API. Use the REST API directly for advanced workflows. # Ollang Skills Source: https://api-docs.ollang.com/skills/overview Give your AI coding agent the ability to manage translations, uploads, and localization workflows through natural language. # Ollang Skills Ollang Skills bring the full Ollang translation platform into your AI coding agent. Instead of switching between your editor and the Ollang dashboard, your agent can upload files, create orders, run QC, and manage projects — all from a single conversation. Install and start using Ollang Skills in under 2 minutes. See all 12 sub-skills and what each one does. ## What Are Agent Skills? [Agent Skills](https://skills.sh/) are reusable capability packages for AI coding agents. They give your agent procedural knowledge — step-by-step instructions and API details — so it can accomplish domain-specific tasks without you writing custom prompts. Skills work with agents like **Cursor**, **Claude Code**, **Windsurf**, **Cline**, **Codex**, and other compatible tools. ## What Can Ollang Skills Do? With Ollang Skills installed, your AI agent can: * **Upload files** — Videos, audio, documents, subtitles, and VTT files * **Create translation orders** — Subtitles, closed captions, AI dubbing, studio dubbing, and document translation * **Manage orders** — Check status, cancel, rerun, and list orders with filters * **Run QC evaluations** — AI-powered quality checks for accuracy, fluency, tone, and cultural fit * **Handle revisions** — Create, view, and delete revision requests for completed orders * **Request human review** — Upgrade orders for professional linguist review * **Browse projects and folders** — List, search, and inspect your Ollang workspace ## End-to-End Workflow A typical translation workflow through Skills looks like this: ```text theme={null} 1. Upload file → ollang-upload → returns projectId 2. Create order → ollang-order-create → returns orderId(s) 3. Monitor status → ollang-order-get → poll until "completed" 4. Quality check → ollang-qc-eval → scores + segment analysis 5. Report issues → ollang-revision → create revisions if needed 6. Upgrade to human → ollang-human-review → optional linguist review ``` ## Authentication All Ollang API operations (except the health check) require an API key: ```text theme={null} X-Api-Key: ``` Get your API key at [lab.ollang.com](https://lab.ollang.com). The skills read the key from the `OLLANG_API_KEY` environment variable — set it in your shell or your project's `.env` before starting your agent. If it isn't set, the skill tells you how to set it; it will never ask you to paste the key into the conversation, and you shouldn't — a key that appears in a chat transcript should be treated as exposed and rotated. ## Architecture ``` ┌─────────────────┐ ┌──────────────────┐ ┌─────────────┐ │ AI Agent │ ── skill prompts ──► │ Ollang Skills │ ── REST API ──► │ Ollang API │ │ (Cursor, Claude │ │ (local SKILL.md │ │ (ollang.com)│ │ Code, Codex) │ │ instructions) │ └─────────────┘ └─────────────────┘ └──────────────────┘ ``` Skills are local instruction files — they teach your agent how to call the Ollang REST API. No proxy server or MCP connection is needed. If you prefer a server-based integration with OAuth, see [Ollang MCP](/mcp/overview). Skills and MCP serve different architectures: Skills are file-based and agent-local; MCP is a hosted protocol server. ## Next Steps One command to get started. Detailed reference for each of the 12 sub-skills. # Quick Start Source: https://api-docs.ollang.com/skills/quickstart Install Ollang Skills and run your first translation in under 2 minutes. # Quick Start Add Ollang Skills to your AI agent in one command. ## Prerequisites * An [Ollang account](https://lab.ollang.com) (free to sign up) * An Ollang API key (generate one in the [Olabs Dashboard](https://lab.ollang.com)) * A compatible AI coding agent (Cursor, Claude Code, Codex, Windsurf, Cline, or similar) * [Node.js](https://nodejs.org/) installed (for the `npx` command) ## Installation Run this in your project root (or anywhere your agent can read files): ```bash theme={null} npx skills add https://github.com/ollang/skills --skill ollang ``` This downloads the Ollang master skill and all 12 sub-skills into your local skills directory. If you have the skills CLI cached: ```bash theme={null} npx skills add ollang/skills ``` ## Verify Installation After installing, you should see an `ollang` skill folder in your project's `.skills/` or `.cursor/skills/` directory (location depends on your agent). Confirm by asking your agent: ``` Check if the Ollang API is healthy. ``` The agent will use the `ollang-health` sub-skill to ping the API and confirm connectivity. ## Set Your API Key The skills read your API key from the `OLLANG_API_KEY` environment variable. Set it in your own terminal before starting your agent: ```bash theme={null} export OLLANG_API_KEY=olk_xxxxxxxxxxxx ``` For persistent configuration, add it to your shell profile or your project's `.env`: ```bash .env theme={null} OLLANG_API_KEY=olk_xxxxxxxxxxxx ``` **Never paste your API key into the agent conversation.** Chat transcripts may be stored, logged, or shared, and a key that appears in one should be treated as exposed. The skills only read the key from the environment variable and pass it via shell expansion, so its value never appears in the conversation. If a key does end up in a chat, rotate it at [lab.ollang.com](https://lab.ollang.com). ## Your First Translation Try asking your agent: ``` Upload the video at https://example.com/intro.mp4 to Ollang and create a subtitle order for French and Japanese. ``` The agent will: 1. Call **ollang-upload** to upload the video → returns a `projectId` 2. Call **ollang-order-create** with subtitle type and `fr` + `ja` targets → returns order IDs 3. Report back the order details and suggest checking status later ## Example Prompts ``` Upload contract.pdf to Ollang and create a document translation order for Spanish and German. ``` ``` What's the status of Ollang order #12345? ``` ``` Run a quality check on order #12345 for accuracy and fluency. ``` ``` Show me my last 10 Ollang orders. ``` ``` Request human review for order #12345. ``` ``` Report a timing issue on order #12345 — the subtitle at 01:23 is 2 seconds late. ``` ## Updating Skills To pull the latest version of Ollang Skills: ```bash theme={null} npx skills update ``` Or check for updates first: ```bash theme={null} npx skills check ``` ## Next Steps See all 12 sub-skills and their parameters. Full REST API docs for advanced usage. # Sub-Skills Reference Source: https://api-docs.ollang.com/skills/sub-skills All 12 Ollang sub-skills — what each one does, when to use it, and the underlying API endpoints. # Sub-Skills Reference The Ollang master skill routes to the right sub-skill based on what you ask your agent. Here's every sub-skill, when the agent uses it, and the API surface it covers. ## Quick Reference | Sub-Skill | When the Agent Uses It | | - | - | | `ollang-health` | Check if the Ollang API is up and reachable | | `ollang-upload` | Upload a video, audio, document, or VTT subtitle file | | `ollang-order-create` | Create a translation, CC, subtitle, or dubbing order | | `ollang-order-get` | Check the status or details of a specific order | | `ollang-orders-list` | List, search, or filter orders | | `ollang-order-cancel` | Cancel an active order | | `ollang-order-rerun` | Rerun/regenerate a completed order with latest AI models | | `ollang-revision` | Report issues or manage revisions on a completed order | | `ollang-human-review` | Request or cancel professional linguist review | | `ollang-qc-eval` | Run an AI-powered quality control evaluation | | `ollang-project` | List or inspect projects | | `ollang-folder` | List or find folders | *** ## ollang-health Pings the Ollang API to verify it's online. No API key required. **Example prompt:** ``` Is the Ollang API up right now? ``` **API endpoint:** `GET /health` *** ## ollang-upload Uploads a source file to Ollang. Supports video, audio, documents, spreadsheets, and VTT subtitle files. Returns a `projectId` used to create orders. **Example prompt:** ``` Upload the file at https://example.com/promo.mp4 to Ollang. ``` **API endpoints:** * `POST /integration/upload/direct` — Direct file upload * `POST /integration/upload/vtt` — VTT subtitle upload **Related API docs:** [Direct File Upload](/apis/ollang-api-reference/direct-file-upload), [Upload a VTT](/apis/ollang-api-reference/upload-a-vtt) *** ## ollang-order-create Creates one or more translation orders for a project. Supports order types: **closed captions**, **subtitles**, **document translation**, **AI dubbing**, and **studio dubbing**. **Example prompt:** ``` Create a subtitle order for project abc123 in French and Japanese. ``` **API endpoint:** `POST /integration/orders/create` **Related API docs:** [Create Order](/apis/ollang-api-reference/create-order), [Order Types](/apis/ollang-api-reference/order-types) *** ## ollang-order-get Retrieves full details of a specific order by ID, including status, languages, documents, and QC results. **Example prompt:** ``` What's the status of order #12345? ``` **API endpoint:** `GET /integration/orders/{orderId}` **Related API docs:** [Get Order by ID](/apis/ollang-api-reference/get-order-by-id) *** ## ollang-orders-list Lists orders with optional filtering by type, name, date range, and pagination. **Example prompt:** ``` Show me my last 20 subtitle orders. ``` **API endpoint:** `GET /integration/orders` **Related API docs:** [Get Orders](/apis/ollang-api-reference/get-orders) *** ## ollang-order-cancel Cancels an active order that hasn't completed yet. **Example prompt:** ``` Cancel order #12345. ``` **API endpoint:** `POST /integration/orders/cancel/{orderId}` **Related API docs:** [Cancel Order](/apis/ollang-api-reference/cancel-order) *** ## ollang-order-rerun Reruns a completed order to regenerate the translation using the latest AI models. **Example prompt:** ``` Rerun order #12345 to get an updated translation. ``` **API endpoint:** `POST /integration/orders/{orderId}/rerun` **Related API docs:** [Rerun Order](/apis/ollang-api-reference/rerun-order) *** ## ollang-revision Creates, lists, or deletes revision requests on a completed order. Use this to flag subtitle timing issues, mistranslations, or other problems. **Example prompt:** ``` Create a revision on order #12345 — the subtitle at 00:45 has a typo. ``` **API endpoints:** * `POST /integration/revision/{orderId}` — Create a revision * `GET /integration/revision/{orderId}` — List all revisions * `DELETE /integration/revision/{orderId}/{revId}` — Delete a revision **Related API docs:** [Create Revision](/apis/ollang-api-reference/create-a-revision-for-an-order), [Get Revisions](/apis/ollang-api-reference/get-all-revision-for-an-order), [Delete Revision](/apis/ollang-api-reference/delete-a-specific-revision) *** ## ollang-human-review Requests or cancels a professional linguist review for an order. Human review upgrades AI-generated output with expert review. **Example prompt:** ``` Request human review for order #12345. ``` **API endpoints:** * `POST /integration/orders/{orderId}/human-review` — Request review * `POST /integration/orders/{orderId}/cancel-human-review` — Cancel review **Related API docs:** [Request Human Review](/apis/ollang-api-reference/request-human-review), [Cancel Human Review](/apis/ollang-api-reference/cancel-human-review) *** ## ollang-qc-eval Runs an AI-powered quality control evaluation on a completed order. Returns scores for accuracy, fluency, tone, and cultural fit, plus segment-level analysis. **Example prompt:** ``` Run a QC check on order #12345 for accuracy and tone. ``` **API endpoint:** `POST /integration/orders/{orderId}/qc` **Related API docs:** [Run QC Evaluation](/apis/ollang-api-reference/run-qc-evaluation) *** ## ollang-project Lists all projects or retrieves details for a specific project by ID. **Example prompt:** ``` Show me all my Ollang projects. ``` **API endpoints:** * `GET /integration/project` — List all projects * `GET /integration/project/{projectId}` — Get project details **Related API docs:** [Retrieve All Projects](/apis/ollang-api-reference/retrieve-all-projects), [Get Project by ID](/apis/ollang-api-reference/get-project-by-id) *** ## ollang-folder Lists and searches Ollang folders for organizing projects. **Example prompt:** ``` Show me my Ollang folders. ``` **API endpoint:** `GET /integration/folder` **Related API docs:** [Retrieve All Folders](/apis/ollang-api-reference/retrieve-all-folders) # Source Files and Asset Handling Source: https://api-docs.ollang.com/source-files-assets Learn how source assets, supporting files, upload formats, and localization resources are managed inside the Ollang Project Management Dashboard. ## Overview The Ollang Project Management Dashboard supports complex localization workflows involving: * video files * audio files * subtitle srt files * document files * localization resource files * guideline and reference materials Each Project can contain a primary source asset and supporting assets. The selected Order type determines which asset is used for localization. *** # Primary Source Assets vs Supporting Assets ## Primary Source Asset A primary source asset is the main file that will be localized. Examples: * a video/audio file for Video Captioning, Subtitle Translation, or AI Dubbing * a document file for Document Translation ## Supporting Assets Supporting assets provide additional context or operational input for localization workflows. Examples: * SRT or VTT subtitle references * M\&E files * source audio * glossaries * brand guidelines * voice instructions * accessibility notes * reference translations * additional documents A Project may contain multiple supporting assets, but the selected Order type determines which asset becomes operationally relevant. *** # Example Project Asset Structure ```text theme={null} Project: Product Demo Video ├── Primary Source Video ├── English SRT ├── M&E File ├── Translation Glossary ├── Brand Guidelines ├── Voice Instructions └── Accessibility Notes ``` In this example: * the source video is the primary asset * the SRT supports subtitle timing and translation * the M\&E file supports dubbing workflows * the glossary and brand guidelines support consistency *** # Supported Video and Audio Upload Formats The following video and audio formats are supported: Commonly used for source video localization workflows. Commonly used for video captioning, subtitle translation, and dubbing workflows. Commonly used for audio-based dubbing, transcription, and voice workflows. Commonly used for audio upload, transcription, and voice-related workflows. *** # Supported Document Upload Formats The following document and localization file formats are supported: These formats support workflows such as: * office document translation * website and HTML localization * software localization * structured resource file localization * multilingual documentation workflows *** # Structured Localization Files Ollang supports structured localization formats such as: * XLIFF * SDLXLIFF * JSON * PO * HTML * SRT * VTT These formats are commonly used by: * localization teams * product teams * engineering teams * SaaS companies * enterprise content teams Structured file support allows organizations to localize content while preserving file structure and localization context. *** # Subtitle and Caption Assets Subtitle and caption files can be used as: * primary assets for subtitle-based workflows * supporting references for video workflows * timing references for dubbing workflows Common subtitle-related formats include: * `.srt` * `.vtt` ## Example ```text theme={null} Project contains: - Source Video - English SRT (Source) Possible Orders: - Subtitle Translation using the source SRT - AI Dubbing ``` In this case, the SRT can help preserve timing, segmentation, and subtitle structure during localization. *** # M\&E Files ## What is an M\&E File? M\&E stands for Music and Effects. An M\&E file contains: * background music * environmental audio * sound effects * non-dialogue audio elements without the original spoken vocals. M\&E files are especially important for: * AI Dubbing * Studio Dubbing * vocal replacement workflows * professional audio mixing workflows *** # Why M\&E Files Matter During dubbing workflows, original vocals may be replaced with localized vocals. M\&E files help preserve the non-dialogue parts of the original media, such as: * background music * crowd noise * room tone * sound effects * environmental sounds This allows localized dubbed audio to sound more natural and closer to the original production. *** # Example Dubbing Workflow with M\&E ```text theme={null} Source Video ↓ Ollang extracts the M&E or User uploads the M&E ↓ Generate Localized Vocals ↓ Mix Localized Vocals with extracted/uploaded M&E ↓ Generate Mixed Master Output ``` If a project already has a clean M\&E file, it can help improve dubbing and mixing workflows. *** # Guideline Documents Guideline documents provide instructions that help AI workflows, linguists, editors, and vendors produce consistent output. Guidelines may include: * subtitle style guides * brand tone instructions * terminology rules * voice direction * accessibility rules * formatting preferences * market-specific localization requirements ## Example ```text theme={null} Guideline: Subtitle Style Guide Rules: - Maximum 42 characters per line - Avoid splitting proper names across lines - Preserve product names in English - Use informal tone for social media content ``` ## Hierarchy in which the Guidelines are applied to your orders 1. **Custom Instructions** represent global guidelines that are automatically applied to Orders when no folder-level or project-level guidelines are configured. C1 2. **Folder-level Guidelines** represent instructions uploaded to a specific Folder and are automatically applied to all Orders within that Folder unless project-level guidelines are configured. C2 3. **Project-level Guidelines** represent instructions uploaded to a specific Project and are automatically applied to all Orders within that Project, overriding folder-level and global guidelines when configured. C3 # Glossaries and Terminology References Glossaries help preserve terminology consistency across multilingual workflows. They are useful for: * product names * brand terms * medical terminology * legal terminology * UI terms * recurring phrases * approved translations Glossaries are especially important for: * enterprise localization * SaaS localization * legal translation * healthcare content * multilingual product operations *** # Accessibility Assets Accessibility-related assets may include: * audio description instructions * accessibility style guides * screen-reader guidance * narration tone notes * compliance requirements * scene description references These assets support workflows such as: * Audio Description * captioning * subtitle accessibility * inclusive media localization *** # Bulk Upload Workflows Bulk Upload workflows allow Project Management Users to upload multiple files into a Folder for scalable project creation and localization management.\ \ Bulk uploads are especially useful for: * Episodic content, * Large multilingual campaigns, * Media libraries, * Enterprise localization operations, * and high-volume content onboarding.\ \ The platform supports two different bulk upload methods: Upload individual source files to create Projects one at a time. Upload multiple structured folders simultaneously to automatically create multiple Projects with associated assets. # Single File Upload Workflow Project Management Users may upload: * a single video, * audio file, * subtitle file, * or document to create: * one new Project. Additional supporting files may then be uploaded manually to enrich the Project. Example: ```text theme={null} Upload: - ProductDemo.mp4 Result: - Creates Project: ProductDemo ``` Additional files such as: * subtitles, * M\&E files, * glossaries, * guidelines, * or supporting documentation can later be added to the Project. *** # Bulk Project Upload Workflow ## Overview The platform also supports structured bulk project creation using: * predefined folder naming conventions. This workflow allows organizations to drag and drop: * dozens or hundreds of folders simultaneously, while automatically generating: * Projects, * associated source files, * and supporting localization assets. This is especially useful for: * episodic media, * multilingual production pipelines, * enterprise-scale localization operations, * and high-volume onboarding. C5 # How Bulk Project Upload Works Each Project should exist inside: * its own dedicated folder. Inside each folder: * files must follow a consistent naming structure. When uploaded: * each folder becomes a Project, * and all associated files are automatically linked to that Project. # Example Folder Structure ```text theme={null} YourFolder/ │ ├── NameofYourVideo/ │ ├── NameofYourVideo_SourceVideo.mp4 │ ├── NameofYourVideo_SourceAudio.wav │ ├── NameofYourVideo_Subtitle_EN.srt │ ├── NameofYourVideo_MEAudio.wav │ ├── NameofYourVideo_CharacterList.pdf │ ├── NameofYourVideo_GeneralGuideline.pdf │ └── NameofYourVideo_Document.pdf │ ├── AnotherVideo/ │ └── ...up to 100 videos/ ``` # What Happens During Upload? When the folder is dragged into Ollang: ```text theme={null} 100 Structured Folders Uploaded ↓ 100 Projects Automatically Created ↓ Associated Files Automatically Linked ↓ Projects Become Ready for Order Creation ``` For each Project: * source videos are identified, * subtitle references are linked, * M\&E assets are associated, * guidelines are attached, * and supporting files are preserved. This significantly reduces: * manual onboarding effort, * repetitive uploads, * and project setup time. # Benefits of Bulk Project Upload Bulk project upload helps organizations: * onboard large media libraries faster, * reduce manual project creation, * preserve structured file relationships, * standardize localization operations, * and accelerate multilingual order creation. Bulk Upload workflows are especially recommended for organizations managing high-volume localization pipelines or episodic content libraries. Bulk uploads may include: * source videos * subtitle files * M\&E files * documents * additional reference files The platform can then organize these assets for downstream localization workflows. *** # Upload Behavior by Workflow Type AI Dubbing workflows commonly use source video or audio files, subtitle references, M\&E files, and voice instructions. Subtitle Translation workflows commonly use source videos, SRT/VTT files, subtitle references, glossaries, and formatting guidelines. Video Captioning workflows commonly use source video or audio files to generate timed transcription and caption outputs. Document Translation workflows commonly use office files, structured localization files, subtitle files, and website localization resources. Studio Dubbing workflows commonly use source video, subtitle timing assets, dubbing scripts, M\&E files, and externally produced studio deliverables. # Multi-Workflow Project Example A single Project can support multiple Orders using the same source and supporting assets. ```text theme={null} Project: Product Launch Video Assets: - Source Video - English SRT - Brand Guidelines - M&E File - Voice Notes Orders: - French Subtitle Translation - German AI Dubbing - Japanese Studio Dubbing ``` This allows teams to manage different localization outputs from the same Project environment. # Important Operational Notes Yes. A Project may contain multiple asset types. The selected Order type determines which asset is used for localization. Yes. Subtitle file such as SRT can be used in subtitle-based localization workflows and can also support video or dubbing workflows. The primary source asset is the main file being localized. Supporting assets provide additional context, timing, terminology, audio layers, or workflow guidance. M\&E files preserve background music and effects while localized vocals replace the original spoken audio. Yes. Multiple Orders under the same Project can reuse the same primary source asset and supporting files. # Teams, Permissions, and LSP Hierarchy Source: https://api-docs.ollang.com/teams-permissions Understand team structures, permissions, assignment visibility, operational hierarchy, and LSP workflows inside the Ollang Project Management Dashboard. ## Overview The Ollang Project Management Dashboard supports: * internal operational teams, * external linguists, * translation agencies, * dubbing studios, * and multi-layered localization workflows. The platform separates operational users into: * Project Management users, * and Editor / LSP users. This separation allows organizations to: * control visibility, * manage assignments, * organize localization operations, * and securely coordinate multilingual workflows. *** # The Two Main Operational Environments Used for operational oversight, order creation, billing, analytics, workflow management, and project organization. Used for subtitle editing, dubbing review, translation operations, and assignment-based localization workflows. # Team Invitation Types Organizations can invite multiple operational user types. Internal operational users working inside the Project Management Dashboard. Linguists or reviewers working inside the Editor Interface. External localization vendors managing multilingual operations. Professional dubbing vendors handling voice production workflows. *** # Project Management Users ## Overview Project Management users operate inside: * the Ollang Project Management Dashboard. These users manage: * Folders, * Projects, * Orders, * assignments, * billing, * analytics, * and workflow operations. *** # Project Management Roles The platform supports operational permission structures including: * Owner * Admin * Project Manager * Team Member *** # Permission Structure ## Core Permissions Permissions may include: Allows users to create localization workflows and operational Orders. Allows users to invite and manage operational users. Allows users to view analytics, invoices, billing details, and payment-related operations. Allows operational visibility into organizational workflows and Projects. Image *** # Access Billing Clarification Users with Access Billing permissions may view: * invoices, * analytics, * payment information, * and operational financial data. However: * general credit visibility remains visible operationally across workflows. *** # Folder-Based Notification Logic Notification behavior operates primarily at: * Folder level. Example: ```text theme={null} Project Manager A assigned to Folder A ↓ Team Member B creates Order ↓ Order completes ↓ Both users receive notification ``` *** # Visibility Rules for Project Management Users Project Management users generally have visibility into: * all Folders, * all Projects, * and organizational workflows. However: * notification ownership operates through Folder assignment structures. *** # Editor / LSP Users ## Overview Editors and linguists operate inside: * the Editor / LSP Interface. These users focus on: * subtitle editing, * transcription review, * dubbing workflows, * translation refinement, * and operational delivery. *** # Important Visibility Rule Editors do not see all Projects or organizational workflows. Editors only see: * explicitly assigned Orders. Assignments operate primarily at: * Order level, not: * Project level. *** # Example Assignment Visibility ```text theme={null} Folder contains: - 10 Projects - 200 Orders Editor assigned: - 5 Orders Result: - Editor only sees assigned Orders. ``` *** # LSP Hierarchy The platform supports a multi-level localization hierarchy. ```text theme={null} LSP Admin (Editor) ↓ LSP Project Manager ↓ LSP Linguist ``` # LSP Admin LSP Admins can: * manage localization operations, * assign Orders, * onboard linguists, * and coordinate multilingual workflows. LSP Admins typically act as: * operational vendor managers. *** # LSP Project Manager LSP Project Managers can: * coordinate operational assignments, * manage delivery pipelines, * and oversee linguist workflows. These users commonly manage: * multilingual delivery operations, * reviewer coordination, * and operational execution. *** # LSP Linguist LSP Linguists: * edit assigned Orders, * refine localization output, * and deliver finalized workflows. They only see: * Orders assigned to them. *** # Translation Agencies and Dubbing Studios ## Overview Translation Agencies and Dubbing Studios may: * create internal users, * assign operational tasks, * and coordinate multilingual delivery pipelines. This allows vendors to: * manage their own operational structures inside Ollang. *** # Studio Dubbing Vendor Workflows Studio vendors may: * upload dubbing vocals, * upload final mixed outputs, * upload Mixmaster files, * and coordinate operational dubbing delivery. However: * delivery behavior depends on Order type. *** # Important Studio Dubbing Rule Studios cannot deliver isolated vocals-only files without sufficient operational audio structure. Delivery workflows require: * either final mixed outputs, * or operationally compatible audio assets. *** # Interface Switching Project Management users may also: * switch into the Editor Interface. A2 A3 This allows: * operational review, * subtitle editing, * dubbing review, * and assignment-level editing workflows. *** # Important Operational Clarification A Project Management user switching into the Editor Interface only sees: * Orders assigned to them operationally inside the Editor environment. Visibility still operates through: * Order-level assignment logic. *** # Example Multi-Team Workflow ```text theme={null} Project Manager creates AI Dubbing Order ↓ Order assigned to Translation Agency ↓ Agency Project Manager assigns Linguist ↓ Linguist edits subtitles ↓ Project Manager receives completed delivery ``` *** # Important Operational Notes Yes. Organizations may onboard internal reviewers, agencies, editors, and dubbing studios. No. Editors only see explicitly assigned Orders. Yes. Agencies may create and manage their own operational users. Yes. Studio workflows support uploaded dubbing assets and final delivery coordination. Yes. Project Management users may access the Editor Interface for operational review workflows. Assignments primarily operate at Order level. # Translation Readiness, Matching, and Context Assets Source: https://api-docs.ollang.com/translation-readiness-context-matching How Ollang scores translation readiness, what full (exact) and fuzzy memory matches are, how glossaries and style guides count, how segments are classified for review, and how the Assets utilized card estimates billable review words. ## Overview When you create an Order, Ollang can look at the source content together with the context assets you selected (Memories, Glossaries, Style Guides, guidelines) and tell you, before checkout, how much of the work is already covered by approved material. After the Order is translated, the same signals are recorded per segment as **evidence**, which drives the review classification and the human-review estimate shown on the Order details page. This page explains every number you will see along the way: * **Full (exact) match** and **fuzzy match** against a Memory * **Glossary coverage** and **Style guide** availability * The **Translation readiness** score and the suggested review policy * **Segment classification** (auto-approved, review recommended, flagged) * **Assets utilized**, evidence, and the **billable / words for review** estimate Translation readiness is advisory. It never blocks checkout, never changes the price you are quoted, and never rewrites your workflow's review settings by itself. Use it to decide which assets to attach and how much human review to plan for. Readiness scoring, the context asset picker, and the Assets utilized card are feature-gated. If you do not see them on the New Order or Order details pages, contact your Ollang account manager to enable context management for your workspace. *** # Context assets A **context asset** is any piece of approved material Ollang can ground a translation on. Each asset carries a *type*, a *scope level*, and a *selection source* that explains why it was used for a given Order. | Asset type | What it holds | Scope levels | | - | - | - | | `memory` | Translation memory: previously approved source/target pairs | Workspace | | `glossary` | Approved terminology, including forbidden terms | Organization, workspace, project | | `style_guide` | Document-wide style rules (tone, formatting, register) | Workspace, project | | `instruction` | Global custom instructions | Workspace, project | | `guideline_doc` | Folder- or project-level guideline documents | Project | | `subtitle_config` | Subtitle formatting configuration | Project | | Selection source | Shown in the UI as | Meaning | | - | - | - | | `explicit` | **Selected** | You picked the asset in the New Order form (or passed its ID to the API). | | `resolved` | **Auto-resolved** | Ollang attached it automatically from the folder / project / workspace scope and language pair. | | `legacy` | **Legacy** | Attached through an older mechanism (for example project guidelines defined before context management). | Memories are **never** auto-attached: a Memory is only used when it is explicitly selected for the Order. Glossaries and Style Guides *are* auto-resolved from the project and workspace scope (glossaries additionally filtered by source language) unless you make an explicit selection, in which case your selection is authoritative. For how to create and manage these assets, see [Memory, Guidelines, and Custom Instructions](/memory-guidelines-custom-instructions). *** # Memory matching Matching is performed **per segment**. A segment is one subtitle cue, one document paragraph / cell, or one line of the source text, depending on the Order type. Before comparing, both the source segment and every Memory entry are **normalized**: ```text theme={null} 1. lowercase 2. trim leading / trailing whitespace 3. collapse repeated whitespace to a single space 4. remove the punctuation characters . , ! ? ; : ``` So `"Save changes?"` and `"save changes"` are treated as the same text. ## Full (exact) match — "TM exact" A segment is a **full match** when its normalized text is identical to the normalized source text of an entry in one of the selected Memories. * Only *active* Memory items are considered; removed items are ignored. * Each exact match is recorded as deterministic evidence of kind `tm_exact` with a match score of **1.0**. * **TM exact coverage** = matched segments ÷ all non-empty source segments, as a percentage. A full match is the strongest signal Ollang has: the segment already has an approved translation, so it needs the least (often no) human attention. ## Fuzzy match — "TM fuzzy" Segments that did **not** get a full match are then compared against Memory entries using **token Dice similarity**: the two normalized texts are split into unique words and ```text theme={null} similarity = 2 × |A ∩ B| / (|A| + |B|) ``` where `A` and `B` are the word sets of the source segment and the Memory entry. A segment counts as a **fuzzy match** when its best candidate reaches the **70 % similarity bar** (`0.7`). ```text theme={null} Source : "Click Save to keep your changes" Memory : "Click Save to keep the changes" A = {click, save, to, keep, your, changes} (6 words) B = {click, save, to, keep, the, changes} (6 words) A ∩ B = {click, save, to, keep, changes} (5 words) similarity = 2 × 5 / (6 + 6) = 0.83 → fuzzy match (≥ 0.70) ``` * **TM fuzzy coverage** = fuzzy-matched segments ÷ all non-empty source segments. * Exact and fuzzy coverage are **disjoint**: a segment is either exact, fuzzy, or unmatched, so the two percentages can be added. * If no segment reaches the bar, the readiness card explains why, for example *"No segment reached the 70% similarity bar — closest matches averaged 41%."* A fuzzy match means an existing translation is close enough to be **reused with post-editing**. It is not a finished translation, which is why it receives partial credit in the readiness score (see below). Matching scans a bounded number of Memory entries and source segments per Order. Very large Memories or source files may report the `tm_scan_capped` caveat, meaning coverage is a lower bound rather than an exhaustive count. *** # Glossaries Glossary terms are matched as **whole words or phrases** inside each source segment (so `add` does not match inside `address`), with Unicode-aware boundaries so that non-Latin scripts and scripts without spaces (Chinese, Japanese, Thai, …) match correctly. Two different glossary percentages exist, and it helps to know which one you are looking at: | Metric | Definition | Where it is used | | - | - | - | | **Glossary (segment coverage)** | Share of source segments that contain at least one approved glossary term | Readiness score (`glossary` component) | | **Term coverage** | Share of the glossary's terms that appear somewhere in the document | Diagnostic shown on the readiness card | Each term hit is recorded as deterministic evidence of kind `glossary_term`, including the source term, the target term, and whether the term is **forbidden**. **Forbidden terms** are terms your glossary marks as *do not use*. When a forbidden term is present in the source: * the readiness report adds the `forbidden_terms_present` caveat, and * every segment containing it is **always flagged** for review, regardless of any other score. *** # Style guides A Style Guide contains rules that apply to the **whole document** (tone, register, formatting, capitalization, …) rather than to individual segments, so there is no meaningful per-segment coverage percentage for it. Readiness therefore only reports **availability**: * a Style Guide is attached → the style component is **100 %** * no Style Guide is attached → **Not available** (0 %) Guideline documents, custom instructions, and subtitle configuration are resolved and listed alongside Style Guides in the Assets utilized card, but do not contribute to the readiness score. *** # Translation readiness score The **Translation readiness** card on the New Order form combines all the signals above into a single **0–100** confidence score. It is computed asynchronously: the card creates a readiness report, polls until it is `completed`, and then shows the breakdown. Translation readiness card on the New Order form ## Inputs | Component | Weight | Value used | | - | - | - | | Translation memory | **0.55** | *combined TM coverage* = TM exact % + TM fuzzy % × **0.6** (clamped to 0–100) | | Glossary | **0.15** | glossary segment coverage % | | Style guide | **0.10** | 100 if a Style Guide is attached, otherwise 0 | | Historical automation | **0.20** | 100 − average human-edit % on your previous Orders (defaults to **50** until at least 3 completed Orders with edit data exist) | ```text theme={null} readiness = 0.55 × (exact% + 0.6 × fuzzy%) + 0.15 × glossary% + 0.10 × (styleGuide ? 100 : 0) + 0.20 × historicalAutomation ``` The result is rounded and clamped to 0–100. **Worked example** — the card above: 5 source segments, 2 exact matches (40 %), no fuzzy matches (0 %), 3 segments carrying an approved glossary term (60 %), no Style Guide, no order history yet: ```text theme={null} TM combined = 40 + 0.6 × 0 = 40 readiness = 0.55 × 40 = 22.0 + 0.15 × 60 = 9.0 + 0.10 × 0 = 0.0 + 0.20 × 50 = 10.0 ------------------------------ 41 → "Needs attention" ``` Attaching a Style Guide would add 10 points; one fuzzy match (20 %) would add 0.55 × 0.6 × 20 ≈ 6.6 more. The fuzzy credit of 0.6 reflects that a fuzzy match is reusable but still needs post-editing. The card also shows the combined TM figure so that the breakdown reconciles with the headline score. ## Bands and suggested review policy The score is mapped onto the same classification thresholds that are later used for segment classification, so what you see before the Order and after the Order line up: | Score (defaults) | Label | Suggested review policy | | - | - | - | | **95 – 100** | Ready | `ai_only_spot_check` — AI translation with a spot check | | **66 – 94** | Review recommended | `review_recommended` — standard human review after translation | | **0 – 65** | Needs attention | `full_review` — full human review after translation | Thresholds are configurable per workflow (see [Review Gates](/review-gates)); the readiness report records the thresholds that were actually used. The suggested policy is a recommendation only. Ollang does not change your review nodes automatically. ## Caveats The report lists caveats that qualify the number: | Caveat | Meaning | | - | - | | `no_source_text` | No text could be extracted from the source, so TM and glossary matching could not run. The score is forced to **0** even if assets are attached. | | `tm_scan_capped` | The Memory / source scan hit its size cap; coverage is a lower bound. | | `forbidden_terms_present` | The source contains glossary terms marked as forbidden. | The report also records its *content availability*: `full_text` when source segments were available for matching, `counts_only` when only source document URLs were supplied and the text still had to be fetched and parsed server-side, and `none` when nothing could be read (which produces the `no_source_text` caveat). The card also tells you what to add to raise a low score (for example attach a Memory for this language pair, or a Style Guide). *** # Segment classification after translation Once the Order is translated, each segment is scored from the evidence recorded for it and classified into one of three review buckets. | Evidence on the segment | Segment score | | - | - | | Exact Memory match (`tm_exact`) | **100** | | Fuzzy Memory match (`tm_fuzzy`) | the fuzzy similarity (e.g. 83) | | Glossary term only (`glossary_term`) | **70** | | Glossary term *in addition to* a non-perfect TM / AI signal | **+5** bonus, capped at 100 | | AI-reported confidence only (`ai_reported`) | the AI confidence for that segment | | Forbidden glossary term present | always **flagged** | | Segment score (defaults) | Classification | | - | - | | ≥ 95 | **Auto-approved** | | 66 – 94 | **Review recommended** | | \< 66 | **Flagged** | The classification thresholds are the same `autoApproveMinScore` / `reviewMinScore` pair used for the readiness bands. The counts of segments in each bucket are what the Assets utilized card summarises as the **review classification roll-up**. *** # Assets utilized The **Assets utilized** card on the Order details page (Project Management → Order) shows, after translation, which context assets actually influenced the Order and how much of the content is grounded in them. Assets utilized card on the Order details page For each asset it lists: * **Name and type** (Memory, Glossary, Style guide, Instruction, Guideline document, Subtitle config) * **Version** of the asset at the time of the Order, and its **scope level** * **Selection source**: Selected, Auto-resolved, or Legacy * **Evidence count**: how many individual matches were recorded against this asset * **Grounded segments**: how many distinct segments have at least one match from this asset Below the assets you see the usage summary: * total evidence records and the number of segments with any evidence * evidence by kind (`tm_exact`, `tm_fuzzy`, `glossary_term`, `style_rule`, `instruction`, `ai_reported`) * the **review classification roll-up**: auto-approved / review recommended / flagged counts * the overall **AI confidence** reported by the translation pipeline and the **context score** Every segment can be opened to inspect its evidence: which Memory entry or glossary term matched, the match score, and the AI justification where available. Per-segment evidence drawer Deterministic evidence (`tm_exact`, `glossary_term`) is produced by Ollang's matching services and is exact. `ai_reported` evidence is the confidence the translation model reported for that segment; it is stored separately, is not counted as an "asset", and is shown with its justification so you can judge it. ## Human review estimate and billable words The card ends with a **Human review estimate** that translates the classification roll-up into words: ```text theme={null} words for review = round( totalWords × (1 − autoApproved / totalClassified) ) ``` and displays it as ` total → billable`. For example, an Order of 10,000 words where 6,200 of 8,000 classified segments were auto-approved shows: ```text theme={null} 10,000 × (1 − 6,200 / 8,000) = 2,250 words for review (10,000 total → 2,250 billable) ``` How to read this: * It is a **proportional estimate**: the auto-approved share of *segments* is applied to the *word count*; it does not sum the exact word counts of the non-auto-approved segments. * "Billable" here refers to the words you should plan to pay a human reviewer for (in-house or LSP). It is **not** the Order's price: the Order was quoted and charged at checkout, and this estimate does not change that quote, the credits consumed, or any invoice. * Use it to size a [Review Gate](/review-gates) assignment or an LSP purchase order, and compare it against the pre-order readiness score to check that your assets are paying off. *** # Putting it together On the New Order form, select the Memories you want to reuse. Glossaries and Style Guides for the project and language pair are auto-resolved; adjust the selection if needed. Check TM exact / fuzzy coverage, glossary coverage, and style-guide availability. Follow the card's suggestions (attach a Memory, add a Style Guide) if the score is low. Readiness is advisory and does not block checkout. Use the suggested review policy to configure the workflow's Review Gate: spot check for "Ready", standard review for "Review recommended", full review for "Needs attention". After translation, confirm which assets were used, inspect flagged segments, and use the human review estimate to plan reviewer effort. Approved reviews grow your Memories, which raises exact/fuzzy coverage, the historical-automation component, and future readiness scores. *** # Quick reference | Term | Short definition | | - | - | | Full / exact match | Normalized source segment identical to a Memory entry; score 100 | | Fuzzy match | Best Memory entry with token Dice similarity ≥ 0.70; score = similarity | | TM combined coverage | exact % + 0.6 × fuzzy % | | Glossary coverage | % of segments containing an approved glossary term | | Term coverage | % of glossary terms appearing in the document (diagnostic) | | Style guide availability | 100 % if a Style Guide is attached, otherwise not available | | Historical automation | 100 − average human-edit % over previous Orders (default 50) | | Translation readiness | 0.55·TM + 0.15·Glossary + 0.10·Style + 0.20·History, 0–100, advisory | | Auto-approved / Review recommended / Flagged | Segment classification at ≥ 95 / ≥ 66 / \< 66 (configurable) | | Assets utilized | Assets with recorded evidence on the Order, with version, scope, selection source, evidence and segment counts | | Words for review ("billable") | totalWords × (1 − autoApproved ÷ totalClassified); a review-planning estimate, not the Order price | # Troubleshooting Source: https://api-docs.ollang.com/troubleshooting Common errors, debugging tips, and what to send to support when something goes wrong. # Troubleshooting Most integration issues fall into a handful of buckets — authentication, uploads, callbacks, order state, or rate limits. Start here before opening a support ticket. ## First, Check the API Is Up ```bash theme={null} curl https://api-integration.ollang.com/health ``` A `200` with `{"status":"OK"}` confirms connectivity. If this fails from your environment but works from your laptop, the issue is between your network and Ollang, not Ollang itself. Full reference: [Health Check](/apis/ollang-api-reference/health-check). If the check fails everywhere — or orders are running but behaving oddly — open the **[Ollang Status page](https://status.ollang.com)** before digging further. It reports live availability, open incidents, and scheduled maintenance across the platform and its APIs. ## Authentication * Confirm the header name is **`X-Api-Key`**, not `Authorization` or `X-API-KEY`. * Confirm the value is your active API key from the [Olabs Dashboard](https://lab.ollang.com) (project settings → API keys). * If you rotated your key recently, revisit any deployment or CI environment variable. * The `/health` endpoint does not require a key — useful as a sanity test. OAuth refresh tokens can expire. Disconnect and reconnect the Ollang MCP server from your client (Claude Desktop, Cursor, etc.). Make sure the configured URL is `https://mcp.ollang.com/mcp`. Set `OLLANG_API_KEY` in your shell or `.env` so the agent can read it once and persist it across the session: ```bash theme={null} export OLLANG_API_KEY="" ``` ## File Uploads Limits: * **Video**: 30 GB * **Documents**: 100 MB * **In-page API playground**: 5 MB (use a real client for anything larger) For very large videos, prefer the [Direct File Upload](/apis/ollang-api-reference/direct-file-upload) endpoint over web uploads. Confirm the file extension matches the actual content (e.g. `.mp4` for video, `.docx` for Office documents). The full supported list lives on the [Direct File Upload](/apis/ollang-api-reference/direct-file-upload) page. Image-to-image translation needs JPEG, JPG, or PNG **via Direct Upload** specifically — see the [Order Types](/apis/ollang-api-reference/order-types) table. The platform takes the stored file's extension from the filename in the multipart `file` part, not from the `name` field. A part sent without one — a bare `Blob` in JavaScript defaults the filename to `blob` — is stored as `.blob`, which the document pipeline cannot read. Send the file under its real name. The three-argument `append` requires a `Blob`, so wrap raw bytes rather than passing a `Buffer` or `Uint8Array` straight in — those throw `TypeError: parameter 2 is not of type 'Blob'`: ```javascript theme={null} // Browser / Node 18+ formData.append("file", new Blob([bytes]), "en.json"); ``` A `File` works too and carries the name itself, but it is only a global from Node 20 onwards — on Node 18 use the `Blob` form above. In the Node SDK, pass `filename` alongside a `Blob` — see [Node.js Library](/sdk/node#naming-the-uploaded-file). In the Python SDK, pass a path, or `filename=` alongside raw bytes. Uploads whose extension the platform cannot read are now rejected with a `400` before the project is created. Before that, the upload was accepted, the document pipeline failed on it, and `Create Order` against the resulting project returned `404 UploadRecordNotFoundException` — with an orphan project left behind on every retry. Pass the destination `folderId` on the upload request. Without it, projects land in the default **API Uploads** folder. You can list folders with [Retrieve All Folders](/apis/ollang-api-reference/retrieve-all-folders). AE uploads run through a retry-with-backoff path and have a 5-minute conversion timeout. If a single asset is failing repeatedly, check that the .ZIP contains a clear main composition and try again. See the [changelog](/changelog) entries on After Effects upload reliability and end-to-end AE localization. ## Orders Use the `projectId` returned from your most recent [Direct File Upload](/apis/ollang-api-reference/direct-file-upload) response. Projects are scoped to the account that owns the API key — keys from another account cannot see them. `orderType` must be one of `cc`, `subtitle`, `document`, `aiDubbing`, or `studioDubbing`. See [Order Types](/apis/ollang-api-reference/order-types). `targetLanguageConfigs` must be a non-empty array. Each entry creates a separate order. Language codes follow [Supported Languages](/apis/ollang-api-reference/supported-languages). Most AI orders complete within minutes; level-1 orders (with Human Review) depend on reviewer availability and may take hours. Some statuses (e.g. `waitingForCC`, `waitingForSubtitle`) indicate the order is gated on an upstream artifact. See [Order Statuses](/apis/ollang-api-reference/order-statuses). If you suspect something is wrong, capture the `orderId` and recent `GET /integration/orders/` response and contact support. Rerun re-executes against the **current** workflow. If the workflow, providers, custom instructions, and source content are unchanged, the AI may produce nearly identical output. Try updating the relevant Folder workflow or attaching guidelines before rerunning. See [Rerun Order](/apis/ollang-api-reference/rerun-order). ## Callbacks (`callbackUrl`) * Confirm `callbackUrl` is a fully-qualified `http(s)` URL. * Make sure your endpoint is reachable from the public internet — internal hostnames (`localhost`, `*.internal`) and IPv6 destinations are blocked at the SSRF guard. * Callbacks have a **10-second timeout**. If your handler takes longer to respond, Ollang treats it as a failure. Acknowledge quickly and process asynchronously. * Callback failures do not affect the order itself. Fall back to polling [Get Order by ID](/apis/ollang-api-reference/get-order-by-id) if you don't receive a callback within a reasonable window. Treat callback handlers as idempotent. Use the `orderId` + `completedAt` as a dedup key, or upsert into your store keyed by `orderId`. Don't rely on the body alone. Pair the callback with a `GET /integration/orders/` confirmation using your API key before acting on the contents. ## QC and Human Review `autoQc` only applies to **top-level** orders (orders created directly), not child orders generated as part of a parent workflow. It also requires `enableQCThreshold` on the client account. Several options: * Add **Custom Instructions** or **Guidelines** to steer the AI toward your tone and terminology. See [Memory, Guidelines, and Custom Instructions](/memory-guidelines-custom-instructions). * Attach a **Memory** (approved terminology) so future orders reference it. * Upgrade to **Level 1** via [Request Human Review](/apis/ollang-api-reference/request-human-review). * Change the AI provider in the [Folder workflow](/workflows-provider-architecture) and rerun. Review gates respect `qcThreshold` routing rules — orders may be re-routed automatically. Use [Cancel Human Review](/apis/ollang-api-reference/cancel-human-review) to revert to the AI-only state and refund the review credits if priority changes. ## Networking and Limits Ollang enforces per-account rate limits. If you receive a `429`, back off exponentially and retry. For high-volume use cases, contact Ollang to discuss limits before launch. Some operations (large uploads, AE conversions) intentionally take minutes. Increase your HTTP client's read/write timeouts (5–10 minutes is reasonable for uploads) and don't reuse a connection across unrelated requests. Outbound traffic from your environment must reach `api-integration.ollang.com` and `mcp.ollang.com`. Some corporate proxies strip `multipart/form-data` headers or terminate long uploads — try a clean network as a comparison. If you need to allowlist Ollang hosts with your network or security team, [trust.ollang.com](https://trust.ollang.com) has the security and compliance documentation they'll usually ask for. ## SDK Issues `Ollang` is a named export: ```typescript theme={null} import { Ollang } from "@ollang-dev/sdk"; ``` It is also the default export, but up to and including 0.4.0 the default import resolved to the module namespace under native ESM rather than to the class, so `import Ollang from "@ollang-dev/sdk"` threw. The named import works on every version. Run `npx @ollang-dev/sdk start` from your project root where `ollang.config.ts` lives. Set `OLLANG_API_KEY` first. If you're developing the SDK from source, run `npm run build` in the SDK package. Check `includePaths` and `includePatterns` in `ollang.config.ts`. The scanner has to match real files — e.g. `messages/*.json`, `locales/**/*.json`. Confirm your i18n files exist at those paths. Allow it via `TMS_CORS_ORIGINS`: ```bash theme={null} TMS_CORS_ORIGINS=http://127.0.0.1:4200 npx @ollang-dev/sdk start ``` Multiple origins are comma-separated. See [SDK Quickstart](/sdk/quickstart#cors-and-allowed-origins). ## What to Send Support Check the [Status page](https://status.ollang.com) first — if there's an open incident, the answer may already be there. Otherwise, when opening a ticket at [info@ollang.com](mailto:info@ollang.com), include: * The **`orderId`** (or `projectId`) you're asking about. * The exact API endpoint and request method. * The full response — status code, headers (especially `x-request-id` if present), and JSON body. * Approximate **timestamp** of the request (UTC) so we can correlate logs. * For SDK / MCP / Skills: the package version, agent, and OS. Do not paste your **API key**, **OAuth tokens**, or **callback secrets** into a support email or public GitHub issue. Redact them. We never need the key value to investigate an issue — the request ID and order ID are enough. ## Status, Security, and Compliance * **[status.ollang.com](https://status.ollang.com)** — live service status, incident history, and scheduled maintenance windows. Check it before filing a ticket about availability. * **[trust.ollang.com](https://trust.ollang.com)** — the Ollang Trust Center: security, privacy, and compliance documentation. Start there for vendor security reviews and questionnaires. # Workflows and Provider Architecture Source: https://api-docs.ollang.com/workflows-provider-architecture Understand workflow configuration, provider orchestration, language-pair logic, and AI provider selection inside the Ollang Project Management Dashboard. ## Overview Workflows inside the Ollang Project Management Dashboard determine: * how Orders are processed, * which providers are used, * which AI models are selected, * how language pairs are configured, * and how localization pipelines operate. A Workflow is a reusable operational configuration that defines how localization should happen for a specific language pair. Example: ```text theme={null} English → French CC / Transcription: Ollang Agentic Subtitle Translation: OpenAI AI Dubbing: Gemini TTS ``` This allows organizations to: * standardize localization workflows, * benchmark provider quality, * and maintain consistency across multilingual operations. *** # What is a Workflow? A Workflow is a reusable configuration that determines: * which providers are used, * which language pair is localized, * how localization is processed, * and how Orders are operationalized. Instead of manually selecting providers every time, organizations can: * preconfigure workflows, * reuse them across Orders, * and standardize operational quality. B1 B2 # Workflow Scope Workflows can currently be configured at: Default workflow configuration applied across the organization. Folder-specific workflow configuration overriding global settings. Project-level workflows are not currently supported. Workflows can be configured globally or at the Folder level. *** # Global Workflows ## Overview Global workflows act as: * organization-wide default workflows. These workflows automatically apply when: * no Folder-level workflow exists. Example: ```text theme={null} Global Workflow English → French CC: Ollang Agentic Subtitle Translation: OpenAI AI Dubbing: ElevenLabs ``` This becomes: * the operational default for all applicable Orders. *** # Folder-Level Workflows ## Overview Folder-level workflows allow teams to configure localization differently for specific operational use cases. This is useful when: * different teams require different providers, * different content types require different quality standards, * or experimentation is needed. Example: ```text theme={null} Folder A English → French CC: Speechmatics Subtitles: Open AI AI Dubbing: Gemini ``` ```text theme={null} Folder B English → French CC: Ollang Agentic Subtitles: Ollang Agentic AI Dubbing: ElevenLabs ``` Even though: * the language pair is identical, the workflow may differ depending on: * operational requirements, * content type, * and quality expectations. B3 B4 # Workflow Override Logic Folder-level workflows always override: * Global workflows. Hierarchy: ```text theme={null} Folder-Level Workflow ↓ Global Workflow ``` Example: ```text theme={null} Global: English → French → Provider A Folder: English → French → Provider B ``` Result: ```text theme={null} Folder Workflow is used. ``` *** # Workflow Architecture by Order Type Different workflows can be configured independently for different localization stages. Supported workflow categories include: Speech-to-text and caption generation workflow. Translation workflow for multilingual subtitle localization. Voice synthesis workflow including Lip Sync and Audio Description. Localization workflow for structured and document-based content. Workflow coordination for studio-managed dubbing operations. *** # Multiple Workflows for the Same Language Pair Organizations may configure multiple workflows for the same language pair across different Folders. Example: ```text theme={null} Folder A English → French CC: Ollang Agentic Subtitles: Provider A Dubbing: Gemini ``` ```text theme={null} Folder B English → French CC: Speechmatics Subtitles: Provider B Dubbing: ElevenLabs ``` This enables: * benchmarking, * experimentation, * quality optimization, * and use-case-specific localization. *** # Provider Architecture ## Overview Ollang acts as an orchestration layer. Rather than forcing a single provider, the platform enables organizations to: * choose providers, * benchmark providers, * compare results, * and optimize workflows. This creates operational flexibility because: ```text theme={null} The best provider today may not be the best provider tomorrow. ``` Organizations can continuously optimize workflows based on: * quality, * speed, * language coverage, * and content type. *** # Speech-to-Text (STT) Providers Speech-to-text providers run in the `transcribe` step and are used for Video Captioning, transcription, subtitle generation, and speaker diarization. | Provider | Languages | Best for | | - | - | - | | **Agentic STT** *(default)* | — | Complex multimedia, noisy audio, multiple language streams | | **Agentic STT-1.2** *(experimental)* | — | Benchmarking the next agentic generation | | **Visual STT** *(experimental)* | — | Silent video and on-screen text | | **AssemblyAI** | 99 | General-purpose transcription with speech intelligence | | **ElevenLabs Scribe v2** | 90+ | Under-resourced languages, 32-speaker diarization | | **Speechmatics** | 70+ | Accented speech; Melia 1 auto-switches languages | | **Speechmatics with LLM** | 70+ | The same, steered by custom guidelines | | **AWS Transcribe** | 100+ locales | AWS-aligned pipelines, nine English locales | Accuracy tiers, language coverage, and hallucination risk for every transcription provider. *** # Translation Providers Translation providers run in the `translate` step and cover subtitle translation, document translation, multilingual localization, and dubbing script generation. The catalog spans 27 engines across 10 model families. | Family | Selectable models | Languages | | - | - | - | | **Ollang Agentic** *(default)* | Agentic Localization, Agentic Turbo | 100+ | | **OpenAI** | GPT-5.6 Sol and Luna, GPT-5.4, GPT-5.2, GPT-5, GPT-4.1, o4-mini | Broad | | **Anthropic Claude** | Claude 5 Fable, Opus, Sonnet; Claude 4.7 / 4.5 Opus; 4.5 / 4 Sonnet | Broad | | **Google Gemini** | Gemini 3.1 Pro, 3.7 Flash, 3 Pro, 2.5 Pro | 100+ | | **DeepL** | DeepL, DeepL Extended | 240+ | | **Amazon** | Amazon Translate | 75 | | **Cohere** | Command A | 23 | | **Mistral** | Mistral Medium 3.1 | 50+ | | **Qwen** | Qwen3-235B-A22B | 119 | | **Llama** | Llama 4 | 12 | Two families have order-type restrictions: **DeepL** serves Document and Subtitle Orders only, and **Llama 4** does not serve AI Dubbing. Everything else covers all three. Model-by-model capability notes, context windows, and order-type support. *** # Text-to-Speech (TTS) Providers TTS providers run in the `textToSpeech` step and are used for AI Dubbing, Audio Description, and multilingual speech generation. | Provider | Languages | Voices | Best for | | - | - | - | - | | **ElevenLabs Multilingual V2** *(default)* | 29 | Cloneable | Premium narration, cross-language voice identity | | **Cartesia Sonic 3.6** | 44 | Cloneable | Natural conversational delivery, fast turnaround | | **Gemini TTS** | 99 | 30 | Widest language reach, multi-speaker dialogue | | **Azure + ElevenLabs** | 90+ locales | 200+ | Voice variety, SSML timing control, custom voices | | **Deepgram TTS** | 7 | 88 | Deep English and Spanish accent coverage | | **OpenAI TTS** | 50+ | 13 | Instruction-steered delivery at high volume | Model versions, voice catalogs, and cloning support. *** # Audio Processing AI Dubbing Orders begin with the `split` step, which separates the dialogue stem from the music-and-effects bed so the original score and sound design survive localization. **LALAL.AI** *(default)* — multi-network stem separation with direct synthesis, selectable noise cancelling, and dereverberation. How stem separation shapes the final dubbing mix. *** # Workflow Lifecycle ## Important Operational Rule Workflow updates only affect future Orders. Already-created Orders: * remain unchanged, * preserve their operational workflow, * and continue using the workflow selected at Order creation. *** # AI Quality Benchmarking Organizations commonly benchmark providers using: * AI QC Evaluation, * Human QC Annotation, * analytics, * and localization performance tracking. This helps teams understand: ```text theme={null} Which provider works best for which language pair, content type, or workflow. ``` Because the AI ecosystem evolves rapidly: ```text theme={null} The best-performing provider today may not remain the best tomorrow. ``` The platform is intentionally designed for: * experimentation, * optimization, * and provider flexibility. *** # Example Enterprise Workflow ```text theme={null} English → French CC: Ollang Agentic Subtitle Translation: OpenAI AI Dubbing: Gemini TTS QC Evaluation: Enabled ``` *** # Example Multi-Folder Benchmarking ```text theme={null} Folder A → Marketing Content English → French Dubbing: Gemini ``` ```text theme={null} Folder B → Entertainment Content English → French Dubbing: ElevenLabs ``` Teams can later compare: * localization quality, * human edit percentage, * QC outcomes, * and operational performance. *** # Important Operational Notes No. Workflows can currently be configured at Global level and Folder level only. Yes. Folder-level workflows always take precedence. Yes. Different Folders may use different workflows for the same language pair. No. Workflow updates only affect future Orders. Yes. Different workflow stages can use different providers. No. Ollang acts as an orchestration layer and allows organizations to choose providers based on operational goals.