# Delete Lilt Create content Source: https://support.lilt.com/api-reference/create/delete-lilt-create-content /api-reference/openapi-bundled.yaml delete /v2/create/{contentId} Delete a piece of Lilt Create content. Example CURL: ```bash curl -X DELETE 'https://api.lilt.com/v2/create/1234?key=API_KEY' ``` # Generate new Lilt Create content Source: https://support.lilt.com/api-reference/create/generate-new-lilt-create-content /api-reference/openapi-bundled.yaml post /v2/create Generate new Lilt Create content with the given parameters. Example CURL: ```bash curl -X POST 'https://api.lilt.com/v2/create?key=API_KEY' \ --header 'Content-Type: application/json' \ --data-raw '{ "language":"en-US", "template":"blog-post", "templateParams":{ "contentLength":"100", "language":"en-US", "sections":[], "summary":"a blog post about hiking" }, "preferences":{"tone":"formal","styleguide":""} }' ``` # Get Lilt Create content Source: https://support.lilt.com/api-reference/create/get-lilt-create-content /api-reference/openapi-bundled.yaml get /v2/create Get a list of all content that has been generated by Lilt Create. Example CURL: ```bash curl -X GET 'https://api.lilt.com/v2/create?key=API_KEY' ``` # Get Lilt Create content by ID. Source: https://support.lilt.com/api-reference/create/get-lilt-create-content-by-id /api-reference/openapi-bundled.yaml get /v2/create/{contentId} Get Lilt Create content by ID. Example CURL: ```bash curl -X GET 'https://api.lilt.com/v2/create/1234?key=API_KEY' ``` # Update Lilt Create content Source: https://support.lilt.com/api-reference/create/update-lilt-create-content /api-reference/openapi-bundled.yaml put /v2/create/{contentId} Update a piece of Lilt Create content. Example CURL: ```bash curl -X PUT 'https://api.lilt.com/v2/create/1234?key=API_KEY' \ --header 'Content-Type: application/json' \ --data-raw '{"language":"de-DE"}' ``` # Download a Document Source: https://support.lilt.com/api-reference/documents/download-a-document /api-reference/openapi-bundled.yaml get /v2/documents/files Export a Document that has been translated in the Lilt web application. Any Document can be downloaded in XLIFF 1.2 format, or can be retrieved in its original uploaded format by setting `is_xliff=false`. This endpoint will fail if either (a) export or (b) pre-translation operations are in-progress. The status of those operations can be determined by retrieving the Document resource. Example CURL command: ```bash curl -X GET https://api.lilt.com/v2/documents/files?key=API_KEY&id=274 -o from_lilt.xliff ``` # Pretranslate Documents Source: https://support.lilt.com/api-reference/documents/pretranslate-documents /api-reference/openapi-bundled.yaml post /v2/documents/pretranslate Pretranslate one or more Documents using translation memory (TM) and, optionally, machine translation (MT). Only documents that are not currently importing/exporting and are not already pretranslating will be pretranslated; the response always reflects the current state of every requested Document id, whether or not it was eligible. This is an asynchronous operation. The endpoint returns immediately with a `202` response once pretranslation has been queued; poll the Document resource (or the `is_pretranslating` / `status.pretranslation` fields it returns) to see when pretranslation has finished. This endpoint is subject to a per-organization rate limit. See the [API Rate Limits guide](/developers/guides/rate-limits) for details on how to read `429` responses and batch requests efficiently by passing multiple document ids in a single call. Example CURL: ```bash curl -X POST 'https://api.lilt.com/v2/documents/pretranslate?key=API_KEY' \ --header 'Content-Type: application/json' \ --data-raw '{"id": [274, 275], "mode": "TM+MT", "auto_accept": true}' ``` # Upload a File Source: https://support.lilt.com/api-reference/documents/upload-a-file /api-reference/openapi-bundled.yaml post /v2/documents/files Create a Document from a file in any of the formats [documented in our knowledge base](/kb/supported-file-formats). Request parameters should be passed as JSON object with the header field `LILT-API`. File names in the header can only contain [US-ASCII characters](https://en.wikipedia.org/wiki/ASCII). File names with characters outside of US-ASCII should be [URI encoded](https://en.wikipedia.org/wiki/Percent-encoding) or transliterated to US-ASCII strings. Example CURL command: ```bash curl -X POST https://api.lilt.com/v2/documents/files?key=API_KEY \ --header "LILT-API: {\"name\": \"introduction.xliff\",\"pretranslate\": \"tm+mt\",\"project_id\": 9}" \ --header "Content-Type: application/octet-stream" \ --data-binary @Introduction.xliff ``` # Retrieve Domains Source: https://support.lilt.com/api-reference/domains/retrieve-domains /api-reference/openapi-bundled.yaml get /v3/domains Retrieve a list of Domains associated with the Organization's API key. Each Domain contains potentially 4 Arrays related to the Domain these are as follows: - models - the list of models associated with the Domain - filterConfigs - the list of filterConfigs associated with the Domain - domainMetadata - the list of Domain specific options that have been configured for this domain. # Add Label to File Source: https://support.lilt.com/api-reference/files/add-label-to-file /api-reference/openapi-bundled.yaml post /v2/files/labels Add a label to a File. Example CURL: ```bash curl -X POST 'https://api.lilt.com/v2/files/labels?key=API_KEY&id=1' --header 'Content-Type: application/json' \ --data-raw '{ "name": "label_name" }' ``` # Delete a File Source: https://support.lilt.com/api-reference/files/delete-a-file /api-reference/openapi-bundled.yaml delete /v2/files Delete a File. Example CURL command: ```bash curl -X DELETE https://api.lilt.com/v2/files?key=API_KEY&id=123 ``` # Download file Source: https://support.lilt.com/api-reference/files/download-file /api-reference/openapi-bundled.yaml get /v2/files/download Download a File. Example CURL: ```bash curl -X GET 'https://api.lilt.com/v2/files/download?key=API_KEY&id=1' ``` # Remove Label from File Source: https://support.lilt.com/api-reference/files/remove-label-from-file /api-reference/openapi-bundled.yaml delete /v2/files/labels Remove a label from a File. Example CURL: ```bash curl -X DELETE 'https://api.lilt.com/v2/files/labels?key=API_KEY&id=1&name=label_name' ``` # Retrieve a File Source: https://support.lilt.com/api-reference/files/retrieve-a-file /api-reference/openapi-bundled.yaml get /v2/files Retrieves one or more files available to your user. Files are not associated with a project or a memory. They are unprocessed and can be used later in the project/document creation workflow step. To retrieve a specific file, specify the id request parameter. To retrieve all files, omit the id request parameter. Example CURL command: ```bash curl -X GET https://api.lilt.com/v2/files?key=API_KEY&id=274 ``` # Upload a File Source: https://support.lilt.com/api-reference/files/upload-a-file /api-reference/openapi-bundled.yaml post /v2/files Upload a File in any of the formats [documented in our knowledge base](/kb/supported-file-formats). Request parameters should be passed in as query string parameters. Example CURL command: ```bash curl -X POST https://api.lilt.com/v2/files?key=API_KEY&name=en_US.json \ --header "Content-Type: application/octet-stream" \ --data-binary @en_US.json ``` Calls to GET /files are used to monitor the language detection results. The API response will be augmented to include detected language and confidence score. The language detection will complete asynchronously. Prior to completion, the `detected_lang` value will be `zxx`, the reserved ISO 639-2 code for "No linguistic content/not applicable". If the language can not be determined, or the detection process fails, the `detected_lang` field will return `und`, the reserved ISO 639-2 code for undetermined language, and the `detected_lang_confidence` score will be `0`. # Archive a Job Source: https://support.lilt.com/api-reference/jobs/archive-a-job /api-reference/openapi-bundled.yaml post /v2/jobs/{jobId}/archive Set job to archived, unassign all linguists and archive all projects and documents inside the job. It will return the archived job. Example CURL command: ```bash curl -X POST 'https://api.lilt.com/v2/jobs/{id}/archive?key=API_KEY' ``` # Create a Job Source: https://support.lilt.com/api-reference/jobs/create-a-job /api-reference/openapi-bundled.yaml post /v2/jobs Create a Job. A Job is a collection of Projects. A Job will contain multiple projects, based on the language pair. A Project is associated with exactly one Memory. Jobs appear in the Jobs dashboard of the web app. Example CURL command: ```bash curl -X POST 'https://api.lilt.com/v2/jobs?key=API_KEY' \ --header 'Content-Type: application/json' \ --data-raw '{ "name": "test job", "fileIds": [5009, 5010, 5011], "due": "2022-05-05T10:56:44.985Z", "srcLang": "en", "srcLocale": "US", "languagePairs": [ { "memoryId": 3121, "trgLang": "de" }, { "memoryId": 2508, "trgLang": "fr" }, { "memoryId": 3037, "trgLang": "zh" } ] }' ``` # Delete a Job Source: https://support.lilt.com/api-reference/jobs/delete-a-job /api-reference/openapi-bundled.yaml delete /v2/jobs/{jobId} Delete a job, deletes all projects and documents in the job, deletes all the segments from all the job's translation memories. Example CURL command: ```bash curl -X DELETE 'https://api.lilt.com/v2/jobs/{id}?key=API_KEY' ``` # Deliver a Job Source: https://support.lilt.com/api-reference/jobs/deliver-a-job /api-reference/openapi-bundled.yaml post /v2/jobs/{jobId}/deliver Set the job state to delivered and set all the projects in the job to done It will return the delivered job. Example CURL command: ```bash curl -X POST 'https://api.lilt.com/v2/jobs/{id}/deliver?key=API_KEY' ``` # Download a Job Source: https://support.lilt.com/api-reference/jobs/download-a-job /api-reference/openapi-bundled.yaml get /v2/jobs/{jobId}/download Make sure you have exported a job with the same id before using this api. Downloading files requires the exported job `id` in the param. Example CURL command: ```bash curl -X GET 'https://api.lilt.com/v2/jobs/{id}/download?key=API_KEY' ``` # Export a Job Source: https://support.lilt.com/api-reference/jobs/export-a-job /api-reference/openapi-bundled.yaml get /v2/jobs/{jobId}/export Prepare job files for download. To export translated documents from the job use the query parameter `type=files`: Example CURL command: ```bash curl -X GET 'https://api.lilt.com/v2/jobs/{id}/export?key=API_KEY&type=files' ``` To export job memories use the query parameter `type=memory`. The status of the export can be checked by requesting the job `GET /jobs/:jobId`, `job.isProcessing` will be `1` while in progress, `0` when idle and `-2` when the export failed. # Reactivate a Job Source: https://support.lilt.com/api-reference/jobs/reactivate-a-job /api-reference/openapi-bundled.yaml post /v2/jobs/{jobId}/reactivate Set the job state to active. Does not change the state of projects associated with the given job. It will return the reactivated job. Example CURL command: ```bash curl -X POST 'https://api.lilt.com/v2/jobs/{id}/reactivate?key=API_KEY' ``` # Retrieve a Job Source: https://support.lilt.com/api-reference/jobs/retrieve-a-job /api-reference/openapi-bundled.yaml get /v2/jobs/{jobId} Retrieves a job data along with stats. To retrieve a specific job, you will need the job `id` in the url path. Example CURL command: ```bash curl -X GET 'https://api.lilt.com/v2/jobs/{id}?key=API_KEY' ``` # Retrieve all Jobs Source: https://support.lilt.com/api-reference/jobs/retrieve-all-jobs /api-reference/openapi-bundled.yaml get /v2/jobs Get all Jobs within a given offset and limit. You can retrieve jobs from your account using the above API. Example CURL command: ```bash curl -X GET 'https://api.lilt.com/v2/jobs?key=API_KEY&isArchived=false' ``` # Retrieve Job Leverage Stats Source: https://support.lilt.com/api-reference/jobs/retrieve-job-leverage-stats /api-reference/openapi-bundled.yaml get /v2/jobs/{jobId}/stats Get the TM leverage stats for the job (new/exact/fuzzy matches). Example CURL command: ```bash curl -X GET 'https://api.lilt.com/v2/jobs/{id}/stats?key=API_KEY' ``` # Unarchive a Job Source: https://support.lilt.com/api-reference/jobs/unarchive-a-job /api-reference/openapi-bundled.yaml post /v2/jobs/{jobId}/unarchive Set job to unarchived, the job will move to active status. Example CURL command: ```bash curl -X POST 'https://api.lilt.com/v2/jobs/{id}/unarchive?key=API_KEY' ``` # Update a Job Source: https://support.lilt.com/api-reference/jobs/update-a-job /api-reference/openapi-bundled.yaml put /v2/jobs/{jobId} Updates a job with the new job properties. To update a specific job, you will need the job `id` in the url path. You can update job's name and due date by passing the property and new value in the body. Example CURL command: ```bash curl -X PUT 'https://api.lilt.com/v2/jobs/{id}?key=API_KEY' \ --header 'Content-Type: application/json' \ --data-raw '{ "name": "test job", "due": "2022-05-05T10:56:44.985Z" }' ``` # Retrieve supported languages Source: https://support.lilt.com/api-reference/languages/retrieve-supported-languages /api-reference/openapi-bundled.yaml get /v2/languages Get a list of supported languages. # Create a Memory Source: https://support.lilt.com/api-reference/memories/create-a-memory /api-reference/openapi-bundled.yaml post /v2/memories Create a new Memory. A Memory is a container that collects source/target sentences for a specific language pair (e.g., English>French). The data in the Memory is used to train the MT system, populate the TM, and update the lexicon. Memories are private to your account - the data is not shared across users - unless you explicitly share a Memory with your team (via web app only). Refer to our KB for a more detailed description. # Delete a Memory Source: https://support.lilt.com/api-reference/memories/delete-a-memory /api-reference/openapi-bundled.yaml delete /v2/memories Delete a Memory. # Delete a segment from a memory. Source: https://support.lilt.com/api-reference/memories/delete-a-segment-from-a-memory /api-reference/openapi-bundled.yaml delete /v2/memories/segment Delete a segment from a memory. ```bash curl -X DELETE https://api.lilt.com/v2/memories/segment?key=API_KEY&id=ID&segment_id=$SEGMENT_ID ``` # File import for a Memory Source: https://support.lilt.com/api-reference/memories/file-import-for-a-memory /api-reference/openapi-bundled.yaml post /v2/memories/import Imports common translation memory or termbase file formats to a specific LILT memory. Currently supported file formats are `*.tmx`, `*.sdltm`, `*.sdlxliff`(With custom Filters), '*.xliff', and `*.tmq` for TM data; `*.csv` and `*.tbx` for termbase data. Request parameters should be passed as JSON object with the header field `LILT-API`. Example CURL command to upload a translation memory file named `my_memory.sdltm` in the current working directory: ```bash curl -X POST https://api.lilt.com/v2/memories/import?key=API_KEY \ --header "LILT-API: {\"name\": \"my_memory.sdltm\",\"memory_id\": 42}" \ --header "Content-Type: application/octet-stream" \ --data-binary @my_memory.sdltm ``` Example CURL command to upload a translation memory file named `my_memory.sdlxliff` in the current working directory, with Custom Filters based on SDLXLIFF fields, conf_name which maps to, percentage, and whether we should ignore unlocked segments. ```bash curl -X POST https://api.lilt.com/v2/memories/import?key=API_KEY \ --header "LILT-API: {\"name\": \"my_memory.sdlxliff\",\"memory_id\": 12,\"sdlxliff_filters\":[{\"conf_name\": \"Translated\", \"percentage\": 100, \"allow_unlocked\": false}]"}" \ --header "Content-Type: application/octet-stream" \ --data-binary @my_memory.sdlxliff ``` # Query a Memory Source: https://support.lilt.com/api-reference/memories/query-a-memory /api-reference/openapi-bundled.yaml get /v2/memories/query Perform a translation memory query. # Retrieve a Memory Source: https://support.lilt.com/api-reference/memories/retrieve-a-memory /api-reference/openapi-bundled.yaml get /v2/memories Retrieve a Memory. If you cannot access the Memory (401 error) please check permissions (e.g. in case you created the Memory via the web app with a different account you may have to explicitly share that Memory). # Termbase download for a Memory Source: https://support.lilt.com/api-reference/memories/termbase-download-for-a-memory /api-reference/openapi-bundled.yaml get /v2/memories/termbase/download Downloads the termbase export for the given memory as a CSV file. Ensure you first call the `/2/memories/termbase/export` endpoint to start the export process before you try to download it. ```bash curl -X GET https://api.lilt.com/v2/memories/termbase/download?key=API_KEY&id=ID ``` # Termbase export for a Memory Source: https://support.lilt.com/api-reference/memories/termbase-export-for-a-memory /api-reference/openapi-bundled.yaml post /v2/memories/termbase/export Exports the termbase entries for the given memory into a CSV file. Calling this endpoint will begin the export process in the background. Check that the processing is complete by polling the `GET /2/memories` endpoint. When the `is_processing` value is 0 then call the `POST /2/memories/termbase/download` endpoint. ```bash curl -X POST https://api.lilt.com/v2/memories/termbase/export?key=API_KEY&id=ID ``` # Update the name of a Memory Source: https://support.lilt.com/api-reference/memories/update-the-name-of-a-memory /api-reference/openapi-bundled.yaml put /v2/memories Update a Memory. # Create a Project Source: https://support.lilt.com/api-reference/projects/create-a-project /api-reference/openapi-bundled.yaml post /v2/projects Create a Project. A Project is a collection of Documents. A Project is associated with exactly one Memory. Projects appear in the dashboard of the web app. # Delete a Project Source: https://support.lilt.com/api-reference/projects/delete-a-project /api-reference/openapi-bundled.yaml delete /v2/projects Delete a Project. # Retrieve a Project Source: https://support.lilt.com/api-reference/projects/retrieve-a-project /api-reference/openapi-bundled.yaml get /v2/projects Retrieves one or more projects, including the documents associated with each project. Retrieving a project is the most efficient way to retrieve a single project, multiple projects or a list of all available projects. To retrieve a specific project, specify the `id` request parameter or you can retrieve multiple projects by adding comma (,) between ids eg. `?id=1234,5678`. To retrieve all projects, omit the `id` request parameter. To limit the retrieved projects to those with a particular source language or target language, specify the corresponding ISO 639-1 language codes in the `srclang` and `trglang` request parameters, respectively. # Create a Segment Source: https://support.lilt.com/api-reference/segments/create-a-segment /api-reference/openapi-bundled.yaml post /v2/segments Create a Segment and add it to a Memory or a Document. A Segment is a source/target pair that is used to train the machine translation system and populate the translation memory. The maximum source length is 5,000 characters. # Delete a Segment Source: https://support.lilt.com/api-reference/segments/delete-a-segment /api-reference/openapi-bundled.yaml delete /v2/segments Delete a Segment from memory. This will not delete a segment from a document. # Retrieve a Segment Source: https://support.lilt.com/api-reference/segments/retrieve-a-segment /api-reference/openapi-bundled.yaml get /v2/segments Retrieve a Segment. # Tag a Segment Source: https://support.lilt.com/api-reference/segments/tag-a-segment /api-reference/openapi-bundled.yaml get /v2/segments/tag Project tags for a segment. The `source_tagged` string contains one or more SGML tags. The `target` string is untagged. This endpoint will automatically place the source tags in the target. Usage charges apply to this endpoint for production REST API keys. # Unaccept and unlock segments Source: https://support.lilt.com/api-reference/segments/unaccept-and-unlock-segments /api-reference/openapi-bundled.yaml post /v2/segments/review/unlock Unaccept and unlock segments. Sets individual segments' "Review Done" to false. Confirmed segments will remain confirmed. Example curl: ``` curl --X --request POST 'https://lilt.com/2/segments/review/unlock?key=API_KEY' \ --header 'Content-Type: application/json' \ --data-raw '{ "segmentIds": [23921, 23922] }' ``` # Update a Segment Source: https://support.lilt.com/api-reference/segments/update-a-segment /api-reference/openapi-bundled.yaml put /v2/segments Update a Segment in memory. The Memory will be updated with the new target string. # Download translated file Source: https://support.lilt.com/api-reference/translate/download-translated-file /api-reference/openapi-bundled.yaml get /v2/translate/files Download a translated File. Example CURL: ```bash curl -X GET 'https://api.lilt.com/v2/translate/files?key=API_KEY&id=1' ``` # Monitor file translation Source: https://support.lilt.com/api-reference/translate/monitor-file-translation /api-reference/openapi-bundled.yaml get /v2/translate/file Get information about the one or more Files that are being translated with machine translation. Query filters are optional but at least one must be provided. Example CURL: ```bash curl -X GET 'https://api.lilt.com/v2/translate/file?key=API_KEY&translationIds=1,2&fromTime=1607966744&toTime=1707966744&status=InProgress' ``` # Translate a File Source: https://support.lilt.com/api-reference/translate/translate-a-file /api-reference/openapi-bundled.yaml post /v2/translate/file Start machine translation of one or more Files that have previously been uploaded. The response will include an `id` parameter that can be used to monitor and download the translations in subsequent calls. Example CURL: ```bash curl -X POST 'https://api.lilt.com/v2/translate/file?key=API_KEY&fileId=583&memoryId=2495&configId=123&withTM=true' ``` # Translate a segment Source: https://support.lilt.com/api-reference/translate/translate-a-segment /api-reference/openapi-bundled.yaml get /v2/translate Translate a source string. Functionally identical to `POST /v2/translate`, with parameters passed as query string parameters instead of a JSON request body. Useful for simple integrations that prefer a GET request. Setting the `rich` parameter to `true` will change the response format to include additional information about each translation including a model score, word alignments, and formatting information. By default, this endpoint also returns translation memory (TM) fuzzy matches, along with associated scores. Fuzzy matches always appear ahead of machine translation output in the response. The maximum source length is 5,000 characters. Usage charges apply to this endpoint for production API keys. # Translate a segment Source: https://support.lilt.com/api-reference/translate/translate-a-segment-1 /api-reference/openapi-bundled.yaml post /v2/translate Translate a source string. Setting the `rich` parameter to `true` will change the response format to include additional information about each translation including a model score, word alignments, and formatting information. The rich format can be seen in the example response on this page. By default, this endpoint also returns translation memory (TM) fuzzy matches, along with associated scores. Fuzzy matches always appear ahead of machine translation output in the response. The maximum source length is 5,000 characters. Usage charges apply to this endpoint for production API keys. # Cancel Multipart Upload Source: https://support.lilt.com/api-reference/uploads/cancel-multipart-upload /api-reference/openapi-bundled.yaml delete /v2/upload/s3/multipart/{uploadId} Cancel/abort a multipart upload and clean up any uploaded parts. Example CURL command: ``` curl -X DELETE "https://lilt.com/v2/upload/s3/multipart/abc123def456?key=API_KEY&key=uploads/user123/file456.zip" ``` # Complete Multipart Upload Source: https://support.lilt.com/api-reference/uploads/complete-multipart-upload /api-reference/openapi-bundled.yaml post /v2/upload/s3/multipart/{uploadId}/complete Complete a multipart upload by providing all uploaded parts information. Example CURL command: ``` curl -X POST "https://lilt.com/v2/upload/s3/multipart/abc123def456/complete?key=API_KEY&key=uploads/user123/file456.zip" \ --header "Content-Type: application/json" \ --data-raw '{ "parts": [ {"ETag": "etag1", "PartNumber": 1}, {"ETag": "etag2", "PartNumber": 2} ] }' ``` # Get All Pending Uploads or specific list of uploads by ids or statuses Source: https://support.lilt.com/api-reference/uploads/get-all-pending-uploads-or-specific-list-of-uploads-by-ids-or-statuses /api-reference/openapi-bundled.yaml get /v2/upload Retrieve all pending uploads for the current user and organization. Example CURL command: ``` curl -X GET https://lilt.com/2/upload?key=API_KEY ``` # Get S3 Upload Parameters Source: https://support.lilt.com/api-reference/uploads/get-s3-upload-parameters /api-reference/openapi-bundled.yaml get /v2/upload/s3/params Get S3 upload parameters via query string. This endpoint provides the necessary information to complete the file upload process using GET parameters. Example CURL command: ``` curl -X GET "https://lilt.com/v2/upload/s3/params?key=API_KEY&filename=example.json&type=application/json&metadata.size=1024&metadata.labels=important,review-needed" ``` # Get Upload by ID Source: https://support.lilt.com/api-reference/uploads/get-upload-by-id /api-reference/openapi-bundled.yaml get /v2/upload/{uploadId} Retrieve a specific upload by its unique identifier. Example CURL command: ``` curl -X GET https://lilt.com/2/upload/12345?key=API_KEY ``` # Initiate File Upload to Cloud Storage Source: https://support.lilt.com/api-reference/uploads/initiate-file-upload-to-cloud-storage /api-reference/openapi-bundled.yaml post /v2/upload/s3/params Initiate the upload of a file to cloud storage. This endpoint provides the necessary information to complete the file upload process. Supports both single file and bulk upload requests. For bulk uploads, pass an array of upload objects (maximum 100 items). The response format matches the request format - a single object for single file requests, or an array for bulk requests. Example CURL command (single file): ``` curl -X POST https://lilt.com/v2/upload/s3/params?key=API_KEY \ --header "Content-Type: application/json" \ --data-raw '{ "filename": "example.json", "type": "application/json", "metadata": { "size": 1024, "labels": ["important", "review-needed"] } }' ``` Example CURL command (bulk upload): ``` curl -X POST https://lilt.com/v2/upload/s3/params?key=API_KEY \ --header "Content-Type: application/json" \ --data-raw '[ { "filename": "file1.json", "type": "application/json", "metadata": { "size": 1024 } }, { "filename": "file2.txt", "type": "text/plain", "metadata": { "size": 2048 } } ]' ``` # Initiate Multipart Upload Source: https://support.lilt.com/api-reference/uploads/initiate-multipart-upload /api-reference/openapi-bundled.yaml post /v2/upload/s3/multipart Initiate a multipart upload for large files. This endpoint provides the necessary information to start a multipart upload process. Supports both single file and bulk upload requests. For bulk uploads, pass an array of upload objects (maximum 100 items). The response format matches the request format - a single object for single file requests, or an array for bulk requests. Example CURL command (single file): ``` curl -X POST https://lilt.com/v2/upload/s3/multipart?key=API_KEY \ --header "Content-Type: application/json" \ --data-raw '{ "filename": "large-file.zip", "type": "application/zip", "metadata": { "size": 104857600 } }' ``` Example CURL command (bulk upload): ``` curl -X POST https://lilt.com/v2/upload/s3/multipart?key=API_KEY \ --header "Content-Type: application/json" \ --data-raw '[ { "filename": "large-file1.zip", "type": "application/zip", "metadata": { "size": 104857600 } }, { "filename": "large-file2.zip", "type": "application/zip", "metadata": { "size": 209715200 } } ]' ``` # Sign Upload Part Source: https://support.lilt.com/api-reference/uploads/sign-upload-part /api-reference/openapi-bundled.yaml get /v2/upload/s3/multipart/{uploadId}/{partNumber} Get a signed URL for uploading a specific part of a multipart upload. Make sure to set the part size to 8MB (8388608 bytes). Example CURL command: ``` curl -X GET "https://lilt.com/v2/upload/s3/multipart/abc123def456/1?key=API_KEY&key=uploads/user123/file456.zip&size=5242880" ``` # Creates a new Webhook Configuration Source: https://support.lilt.com/api-reference/webhook-configuration/creates-a-new-webhook-configuration /api-reference/openapi-bundled.yaml post /v3/connectors/configuration/webhooks Creates a new webhook configuration for your LILT organization. # Delete a specific Webhook Configuration by ID. Source: https://support.lilt.com/api-reference/webhook-configuration/delete-a-specific-webhook-configuration-by-id /api-reference/openapi-bundled.yaml delete /v3/connectors/configuration/webhooks/{id} # Retrieve a list of Webhook Configurations. Source: https://support.lilt.com/api-reference/webhook-configuration/retrieve-a-list-of-webhook-configurations /api-reference/openapi-bundled.yaml get /v3/connectors/configuration/webhooks Retrieves a list of webhook configurations available to your LILT organization. Use this to manage your webhook configurations. # Retrieve a specific Webhook Configuration by ID. Source: https://support.lilt.com/api-reference/webhook-configuration/retrieve-a-specific-webhook-configuration-by-id /api-reference/openapi-bundled.yaml get /v3/connectors/configuration/webhooks/{id} Retrieves a specific webhook configuration by its ID. Deleted webhook configurations are not returned. # Update a specific Webhook Configuration by ID. Source: https://support.lilt.com/api-reference/webhook-configuration/update-a-specific-webhook-configuration-by-id /api-reference/openapi-bundled.yaml put /v3/connectors/configuration/webhooks/{id} Updates a specific webhook configuration by its ID. Only the fields that are provided in the request body will be updated. # Retrieve workflow templates Source: https://support.lilt.com/api-reference/workflows/retrieve-workflow-templates /api-reference/openapi-bundled.yaml get /v2/workflows/templates Get all of the possible Workflow Templates owned by the team. Useful for retrieving the ids corresponding to each workflow tables, and passing them to subsequent requests, for example, creating a new Job with a specific Workflow. Example CURL: ```bash curl -X GET 'https://api.lilt.com/v2/workflows/templates?key=API_KEY' ``` # Connect Systems To Workflows Source: https://support.lilt.com/developers/guides/connect-systems-to-workflows The LILT Connectors framework simplifies the process of integrating external applications and services with the LILT platform. It provides a standardized approach for building connectors, reducing development time and effort. These connectors act as bridges, allowing data to flow seamlessly between LILT and other tools. This not only streamlines workflows but also expands LILT's capabilities by enabling it to leverage functionalities offered by external systems. With the LILT Connectors framework, users can benefit from a wider range of features and data sources, ultimately enhancing the efficiency and effectiveness of their localization processes. The Connectors that LILT supports grows over time, a current list can be found [here](https://lilt.com/connectors). If you want an in-depth guide for how the connectors integrate with a specific partner, check out our [knowledge base](/kb/connectors). # Create Content Source: https://support.lilt.com/developers/guides/create-new-content LILT Create offers an alternative to normal translation, by allowing you to generate content in the target language using various prompts to get your message across more organically in the new language. This can make your content easier to understand for users of that language and can empower a global audience. This guide will demonstrate how to: * [Generate Content](#generate-content) * [Retrieve Generated Content](#get-generated-content) * [Update or Delete Content](#update-or-delete-content) Things you will need: * API Key - All requests throughout the LILT API use the API Key to authenticate. ## Generate Content There are a few things to consider before Generating Content: 1. What do I want to generate? This can be as simple as "Write a story about bees" or "Write a paragraph about product X". As long as your prompt is below the character limit of 500. 2. How do I want to group the content to be generated? Writing an article that is split into multiple sections with different headings, add sections to structure the generated content. 3. Do I want to use Terminology specific to my organization? Add a `memoryId` to the request. [See the API docs for more info](/api-reference/create/generate-new-lilt-create-content). Below is an example request to generate content in English. ```bash theme={null} curl -X POST 'https://api.lilt.com/v2/create?key=API_KEY' \ --header 'Content-Type: application/json' \ --data-raw '{ "language":"en-US", "template":"blog-post", "templateParams":{ "contentLength":"1000", "language":"en-US", "sections":["Bees and me","Honey for you", "Conclusion"], "summary":"a blog post about how important bees are to my honey farm" }, "preferences":{"tone":"formal","styleguide":""} }' ``` The response is an event stream of the generated content. You can choose to read the stream, or you can choose to wait until a DONE message is emitted. Try it out with something that makes sense for your organization or a different language you are proficient with. ## Get Generated Content As you Create more it might become necessary to get content you already generated previously. You can get a complete list of everything you have created previously using this [endpoint](/api-reference/create/get-lilt-create-content): ```powershell theme={null} curl -X GET 'https://api.lilt.com/v2/create?key=API_KEY' ``` You can also retrieve a single piece of content by its ID using the [Get Lilt Create content by ID endpoint](/api-reference/create/get-lilt-create-content-by-id): ```powershell theme={null} curl -X GET 'https://api.lilt.com/v2/create/1234?key=API_KEY' ``` ## Update or Delete Content Existing Lilt Create content can be updated (for example, to change the language) or deleted using the content's ID. ```bash theme={null} curl -X PUT 'https://api.lilt.com/v2/create/1234?key=API_KEY' \ --header 'Content-Type: application/json' \ --data-raw '{"language":"de-DE"}' ``` ```bash theme={null} curl -X DELETE 'https://api.lilt.com/v2/create/1234?key=API_KEY' ``` See the [API Specification](/api-reference/create/get-lilt-create-content-by-id) for the full request and response shapes for these endpoints. # Create A Data Source Source: https://support.lilt.com/developers/guides/manage-content/create-a-datasource What is a Data Source? A Data Source is an object that links all of your translated content together for a given language. It allows the LILT system to reference all of your previous translations, TMX files and Termbases(TB) to provide you with the most accurate translation possible. Things you will need: * API Key - All requests through the LILT API use the API Key to authenticate. * (Optional) TMX File - TMX files contain sentence to sentence translations and serve as a basis for translating content, these files aren't necessary but can produce better Instant Translate results for your documents depending on the quality of the data provided. * (Optional) TB File - Your business likely has specific product names, advertising terminology, and other words that you may or may not want translated. Adding a TB (Termbase) file to the Data Source creates a managed way to translate certain words/phrases for your business. **Note:** Data Sources can also be referred to as Memories. Anywhere in the docs that mentions a `memoryId` or `/memories` endpoint is referring to a Data Source. ## Create a Data Source Creating a Data Source with LILT is a straight-forward process. For this example we will create a Data Source in English to German using Locales. If you want to try a different language, a list of supported languages and how to access them is available in the [Quick Start Guide](/developers/quickstart). Here is an example API call to create a Data Source plus the Request body. [See the API docs for more info](/api-reference/memories/create-a-memory) ```bash theme={null} curl -X POST https://api.lilt.com/v2/memories?key=API_KEY \ --header "Content-Type: application/json" \ --data '{"name": "Test Data Source","srclang": "en","trglang": "de","srclocale": "US","trglocale": "DE"}' ``` Once the call is made you should expect to see a response that looks something like this: ```json theme={null} { "id": 1234, "srclang": "en", "trglang": "de", "srclocale": "US", "trglocale": "DE", "name": "Test Data Source", "is_processing": false, "version": 78, "created_at": 1489147692, "updated_at": 1489147692, "resources": ["string"] } ``` Congratulations, you have successfully created a Data Source. ## Add a TMX file/TB file to your Data Source A Data Source is only as useful as the data stored within. LILT uses memories as a way to keep track of your organizations content in a language pair format. Adding data to an empty Data Source is a typical first step when onboarding to LILT. If your organization has done localization in the past, chances are that you have a tmx file/tb file that needs to be added to your Data Source to ensure that your historical data is taken into consideration by the LILT Transformative AI. For this example we will upload a tmx file called "test.tmx" using the [import file endpoint](/api-reference/memories/file-import-for-a-memory) ```bash theme={null} curl -X POST https://api.lilt.com/v2/memories/import?key=API_KEY \ --header "LILT-API: {\"name\": \"test.tmx\",\"memory_id\": 1234}" \ --header "Content-Type: application/octet-stream" \ --data-binary @test.tmx ``` This should elicit a 200 response that looks something like this: ```json theme={null} { "id": 123, "isProcessing": 1 } ``` This response means is that the request was registered successfully and your file is being processed by LILT into Segments which will become part of the Data Source. This process is asynchronous and can be verified using the [memories endpoint](/api-reference/memories/retrieve-a-memory): ```bash theme={null} curl -X GET https://api.lilt.com/v2/memories?key=API_KEY&id=1234\ ``` This request will give you a response similar to the creation logic, with the key difference of seeing the new resource in the resources list. ```json theme={null} { "id": 1234, "srclang": "en", "trglang": "de", "srclocale": "US", "trglocale": "DE", "name": "Test Data Source", "is_processing": false, "version": 78, "created_at": 1489147692, "updated_at": 1489147692, "resources": ["test.tmx"] } ``` # Data Source Management Source: https://support.lilt.com/developers/guides/manage-content/tm-query In the normal course of translation and localization, there will be times where you need to verify the existence of a specific sentence/word/phrase in your Data Source. Whether that is because the target language has changed how it uses the word in the course of a languages evolution or if you simply want to verify that the Term your organization uses to describe a specific product is correct, this guide will show you how to look things up in a LILT Data Source without having to pull down the whole file. In this guide you will learn how to: * [Query a Data Source](#get-generated-content) Things you will need: * API Key - All requests through the LILT API use the API Key to authenticate. ## Query a Data Source Querying a Data Source in LILT uses a string lookup to pull specific segments that fit the source provided. In this example the string we will use is "LILT Create". Please note that the n in the query is a limit on the number of segments to pull. [See the API docs for more info](/api-reference/memories/query-a-memory) ```bash theme={null} curl -X GET https://api.lilt.com/v2/memories/query?key=API_KEY&id=MEMORY_ID&query="LILT Create is a Generative AI tool."&n=100 ``` With that we would expect to see a response containing no more than 100 segments that fit the query criteria. ```json theme={null} [ { "source": "LILT Create is a Generative AI tool.", "target": "LILT Create ist ein generatives KI-Tool.", "score": 100, "metadata": "object" } ] ``` In this case, there was a single segment that fit the criteria with a score of 100. The score determines how close the system believes the query provided is close to what you are looking for. Anything less than 75 is automatically discarded. ## Note The query is a useful tool for verifying small things and ensuring certain phrases are in the right place. Feel free to explore the other Data Source End points in the [API Specification](/api-reference/memories). # API Rate Limits Source: https://support.lilt.com/developers/guides/rate-limits **Recent product change: API rate limits effective June 30, 2026** LILT is committed to delivering fast, reliable translation performance to every organization on our platform. To protect that shared experience and make sure no single workload can degrade service for others, **we've adding per-organization rate limits to our document pretranslation and file-translation APIs, beginning June 30, 2026**. These endpoints aren't changing; we've simply introduced fair-use limits so capacity stays balanced across all our customers. *Please note: All LILT Connectors are out of scope for these rate limits. These will only apply to the API.* *** # Overview Starting June 30, 2026, LILT is introducing per-organization rate limits on the following endpoints: * `POST /v2/documents/pretranslate` * `POST /v2/translate/file` * `POST /v2/documents/files` (only when the upload invokes MT - see exclusion note below) Two independent limits apply to every organization: | **Limit** | **Threshold** | | :------------------- | :------------------------------ | | Request rate | 300 requests per minute | | Character throughput | 2,500,000 characters per minute | Requests that exceed either limit receive an **HTTP 429 Too Many Requests** response. This guide explains how to read the 429 response headers and restructure your integration to stay comfortably within these thresholds. ### File uploads without Machine Translation (MT) are excluded `POST /v2/documents/files` uploads a file - it does not, by itself, run machine translation (MT). Uploads that don't invoke MT are not counted against the character-throughput limit: LILT evaluates each request's translation cost and a non-MT upload is measured as zero characters, so it draws down neither your throughput budget. Only calls that actually consume MT (`POST /v2/documents/pretranslate` and `POST /v2/translate/file`, plus a `/v2/documents/files` upload that triggers pretranslation) count toward the 2,500,000-characters-per-minute limit. You can upload source files freely; batch and pace the translation calls that follow. # Understanding the 429 Response When a request is rate-limited, LILT returns a 429 with three headers that tell you exactly when you can safely retry: | **Header** | **Meaning** | | :---------------------- | :----------------------------------------------------------------------------------- | | `X-RateLimit-Limit` | Your per-minute allowance (requests or characters, depending on which limit was hit) | | `X-RateLimit-Remaining` | Requests or characters still available in the current one-minute window | | `X-RateLimit-Reset` | Seconds until the current window resets and your full quota is restored | The two limits are **independent**. You can hit the character throughput ceiling without exhausting your request count, or vice versa. Check both headers when handling a 429. ## Example 429 response ```http theme={null} HTTP/1.1 429 Too Many Requests X-RateLimit-Limit: 300 X-RateLimit-Remaining: 0 X-RateLimit-Reset: 38 { "error": "rate_limit_exceeded", "message": "Request rate limit reached. Retry after 38 seconds." } ``` # Handling a 429: Retry with Back-Off The simplest fix for an occasional 429 is to wait for the window to reset before retrying. Do not tight-loop or immediately re-send. This wastes quota and keeps triggering 429s. ## Recommended retry pattern On receiving a 429: 1. Read the `X-RateLimit-Reset` value from the response headers. 2. Sleep for that many seconds (plus a small jitter to avoid synchronized retries across parallel workers). 3. Re-send the original request. ## Python example ```python theme={null} import time, random, requests def pretranslate(payload, headers): url = "https://api.lilt.com/v2/documents/pretranslate" for attempt in range(5): resp = requests.post(url, json=payload, headers=headers) if resp.status_code == 429: reset_in = int(resp.headers.get("X-RateLimit-Reset", 60)) jitter = random.uniform(0.5, 2.0) wait = reset_in + jitter print(f"Rate limited. Retrying in {wait:.1f}s (attempt {attempt+1}/5)") time.sleep(wait) continue resp.raise_for_status() return resp.json() raise RuntimeError("Exceeded retry limit") ``` ## Node.js example ```js theme={null} async function pretranslate(payload, headers) { const url = "https://api.lilt.com/v2/documents/pretranslate"; for (let attempt = 0; attempt < 5; attempt++) { const res = await fetch(url, { method: "POST", headers: { ...headers, 'Content-Type': 'application/json' }, body: JSON.stringify(payload), }); if (res.status === 429) { const resetIn = parseInt(res.headers.get("X-RateLimit-Reset") ?? "60", 10); const jitter = Math.random() * 1.5 + 0.5; const wait = (resetIn + jitter) * 1000; console.log(`Rate limited. Retrying in ${(wait/1000).toFixed(1)}s`); await new Promise(r => setTimeout(r, wait)); continue; } if (!res.ok) throw new Error(`HTTP ${res.status}`); return res.json(); } throw new Error("Exceeded retry limit"); } ``` # Batching Requests If your integration sends many small, individual translation calls in rapid succession, **batching** (combining multiple documents or files into fewer API calls) is the most effective way to stay well under the rate limits. ## What to batch | **Endpoint** | **Batching approach** | | :-------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `POST /v2/documents/pretranslate` | Pass an array of document IDs in a single request body | | `POST /v2/translate/file` | Batch by referencing multiple already-uploaded files in a single call. Pass their IDs via the fileId query parameter (e.g. ?fileId=1,2,3 or repeated ?fileId=1\&fileId=2). This does not accept multiple source files in the multipart body; the files must already exist (uploaded via the file-upload endpoint first). | **Character throughput tip** Batching reduces your request count, but each batch's characters still count toward the 2,500,000 character-per-minute throughput limit. If you're working with very large documents, spread batches across multiple windows rather than sending all characters at once. ## Sizing your batches There is no fixed rule for batch size — it depends on your document sizes and submission cadence. Use these guidelines as a starting point: * Keep each batch well under 2,500,000 characters to leave headroom for concurrent jobs from other parts of your organization. * If you are consistently close to the `X-RateLimit-Remaining` ceiling, reduce batch frequency or split large batches into smaller ones with a brief pause between them. * For burst workloads (e.g., end-of-sprint file exports), schedule submissions in staggered windows rather than all at once. ## Pretranslation: batching document IDs The `POST /v2/documents/pretranslate` endpoint accepts an array of document IDs. Instead of issuing one request per document, collect IDs and submit them together: ```python theme={null} # ✗ One request per document (inefficient) for doc_id in document_ids: requests.post('/v2/documents/pretranslate', json={'id': [doc_id]}, headers=headers) # ✓ All documents in a single request (efficient) requests.post( '/v2/documents/pretranslate', json={'id': document_ids}, # e.g. [1001, 1002, 1003, ...] headers=headers, ) ``` If you have hundreds of documents to pretranslate, split them into chunks and submit one chunk per window: ```python theme={null} import time, math, requests CHUNK_SIZE = 50 # documents per request WINDOW_SEC = 62 # slightly more than 60 s to be safe def batch_pretranslate(doc_ids, headers): chunks = [doc_ids[i:i+CHUNK_SIZE] for i in range(0, len(doc_ids), CHUNK_SIZE)] for i, chunk in enumerate(chunks): print(f'Submitting chunk {i+1}/{len(chunks)} ({len(chunk)} docs)') pretranslate({'id': chunk}, headers) # uses retry helper above if i < len(chunks) - 1: time.sleep(WINDOW_SEC) ``` ## File translation: Uploading and batching by reference The `POST /v2/documents/files` accepts one file per request. Additional files in a multipart body are silently ignored.  To translate many files, upload each one individually, then batch the downstream operation by passing the resulting IDs in a single call (e.g. an array of document IDs to `POST /v2/documents/pretranslate`, or multiple field query params to `POST /v2/translate/file`.) ```python theme={null} ▎ import requests ▎ ▎ def upload_files(file_paths, headers): ▎ """Upload files one at a time; return the list of created file IDs.""" ▎ file_ids = [] ▎ for path in file_paths: ▎ with open(path, 'rb') as fh: ▎ files = {'file': (path.split('/')[-1], fh, 'application/octet-stream')} ▎ resp = requests.post( ▎ 'https://api.lilt.com/v2/documents/files', ▎ files=files, ▎ headers=headers, ▎ ) ▎ resp.raise_for_status() ▎ file_ids.append(resp.json()['id']) # adjust to actual response field ▎ return file_ids ▎ ▎ def translate_files(file_ids, headers): ▎ """Batch-translate already-uploaded files in a single request by reference.""" ▎ resp = requests.post( ▎ 'https://api.lilt.com/v2/translate/file', ▎ params={'fileId': ','.join(str(i) for i in file_ids)}, ▎ headers=headers, ▎ ) ▎ resp.raise_for_status() ▎ return resp.json() ``` # Proactive Throttling Rather than reacting to 429s, you can read `X-RateLimit-Remaining` and `X-RateLimit-Reset` on every successful response and slow down before you hit the ceiling. ```python theme={null} def check_and_throttle(response, low_watermark=20): """Pause proactively when remaining quota is low.""" remaining = int(response.headers.get("X-RateLimit-Remaining", 999)) reset_in = int(response.headers.get("X-RateLimit-Reset", 0)) if remaining <= low_watermark and reset_in > 0: print(f'Quota low ({remaining} left). Pausing {reset_in}s.') time.sleep(reset_in + 1) ``` # Pre-Launch Checklist Before June 30, verify that your integration: * Sends arrays of document IDs to `/v2/documents/pretranslate` rather than one ID at a time and arrays of file IDs to `/v2/files/translation`. * Groups related files into a single `multipart/form-data` request where possible. * Handles HTTP 429 by sleeping for `X-RateLimit-Reset` seconds (plus jitter) before retrying. * Does not tight-loop on 429 responses. * Monitors `X-RateLimit-Remaining` and throttles proactively when quota is low. * Schedules large burst workloads across multiple one-minute windows. # Need More Headroom? The default thresholds are designed to sit well above typical usage patterns. If your workload genuinely requires higher limits, reply to the rate-limits notification email and the LILT team will work with you to find a configuration that fits your needs without impacting the shared platform. **Contact support** Reach out via your rate-limits notification email, or contact LILT support at [support.lilt.com](https://support.lilt.com). Please include your organization ID and a brief description of your workload volume when you get in touch. # AI Translation Source: https://support.lilt.com/developers/guides/translate-content/instant-translate In this walkthrough we will demonstrate how to use the LILT API AI Translation functionality. Instant translate is a powerful way to use LILT's Transformative AI to translate your content quickly and accurately without having to wait for a human to verify the results. Things you will need: * API Key - All requests through the LILT API use the API Key to authenticate. * File to Translate - We recommend a simple text file (txt) for a first attempt. * Memory ID - A LILT Data Source's memoryId to use with the translation - [Create one here!](/developers/guides/manage-content/create-a-datasource) ## File Upload Please refer to the [File Upload](/developers/guides/upload/file-upload) documentation to get a File ID. ## Translate File Now that you have a file saved in LILT, let's translate it! To run an AI translation for a single file you will need to use the [translate file endpoint](/api-reference/translate/translate-a-file). The end point below will translate your file, using the provided memoryId, fileId. File Translation is an Asynchronous process. ```powershell theme={null} curl -X POST 'https://api.lilt.com/v2/translate/file?key=API_KEY&fileId=123&memoryId=1234' ``` The response will be a status object that looks like this: ```json theme={null} { "id": 1, "fileId": "2,", "status": "InProgress", "createdAt": 1609357135 } ``` ## Monitor Translation Now that you have the translation id, you can call the [monitor endpoint](/api-reference/translate/monitor-file-translation) to get the current status of your translations. You can ask for status for any number of translations at a time, we recommend bundling these translationIds together. ```powershell theme={null} curl -X GET 'https://api.lilt.com/v2/translate/file?key=API_KEY&translationIds=1,2,3,4' ``` The response to the Monitor end point will look the same as the POST call you made earlier. The status might be different. Here are the statuses you can expect to see: * `InProgress` - The Translation has begun! * `Completed` - Translation is Complete but not yet ready for download. * `Failed` - The Translation was unsuccessful. 🙃 * `ReadyForDownload` - The Translation was Complete and is available for retrieval. ## Download Translated File Once you have the green light to download the translated file you can call the [download endpoint](/api-reference/translate/download-translated-file). This endpoint only allows for downloading one file at a time. ```powershell theme={null} curl -X GET 'https://api.lilt.com/v2/translate/files?key=API_KEY&id=1' ``` The response to this end point will be your content translated into whatever language you picked for the Data Source! ## Notes The end points described above have additional features, but we don't recommend them for most users. If you are curious, feel free to take a look at the [API Specification](/api-reference). # Verified Translation Source: https://support.lilt.com/developers/guides/translate-content/verified-translation Verified Translation has a human in the loop to ensure the highest translation quality. That means immediate turn around times will not be possible unlike with [Instant Translate](/developers/guides/translate-content/instant-translate). In this section we will discuss: * [Uploading Files](#uploading-files) * [Creating a Job](#creating-a-job) * [Monitoring Job Status](#monitoring-the-job-status) * [Downloading Translated Jobs](#downloading-translated-jobs) * [Archiving Downloaded Jobs](#archiving-downloaded-jobs) Things you will need: * API Key - All requests through the LILT API use the API Key to authenticate. * File to Translate - We recommend a simple text file (txt) for a first attempt. * Memory ID - A LILT Data Source's `memoryId` to use with the translation - [Create one here!](/developers/guides/manage-content/create-a-datasource) ## Submitting a New LILT Job A LILT Job encapsulates the various files that you want to translate. A Job is usually made up of multiple Projects. A Project is a grouping of Documents to be translated for an individual language pair (en->de - English to German). The LILT app has a useful wizard for creating Jobs that breaks all of these concepts down into a single package. In the next section you will learn how to create your first LILT Job. If you are curious about how these objects fit together, feel free to check out the API Reference: * [Jobs](/api-reference/jobs) * [Projects](/api-reference/projects) * [Documents](/api-reference/documents) * [Files](/api-reference/files) * [Languages](/api-reference/languages) ## Uploading Files The first step is to upload some files. For this example, a text (txt) file will be used as it is one of the simplest file types supported for verified translation. [See the API docs for more file upload options](/api-reference/files/upload-a-file). ```java theme={null} curl -X POST https://api.lilt.com/v2/files?key=API_KEY&name=testfile.txt \ --header "Content-Type: application/octet-stream" \ --data-binary @testfile.txt ``` The response will have an ID that relates to the File: ```javascript theme={null} { "id": {Your File Id here}, "name": "testfile.txt", "file_hash": "3858f62230ac3c915f300c664312c63f", "detected_lang": "en", "detected_lang_confidence": 0.7, "category": "API", "labels": [], "created_at": "2024-02-16T22:12:34.000Z", "updated_at": "2024-02-16T22:12:34.000Z" } ``` Hold onto the file IDs as you will need them in Step 2. If you lose them, you can always query the [Files API](/api#tag/Files/operation/getFiles) to see a list of your files. **Tip** Upload all of the files first before creating a Job with them. ## Creating a Job To create a Job you need at least one Data Source for the language you want to translate into. We will use the corresponding `memoryId` and the target language from that memory to specify a Language Pair, which can then be linked to the relevant Job. ### Basic Job Creation For now, let's create a Job for a single File and a single Language Pair. The request to create a Job will look like this. [See the API docs for more info](/api-reference/jobs/retrieve-all-jobs). ```bash theme={null} curl -X POST 'https://api.lilt.com/v2/jobs?key=API_KEY' \ --header 'Content-Type: application/json' \ --data-raw '{ "name": "test job", "fileIds": [1234], "due": "2024-02-05T10:56:44.985Z", "srcLang": "en", "srcLocale": "US", "languagePairs": [ { "memoryId": 3121, "trgLang": "de" } ] }' ``` ### Advanced Job Creation with Unified Fields You can also include additional fields to provide more context and metadata: ```swift theme={null} curl -X POST 'https://api.lilt.com/v2/jobs?key=API_KEY' \ --header 'Content-Type: application/json' \ --data-raw '{ "name": "Marketing Campaign Q1", "fileIds": [1234, 1235], "due": "2024-02-05T10:56:44.985Z", "srcLang": "en", "srcLocale": "US", "jobInstructions": "This is a marketing campaign for Q1. Please maintain brand voice and use approved terminology from the style guide.", "customProperties": { "purchaseOrder": "PO-2024-Q1-001", "department": "Marketing", "campaign": "Q1-Launch", "priority": "high" }, "enablePostProcessing": true, "languagePairs": [ { "memoryId": 3121, "trgLang": "de", "instructions": "Use formal German (Sie form) for B2B audience" }, { "memoryId": 3122, "trgLang": "fr", "instructions": "Use informal French (tu form) for consumer audience" } ] }' ``` **Field Descriptions:** * **`jobInstructions`** (optional): General instructions that apply to all projects in the job. Visible to all translators and reviewers. Max 5000 characters. * **`customProperties`** (optional): Key-value pairs for custom metadata. Useful for tracking purchase orders, departments, or other organizational data. * **`enablePostProcessing`** (optional): Boolean flag to enable additional post-processing steps after translation. * **`languagePairs[].instructions`** (optional): Language-specific instructions for each target language. Max 200 characters per language pair. That is all it takes to create a Verified Translation Job in LILT with full context and metadata. The Job has now been created and the LILT team will handle processing the verified translations. The Job will be marked as Delivered in LILT to indicate that the translations are ready for download. ## Monitoring the Job Status To determine which translations are ready for download query for jobs where `isDelivered=true` and `isArchived=false`. ```bash theme={null} curl -X GET https://api.lilt.com/v2/jobs?key=API_KEY&isDelivered=true&isArchived=false ``` [See the API Docs for more info](/api-reference/jobs/retrieve-all-jobs). ## Downloading Translated Jobs To download the completed translations, first initiate an export of the Job using the [export endpoint](/api-reference/jobs/export-a-job). This will set the `isProcessing` value to `1`. ```powershell theme={null} curl -X GET 'https://api.lilt.com/v2/jobs/{id}/export?key=API_KEY&type=files' ``` Check the status of the export by calling the [get job by ID endpoint](/api-reference/jobs/retrieve-a-job). When the export is complete, the `isProcessing` value will be set to `0` (or `-2` in the case of an export error). ```powershell theme={null} curl -X GET 'https://api.lilt.com/v2/jobs/{id}?key=API_KEY' ``` Once the export is complete the translations can be downloaded. The [download endpoint](/api-reference/jobs/download-a-job) will return a zip file containing all of the translations. ```powershell theme={null} curl -X GET 'https://api.lilt.com/v2/jobs/{id}/download?key=API_KEY' ``` ## Archiving Downloaded Jobs Call the [archive endpoint](/api-reference/jobs/archive-a-job) after successful download of the translations to indicate that the translations have been received. ```powershell theme={null} curl -X POST 'https://api.lilt.com/v2/jobs/{id}/archive?key=API_KEY' ``` That concludes this end-to-end guide for completing Verified Translation Jobs using the LILT API. # Cloud Upload API Documentation Source: https://support.lilt.com/developers/guides/upload/file-upload ## Overview The LILT Cloud Upload API provides secure file upload capabilities using S3-compatible presigned URLs. This system supports both single file uploads and multipart uploads for large files, enabling efficient and secure file transfers directly to cloud storage. ## Key Features * **Direct S3 Uploads**: Files are uploaded directly to S3-compatible storage, reducing server load * **Presigned URL Security**: Time-limited, secure URLs with no exposed credentials * **Multipart Upload Support**: Efficient handling of large files through chunked uploads * **Flexible Client Support**: Use any HTTP client library in your preferred programming language * **Managed Infrastructure**: LILT handles all bucket configuration, CORS setup, and storage management ## How It Works The upload process uses AWS S3-compatible presigned URLs for secure file transfers: 1. **Request Upload Parameters**: Call the Lilt API to get presigned URL and upload parameters 2. **Upload Directly to Storage**: Use the presigned URL to upload files directly to S3-compatible storage 3. **Complete Upload**: * For multipart uploads, notify the API when all parts are uploaded * Poll for antivirus scan completion to get the File ID which you can use for other endpoints (add to jobs or projects) ## API Endpoints ### 1. Initiate Single File Upload **Endpoint:** `POST /v2/upload/s3/params` or `GET /v2/upload/s3/params` Initiates a single file upload and returns presigned URL for direct upload to storage. #### Request Body ```json theme={null} { "filename": "document.pdf", "type": "application/pdf", "metadata": { "size": 1048576, "category": "SOURCE", "uuid": "123e4567-e89b-12d3-a456-426614174000" } } ``` #### Parameters | Field | Type | Required | Description | | ------------------- | ------- | -------- | ----------------------------------- | | `filename` | string | Yes | File name including extension | | `type` | string | Yes | MIME type of the file | | `metadata.size` | integer | No | File size in bytes | | `metadata.category` | string | No | File category (SOURCE or REFERENCE) | | `metadata.uuid` | string | No | Unique identifier for the file | #### Response ```json theme={null} { "url": "https://storage.example.com/bucket/path/file.pdf?AWSAccessKeyId=...", "method": "PUT", "filename": "text2.txt", "contentType": "text/plain", "metadata": { "size": 1048576, "category": "SOURCE", "uuid": "123e4567-e89b-12d3-a456-426614174000" }, "upload": { "createdAt": "2025-07-08T11:11:27.674Z", "updatedAt": "2025-07-08T11:11:27.674Z", "isDeleted": false, "deletedAt": null, "id": 362, "UserId": 10727, "OrganizationId": 682, "fileLocation": "gs://.../text2.txt", "status": "UPLOADING", "totalBytes": 333, "uploadedBytes": 0, "category": "SOURCE" } } ``` ### 2. Initiate Multipart Upload **Endpoint:** `POST /v2/upload/s3/multipart` Initiates a multipart upload for large files (recommended for files > 100MB). Make sure your part size is set to 8MB (8388608 bytes). #### Request Body ```json theme={null} { "filename": "large-file.zip", "type": "application/zip", "metadata": { "size": 104857600, "category": "SOURCE" } } ``` #### Response ```json theme={null} { "uploadId": "abc123def456", "key": "uploads/user123/large-file.zip", "upload": { "createdAt": "2025-07-08T11:11:27.674Z", "updatedAt": "2025-07-08T11:11:27.674Z", "isDeleted": false, "deletedAt": null, "id": 362, "UserId": 10727, "OrganizationId": 682, "fileLocation": "gs://.../text2.txt", "status": "UPLOADING", "totalBytes": 333, "uploadedBytes": 0, "category": "SOURCE" } } ``` The following parameters are optional and only relevant when uploading video content for translation: * `extractText`: When uploading a video file, set this parameter to `True` to ensure that text is extracted from the video (if needed). * `isSourceReviewRequired`: When uploading a video file, set this parameter to `True`to indicate that the source content should be reviewed before translation begins. ### 3. Get Upload Part URL **Endpoint:** `GET /v2/upload/s3/multipart/{uploadId}/{partNumber}` Retrieves a presigned URL for uploading a specific part of a multipart upload. #### Parameters | Parameter | Type | Required | Description | | ------------ | ------- | -------- | ------------------------------------------ | | `uploadId` | string | Yes | Multipart upload ID from initiate response | | `partNumber` | integer | Yes | Part number (1-based, 1-10000) | | `s3Key` | string | Yes | Upload key from initiate response | | `size` | integer | Yes | Size of the file | #### Example Request ```bash theme={null} GET /v2/upload/s3/multipart/abc123def456/1?s3Key=uploads/user123/large-file.zip&size=104857600 ``` #### Response ```json theme={null} { "url": "https://storage.example.com/bucket/path/file.zip?partNumber=1&uploadId=...", "method": "PUT" } ``` ### 4. Complete Multipart Upload **Endpoint:** `POST /v2/upload/s3/multipart/{uploadId}/complete` Completes a multipart upload by providing information about all uploaded parts. #### Parameters | Parameter | Type | Required | Description | | ---------- | ------ | -------- | --------------------------------- | | `uploadId` | string | Yes | Multipart upload ID | | `s3Key` | string | Yes | Upload key from initiate response | #### Request Body ```json theme={null} { "parts": [ { "ETag": "\"abc123def456\"", "PartNumber": 1 }, { "ETag": "\"def789ghi012\"", "PartNumber": 2 } ] } ``` #### Response ```json theme={null} { "success": true, "location": "https://storage.example.com/bucket/uploads/user123/large-file.zip" } ``` ### 5. Cancel Multipart Upload **Endpoint:** `DELETE /v2/upload/s3/multipart/{uploadId}` Cancels a multipart upload and cleans up any uploaded parts. #### Parameters | Parameter | Type | Required | Description | | ---------- | ------ | -------- | --------------------------------- | | `uploadId` | string | Yes | Multipart upload ID to cancel | | `s3Key` | string | Yes | Upload key from initiate response | #### Response ```json theme={null} { "success": true, "message": "Multipart upload cancelled successfully" } ``` ## Upload Workflows ### Simple Upload Flow ```text theme={null} 1. POST /v2/upload/s3/params → Get presigned URL and upload object 2. PUT to presigned URL → Upload file directly to S3 3. Poll GET /v2/upload/:uploadId for AV scan completion 4. File is ready for use when upload.status=SUCCESS and upload.FileId is a number ``` ### Multipart Upload Flow ```text theme={null} 1. POST /v2/upload/s3/multipart → Get upload ID and key 2. For each part: - GET /v2/upload/s3/multipart/{uploadId}/{partNumber} → Get part URL - PUT to part URL → Upload part to S3 - Save ETag from response 3. POST /v2/upload/s3/multipart/{uploadId}/complete → Complete upload 4. Poll GET /v2/upload/:uploadId for AV scan completion 5. File is ready for use when upload.status=SUCCESS and upload.FileId is a number ``` ## Implementation Examples ### Node.js Example ```javascript theme={null} const axios = require("axios"); const fs = require("fs"); // Initialize axios with base URL const api = axios.create({ baseURL: "https://api.lilt.com/v2", headers: { Authorization: "Bearer YOUR_API_KEY" } }); // Single file upload async function uploadFile(filePath, filename, contentType) { const fileBuffer = fs.readFileSync(filePath); // 1. Initiate upload const { data: uploadParams } = await api.post("/upload/s3/params", { filename, type: contentType, metadata: { size: fileBuffer.length } }); // 2. Upload to S3 using presigned URL await axios.put(uploadParams.url, fileBuffer, { headers: { "Content-Type": contentType, ...uploadParams.headers } }); console.log("Upload successful"); } // Multipart upload for large files async function uploadLargeFile(filePath, filename, contentType) { const fileBuffer = fs.readFileSync(filePath); const chunkSize = 8 * 1024 * 1024; // 8MB chunks // 1. Initiate multipart upload const { data: initResponse } = await api.post("/upload/s3/multipart", { filename, type: contentType, metadata: { size: fileBuffer.length } }); const { uploadId, key } = initResponse; const parts = []; // 2. Upload each part for (let i = 0; i < fileBuffer.length; i += chunkSize) { const partNumber = Math.floor(i / chunkSize) + 1; const chunk = fileBuffer.slice(i, i + chunkSize); // Get presigned URL for this part const { data: partParams } = await api.get( `/upload/s3/multipart/${uploadId}/${partNumber}`, { params: { s3Key: key, size: chunk.length } } ); // Upload part const response = await axios.put(partParams.url, chunk, { headers: { "Content-Type": contentType } }); parts.push({ ETag: response.headers.etag, PartNumber: partNumber }); } // 3. Complete multipart upload await api.post( `/upload/s3/multipart/${uploadId}/complete`, { parts }, { params: { s3Key: key } } ); console.log("Multipart upload successful"); } ``` ### Python Example ```python theme={null} import requests import os from typing import List, Dict class LiltUploadClient: def __init__(self, api_key: str, base_url: str = "https://api.lilt.com/v2"): self.api_key = api_key self.base_url = base_url self.headers = { 'Authorization': f'Bearer {api_key}', 'Content-Type': 'application/json' } def upload_file(self, file_path: str, filename: str, content_type: str): """Upload a single file""" with open(file_path, 'rb') as f: file_data = f.read() # 1. Initiate upload response = requests.post( f"{self.base_url}/upload/s3/params", json={ "filename": filename, "type": content_type, "metadata": { "size": len(file_data) } }, headers=self.headers ) response.raise_for_status() upload_params = response.json() # 2. Upload to S3 upload_headers = { 'Content-Type': content_type, **upload_params.get('headers', {}) } upload_response = requests.put( upload_params['url'], data=file_data, headers=upload_headers ) upload_response.raise_for_status() print("Upload successful") def upload_large_file(self, file_path: str, filename: str, content_type: str, chunk_size: int = 8 * 1024 * 1024): """Upload a large file using multipart upload""" file_size = os.path.getsize(file_path) # 1. Initiate multipart upload response = requests.post( f"{self.base_url}/upload/s3/multipart", json={ "filename": filename, "type": content_type, "metadata": { "size": file_size } }, headers=self.headers ) response.raise_for_status() init_response = response.json() upload_id = init_response['uploadId'] key = init_response['key'] parts = [] # 2. Upload each part with open(file_path, 'rb') as f: part_number = 1 while True: chunk = f.read(chunk_size) if not chunk: break # Get presigned URL for this part part_response = requests.get( f"{self.base_url}/upload/s3/multipart/{upload_id}/{part_number}", params={ 's3Key': key, 'size': len(chunk) }, headers=self.headers ) part_response.raise_for_status() part_params = part_response.json() # Upload part upload_response = requests.put( part_params['url'], data=chunk, headers={'Content-Type': content_type} ) upload_response.raise_for_status() parts.append({ 'ETag': upload_response.headers['etag'], 'PartNumber': part_number }) part_number += 1 # 3. Complete multipart upload complete_response = requests.post( f"{self.base_url}/upload/s3/multipart/{upload_id}/complete", json={'parts': parts}, params={'s3Key': key}, headers=self.headers ) complete_response.raise_for_status() print("Multipart upload successful") # Usage client = LiltUploadClient('your-api-key') client.upload_file('/path/to/file.pdf', 'document.pdf', 'application/pdf') ``` ### Java Example ```java theme={null} import java.io.*; import java.net.http.*; import java.util.*; import com.fasterxml.jackson.databind.ObjectMapper; public class LiltUploadClient { private final String apiKey; private final String baseUrl; private final HttpClient httpClient; private final ObjectMapper objectMapper; public LiltUploadClient(String apiKey, String baseUrl) { this.apiKey = apiKey; this.baseUrl = baseUrl != null ? baseUrl : "https://api.lilt.com/v2"; this.httpClient = HttpClient.newHttpClient(); this.objectMapper = new ObjectMapper(); } public void uploadFile(String filePath, String filename, String contentType) throws Exception { byte[] fileData = Files.readAllBytes(Paths.get(filePath)); // 1. Initiate upload Map uploadRequest = new HashMap<>(); uploadRequest.put("filename", filename); uploadRequest.put("type", contentType); Map metadata = new HashMap<>(); metadata.put("size", fileData.length); uploadRequest.put("metadata", metadata); HttpRequest request = HttpRequest.newBuilder() .uri(URI.create(baseUrl + "/upload/s3/params")) .header("Authorization", "Bearer " + apiKey) .header("Content-Type", "application/json") .POST(HttpRequest.BodyPublishers.ofString(objectMapper.writeValueAsString(uploadRequest))) .build(); HttpResponse response = httpClient.send(request, HttpResponse.BodyHandlers.ofString()); if (response.statusCode() != 200) { throw new RuntimeException("Failed to initiate upload: " + response.body()); } Map uploadParams = objectMapper.readValue(response.body(), Map.class); // 2. Upload to S3 HttpRequest.Builder uploadRequestBuilder = HttpRequest.newBuilder() .uri(URI.create((String) uploadParams.get("url"))) .header("Content-Type", contentType) .PUT(HttpRequest.BodyPublishers.ofByteArray(fileData)); // Add any additional headers Map headers = (Map) uploadParams.get("headers"); if (headers != null) { headers.forEach(uploadRequestBuilder::header); } HttpRequest uploadRequest = uploadRequestBuilder.build(); HttpResponse uploadResponse = httpClient.send(uploadRequest, HttpResponse.BodyHandlers.ofString()); if (uploadResponse.statusCode() != 200) { throw new RuntimeException("Failed to upload file: " + uploadResponse.body()); } System.out.println("Upload successful"); } public void uploadLargeFile(String filePath, String filename, String contentType) throws Exception { File file = new File(filePath); long fileSize = file.length(); int chunkSize = 8 * 1024 * 1024; // 8MB chunks // 1. Initiate multipart upload Map uploadRequest = new HashMap<>(); uploadRequest.put("filename", filename); uploadRequest.put("type", contentType); Map metadata = new HashMap<>(); metadata.put("size", fileSize); uploadRequest.put("metadata", metadata); HttpRequest request = HttpRequest.newBuilder() .uri(URI.create(baseUrl + "/upload/s3/multipart")) .header("Authorization", "Bearer " + apiKey) .header("Content-Type", "application/json") .POST(HttpRequest.BodyPublishers.ofString(objectMapper.writeValueAsString(uploadRequest))) .build(); HttpResponse response = httpClient.send(request, HttpResponse.BodyHandlers.ofString()); Map initResponse = objectMapper.readValue(response.body(), Map.class); String uploadId = (String) initResponse.get("uploadId"); String key = (String) initResponse.get("key"); List> parts = new ArrayList<>(); // 2. Upload each part try (FileInputStream fis = new FileInputStream(file)) { byte[] buffer = new byte[chunkSize]; int partNumber = 1; int bytesRead; while ((bytesRead = fis.read(buffer)) != -1) { byte[] chunk = bytesRead == chunkSize ? buffer : Arrays.copyOf(buffer, bytesRead); // Get presigned URL for this part String partUrl = String.format("%s/upload/s3/multipart/%s/%d?s3Key=%s&size=%d", baseUrl, uploadId, partNumber, key, chunk.length); HttpRequest partRequest = HttpRequest.newBuilder() .uri(URI.create(partUrl)) .header("Authorization", "Bearer " + apiKey) .GET() .build(); HttpResponse partResponse = httpClient.send(partRequest, HttpResponse.BodyHandlers.ofString()); Map partParams = objectMapper.readValue(partResponse.body(), Map.class); // Upload part HttpRequest uploadPartRequest = HttpRequest.newBuilder() .uri(URI.create((String) partParams.get("url"))) .header("Content-Type", contentType) .PUT(HttpRequest.BodyPublishers.ofByteArray(chunk)) .build(); HttpResponse uploadPartResponse = httpClient.send(uploadPartRequest, HttpResponse.BodyHandlers.ofString()); Map part = new HashMap<>(); part.put("ETag", uploadPartResponse.headers().firstValue("etag").orElse("")); part.put("PartNumber", partNumber); parts.add(part); partNumber++; } } // 3. Complete multipart upload Map completeRequest = new HashMap<>(); completeRequest.put("parts", parts); HttpRequest completeHttpRequest = HttpRequest.newBuilder() .uri(URI.create(String.format("%s/upload/s3/multipart/%s/complete?s3Key=%s", baseUrl, uploadId, key))) .header("Authorization", "Bearer " + apiKey) .header("Content-Type", "application/json") .POST(HttpRequest.BodyPublishers.ofString(objectMapper.writeValueAsString(completeRequest))) .build(); HttpResponse completeResponse = httpClient.send(completeHttpRequest, HttpResponse.BodyHandlers.ofString()); if (completeResponse.statusCode() != 200) { throw new RuntimeException("Failed to complete upload: " + completeResponse.body()); } System.out.println("Multipart upload successful"); } } // Usage LiltUploadClient client = new LiltUploadClient("your-api-key", null); client.uploadFile("/path/to/file.pdf", "document.pdf", "application/pdf"); ``` ## Best Practices ### File Size Recommendations * **Small files (\< 100MB)**: Use single file upload (`POST /upload/s3/params`) * **Large files (> 100MB)**: Use multipart upload (`POST /upload/s3/multipart`) * **Chunk size**: Use 8MB chunks for multipart uploads ### Error Handling Implement retry logic for network errors: ```javascript theme={null} async function uploadWithRetry(uploadFn, maxRetries = 3) { for (let i = 0; i < maxRetries; i++) { try { await uploadFn(); return; } catch (error) { if (i === maxRetries - 1) throw error; await new Promise(resolve => setTimeout(resolve, 1000 * Math.pow(2, i)) ); } } } ``` ### Security Considerations * Presigned URLs expire after a configurable time (typically 1 hour) * URLs are single-use for uploads * All uploads are validated against the original request parameters * HTTPS is required for all upload operations ## Common Error Responses ### 400 Bad Request ```json theme={null} { "error": { "message": "Invalid file type", "code": "INVALID_FILE_TYPE" } } ``` ### 413 Payload Too Large ```json theme={null} { "error": { "message": "File size exceeds maximum allowed size", "code": "FILE_TOO_LARGE", "details": { "maxSize": 104857600, "actualSize": 209715200 } } } ``` ### 403 Forbidden ```json theme={null} { "error": { "message": "Upload URL has expired", "code": "URL_EXPIRED" } } ``` ## Support For questions or issues with the Cloud Upload API, please contact [support@lilt.com](mailto:support@lilt.com) or refer to the main [API documentation](/api-reference). # Webhooks Source: https://support.lilt.com/developers/guides/webhooks Receive notifications when events occur in LILT Webhooks allow you to receive real-time notifications when specific events occur in LILT. When you configure a webhook, LILT sends an HTTP POST request to your specified URL whenever a subscribed event is triggered. ## Event Types You can subscribe to the following event types when [creating a webhook configuration](/api-reference/webhook-configuration/creates-a-new-webhook-configuration): | Event Type | Description | | ----------------------------- | ------------------------------------------------------------------- | | `JOB_UPDATE` | Triggered when a job is updated | | `JOB_DELIVER` | Triggered when a job is delivered | | `PROJECT_UPDATE` | Triggered when a project is updated | | `PROJECT_DELIVER` | Triggered when a project is delivered | | `INSTANT_TRANSLATE_COMPLETED` | Triggered when instant file translation task completes successfully | | `INSTANT_TRANSLATE_FAILED` | Triggered when instant file translation task fails | ## Payload Structure The payload sent to your webhook URL is a JSON object. The structure varies depending on the event type. Job and project event payloads do not include an explicit event type field, so you must infer the event type from the fields present in the payload. Instant translate event payloads include an `eventType` field. ### JOB\_UPDATE Sent when a job is updated. ```json theme={null} { "OrganizationId": 9, "due": "2025-03-28T10:32:31Z", "id": 895890, "isDelivered": 0, "name": "Marketing Brochure Q1 - English to German" } ``` | Field | Type | Description | | ---------------- | ------- | ------------------------------------- | | `OrganizationId` | integer | The ID of the organization | | `due` | string | The due date in ISO 8601 format | | `id` | integer | The job ID | | `isDelivered` | integer | Delivery status (`0` = not delivered) | | `name` | string | The job name | ### JOB\_DELIVER Sent when a job is delivered. ```json theme={null} { "OrganizationId": 9, "deliveredAt": "2025-03-24T08:10:55Z", "due": "2025-03-24T10:35:01Z", "id": 895892, "isDelivered": 1, "name": "Product Manual v2.0 - English to French" } ``` | Field | Type | Description | | ---------------- | ------- | ----------------------------------------- | | `OrganizationId` | integer | The ID of the organization | | `deliveredAt` | string | The delivery timestamp in ISO 8601 format | | `due` | string | The due date in ISO 8601 format | | `id` | integer | The job ID | | `isDelivered` | integer | Delivery status (`1` = delivered) | | `name` | string | The job name | ### PROJECT\_UPDATE Sent when a project is updated. ```json theme={null} { "OrganizationId": 9, "id": 37654, "name": "Website Localization - Spring Release", "due": "2025-03-20T13:47:09.000Z" } ``` | Field | Type | Description | | ---------------- | ------- | ------------------------------- | | `OrganizationId` | integer | The ID of the organization | | `id` | integer | The project ID | | `name` | string | The project name | | `due` | string | The due date in ISO 8601 format | ### PROJECT\_DELIVER Sent when a project is delivered. ```json theme={null} { "OrganizationId": 9, "id": 1376873 } ``` | Field | Type | Description | | ---------------- | ------- | -------------------------- | | `OrganizationId` | integer | The ID of the organization | | `id` | integer | The project ID | ### INSTANT\_TRANSLATE\_COMPLETED Sent when an instant file translation task completes successfully. ```json theme={null} { "eventType": "INSTANT_TRANSLATE_COMPLETED", "translationId": 1376873, "fileId": 68754 } ``` | Field | Type | Description | | --------------- | ------- | --------------------------- | | `eventType` | string | The type of event | | `translationId` | integer | Instant file translation ID | | `fileId` | integer | ID of the file translated | ### INSTANT\_TRANSLATE\_FAILED Sent when an instant file translation task fails. ```json theme={null} { "eventType": "INSTANT_TRANSLATE_FAILED", "translationId": 1376873, "fileId": 68754 } ``` | Field | Type | Description | | --------------- | ------- | --------------------------- | | `eventType` | string | The type of event | | `translationId` | integer | Instant file translation ID | | `fileId` | integer | ID of the file translated | ## Distinguishing Event Types Instant translate events include an `eventType` field in the payload. For job and project events, which do not include an explicit event type field, use the following logic to determine which event triggered the webhook: | If the payload contains... | Event Type | | ----------------------------------------------------- | ----------------- | | `isDelivered: 1` and `deliveredAt` | `JOB_DELIVER` | | `isDelivered: 0` and `name` (job name) | `JOB_UPDATE` | | `name` (project name) and `due`, but no `isDelivered` | `PROJECT_UPDATE` | | Only `OrganizationId` and `id` | `PROJECT_DELIVER` | If you need to handle multiple event types, consider subscribing to each event type with a separate webhook configuration pointing to distinct endpoints. This removes the need to infer the event type from the payload structure. # Introduction Source: https://support.lilt.com/developers/introduction Welcome to the LILT API Documentation and User Guide. If you are looking to: * Effortlessly [**Translate your content**](https://support.lilt.com/developers/guides/translate-content/instant-translate) across multiple languages, using AI and human in the loop translation. * Streamline content creation using [**Transformative AI**](/developers/guides/create-new-content) to create multilingual content directly in the language of your choice. * Connect your existing [**Content Management System**](/developers/guides/connect-systems-to-workflows) (CMS) to LILT with a connector. * [**Manage your multilingual content**](https://support.lilt.com/developers/guides/manage-content/create-a-datasource) using your current translation provider. You have come to the right place. *** This comprehensive API empowers developers and businesses of all sizes to unlock the full potential of their content through four key areas of functionality: 1. **Translate Content:** Fundamentally, this API will enable you to translate content. LILT enables you with AI powered models that learn using the data you provide and improve with each iteration. Whether you decide to use [AI Translation](https://support.lilt.com/developers/guides/translate-content/instant-translate) or [Verified Translation](https://support.lilt.com/developers/guides/translate-content/verified-translation) is up to you and your business. 2. [**Create:**](/developers/guides/create-new-content) Open AI's ChatGPT took the world by surprise in 2023 by changing how we think about words online. At LILT we took that a step further to create new content for your organization in the desired language and locale. 3. [**Connect:**](/developers/guides/connect-systems-to-workflows) At LILT we have built many ways to access and connect with your content. One such way is through our Connectors framework. This framework enables you to connect directly from a CMS of your choice to provide content for translation, which will automatically be routed back to your organization's CMS. 4. [**Manage:**](/developers/guides/manage-content/create-a-datasource) Content on the internet comes in many formats and can be hard to manage. LILT makes it easy by providing the ability to connect directly to the tools you already use for your translation services, whether it might be Google Translate, DeepL, or Amazon Translate. We have ways to enable workflows with these providers directly within LILT. *** Ready to take the first step? * [Try out the Quick Start Guide](/developers/quickstart) - A quick description of how to authenticate and make your first API request with LILT. * [Explore the API Reference](/api-reference) - Dive into the details of each endpoint, parameter, and available functionality. # Quickstart Source: https://support.lilt.com/developers/quickstart Let's talk about how to make your first API call using LILT's API. This should take about 5 minutes and by the end you will know all of the available languages that LILT can localize your content into. ## What you need to start: First you will need to retrieve your Organization's API Key from the LILT User Interface. Log in to the LILT platform as an Administrator, and select Manage from the sidebar. Select API keys. Image Create a new API key, or use an existing one. More information on how to use this is available [here](https://support.lilt.com/kb/organization-settings#api). Then, copy the API Key into your favorite API Platform like Postman, Datadog, etc... Image Congratulations, now you have everything you need to make your first Api call to LILT. ## Making your first API Call! As a first step at LILT, you should examine the languages available for Language Translation. To do this we will access our [languages](/api-reference/languages/retrieve-supported-languages) end point. This end point is a good starting point as all you have to think about is authenticating. To authenticate for the public LILT endpoint all you need is the LILT provided API Key from earlier. ```bash theme={null} curl https://api.lilt.com/v2/languages?key={Your API Key here} ``` Then you should see a response that looks something like this: ```json theme={null} { "source_to_target": { "en": {}, "...": "..." }, "code_to_name": { "aa": "Afar", "ab": "Abkhazian", "af": "Afrikaans", "...": "..." } } ``` Congratulations on making your first API call with LILT! # Product Overview Source: https://support.lilt.com/documentation/lilt-converse/product-overview ## LILT Converse: Product Overview & User Guide LILT Converse is a hardware and software package designed to provide instant, offline language support. While standard translation and localization cover text-to-text needs, Converse handles speech-to-speech interaction, functioning as a "real-time speech translation" or "AI interpretation" tool. ## **Key Capabilities** * **AI Real-Time Translation:** Converse provides secure, real-time speech translation between English and a variety of other languages. * **Offline Functionality:** Converse operates completely offline — without Wi-Fi or cellular — ensuring maximum security for sensitive communications or for work in remote areas. * **Integrated Hardware and Software:** Converse's mobile-native AI is built with integrated hardware and software for a seamless user experience, anywhere where translation is needed. ### **Hardware Specifications** LILT Converse is a hardware + software package. * **Hardware:** Converse is currently available for Android Tablets. The Samsung S11 is recommended. * **Configuration:** Hardware is pre-configured by LILT to meet specific customer requirements before delivery, including the option to load adapted translation models created through the LILT platform. * **Optional Microphone Support:** While the device has built-in audio, compatible plug-in microphones are recommended for better background noise management. ### **Supported Languages** Converse supports translation between English and the following languages: * Spanish * French * German * Portuguese * Italian * Dutch * Arabic (optimized for Modern Standard, Gulf, and Egyptian dialects) * Chinese (Mandarin), with support for Simplified and Traditional script * Korean * Japanese * Vietnamese * Ukrainian * Russian # User Guide Source: https://support.lilt.com/documentation/lilt-converse/user-guide ## The Conversation Screen Upon opening the app, the homepage is the Conversation screen. This screen is the user interface for real-time translations. ### **Interface** The Conversation screen is a split view, where one side faces Speaker 1 (the primary user) and the other side faces Speaker 2. * The **Speaker 1** side is always set to English. When the app launches, the Speaker 1 side displays the text "Press button to speak" in English above the microphone button; the other side will display the equivalent instruction in the target language. The Speaker 1 side also displays the buttons for clearing the conversation and accessing the Settings menu. * The **Speaker 2** side can be set to any available language other than English using the Settings menu. ### Having a Conversation * **Device Positioning:** Set the device on a flat surface or hold it between yourself and the person you are speaking to. In the basic setup, the person you're speaking to should easily be able to read the Speaker 2 side of the split screen and access the microphone button there. * **Tap to Speak:** Either speaker can begin by tapping the microphone button on their side of the screen. When their microphone button is activated, the button will turn green. As they speak, the device will display a transcript of their speech on their side of the screen and the translation of their speech on the other side. * **Taking Turns:** * While a speaker is speaking, their microphone button will be turned on. * The speaker can end their turn by tapping their microphone button to turn it off, indicated by the button going from green to gray. * Alternatively, the other speaker can tap their button at any time to begin their turn. This will automatically end the other speaker's turn, if it's still active. * **Text-to-Speech:** Converse will produce text-to-speech (TTS) audio for the target language, reading aloud the translation of Speaker 1's speech. There is no TTS in the reverse direction; i.e., translations into English will not be read aloud. * This functionality allows for Converse to be used in situations where Speaker 2 cannot or should not have physical access to the device. In this scenario, Speaker 1 can manage both microphone buttons, and Speaker 2 will simply hear the translations spoken aloud. * **Clearing the Conversation:** To clear the Conversation screen, tap the clear button (the circular arrow) in the lower left of the Conversation screen. * **Managing Background Noise:** Using Converse in noisy audio environments may degrade the quality of the transcription and translation. If this seems to be an issue, move to a location with less background noise or consider using a plug-in microphone to improve audio quality. Using LILT Converse ## Settings To open Settings, tap the Settings icon (the gear) in the lower right of Speaker 1's screen. Converse Settings ### Select Language The Select Language menu allows you to select Speaker 2's language. Please note that it may take up to 30 seconds for a new model to load after selection. Selecting a new language will automatically return you to the Conversation screen. ### Conversation Settings The Conversation Settings cover saving conversations, profanity censoring, and external display settings. ### **Saving Conversations** LILT Converse allows you to export transcripts and audio recordings of your conversations. * **Configuring Storage** * In order to save conversations or audio, an external storage device must be plugged into the USB-C port of the device while the conversation is taking place. * When plugging in a storage device for the first time while running Converse, a popup will guide you through selecting the desired folder for storage. * If the storage device is removed while the settings for transcript or audio storage are turned on, Converse will display a warning prompting you to check your external storage before proceeding. * **Save Conversations** * Toggle this setting **on** to store conversation transcripts on your external storage device. * Transcripts are stored as `.txt` files in the location selected during storage configuration. The transcripts will contain timestamps for each speaker turn with the transcript and translation of what was said during each turn. * Conversations are stored by **app session**. For example, if one conversation takes place, then the Conversation screen is cleared and a separate conversation takes place without closing the app in between, both conversations will be stored in one transcript file. * **Save Background Audio** * Toggle this setting **on** to store conversation audio files on your external storage device. * Audio is stored as `.wav` files in the location selected during storage configuration. * Audio is stored by **app session**. For example, if one conversation takes place, then the Conversation screen is cleared and a separate conversation takes place without closing the app in between, both conversations will be stored in one audio file. * **Encrypt Saved Conversations** * This setting allows you to set a password on exported transcript and audio files. ### **Censor Profanity** Toggle this setting **on** to censor common profanity words in all languages. * Note that profanity censoring may be imperfect, as profanities vary widely in different dialects and the definition of profanity is subjective. This feature covers commonly recognized profanity words. * On the Conversation screen, censored words will be replaced in the transcripts with a series of asterisks ("\*\*\*\*\*\*"). In the translated text, the equivalent word will either be censored in the same way or will be expressed in non-profane terms, depending on the context. * In Saved Conversation transcripts, profanity will be censored in the same way as on the Conversation screen. * In Saved Audio files, profanity will not be censored. ### **External Display Settings** Converse can be used to display live subtitles onto an external display. The displayed text can either be a transcription of the input speech or a live written translation of the speech. * **External Display Shows:** This can be toggled between *Transcription* and *Translation* * **External Display Chroma Key:** This optimizes the output for "green screen" setups. It allows the translation or transcription text to be cleanly overlaid onto a broadcast or video system. * **External Display Logo:** This is a simple toggle to show or hide the Converse logo on the external output. It’s primarily used for demos or when a customer wants branded attribution. ### Performance Notes * **Accuracy Disclaimer:** LILT Converse can make mistakes. It is not suitable for conversations requiring 100% accuracy. * **Context Sensitivity:** Converse's AI performs better with more context. Very short conversational passages may exhibit lower performance compared to longer exchanges, where LLMs can better utilize predictive context. * **Domain Adaptation:** By default, Converse uses general-purpose models that may lack domain-specific expertise. Specialized domain models can be developed by request. Customers of the LILT platform who already have adapted models can request to have those models loaded into Converse. # 2024 Q4 Release Notes Source: https://support.lilt.com/kb/2024-q4-release-what-s-new-in-the-lilt-platform ## What's New In The Platform ## **On-Prem Features and Security Updates** ### **LILT Translate** #### **Improved Tag Projection** We are excited to announce updates to our tag projection functionality, which improves the overall quality of tag projection and allows linguists to spend less time on adjustment. Previously, tags were projected by computing a word alignment on the tag-stripped source/target using a variant of our V1 models, then used a rule-based approach to transfer tags based on word alignments. With this new update, tags are projected using a single, multilingual projection model that directly generates the target sentence with tags, without the detour through word alignment. [***For more information on our Research Team's work on tag projection, see this article.***](https://aclanthology.org/2021.findings-emnlp.299.pdf) #### **Domains** LILT’s new **Domains** feature enhances workflow segmentation, allowing organizations to create distinct operational areas within LILT. By assigning resources such as users, models, and preferences to specific domains, administrators can customize experiences to improve productivity, focus, and data privacy for each user group. **What’s New?** 1. **Customizable Domains** * Domains allow administrators to segment LILT by operational areas, facilitating tailored experiences across teams or departments. 2. **Enhanced User Personalization** * Users can switch between assigned domains, with interfaces updating to reflect models, file loaders, and translation jobs associated with the active domain. 3. **Advanced Administrative Control** * Administrators can set up, manage, and delete domains, assigning specific resources such as users, models, and preferences. * Default languages, workflows, and file loaders can be specified per domain. 4. **Domain-Specific Analytics and Job Filtering** * Analytics and job management views are filtered based on the active domain, making it easier for users and admins to manage tasks and track progress relevant to their domain. #### **Assign Domains as Secondary Reviewers** We are excited to announce updated assignment functionality where project opportunities can be presented to multiple Secondary Reviewers. With this update, Secondary Reviewers identify which languages they support in their profile, and are then assigned to domains. We can then assign a domain as a Secondary Reviewer, which would share the opportunity with all those qualified and Secondary Reviewers can accept projects based on their availability. For more information, please visit [/kb/customer-review#SecondaryReview-SecondaryReviewerassignmentsthroughdomains](/kb/customer-review#SecondaryReview-SecondaryReviewerassignmentsthroughdomains). *Please note: This feature is in beta and will be available for all orgs in early November. If you would like to use this feature before then, please reach out to your Account Team to learn more.* #### **Additional Data in Concordance search and Data Source Download** Concordance searches now display additional data: Creation date, Updated date, Created by (name/email), Updated by (name/email), and the file name from which it was created. This allows users to understand who accepted and confirmed segments into their data sources. Only those with the User Visibility permission set are allowed to see the names and emails of those who created or updated the entry. This data is now also available for managers and admins in the Data Source download. #### **Recently Used Language Options** We are excited to introduce a feature improvement to our language dropdown menu that shows customers their most recently used languages when submitting projects for translation. Previously, customers needed to search for languages every time they went to submit new projects. With this update, their recently used languages are more accessible. #### **Project-Level Setting for Copy/Paste** LILT Translate now has a project-level setting to define the usage of Copy/Paste. All new projects inherit the organization setting by default, but can be adjusted at the project level. To learn more about the Copy/Paste setting, please visit the [Organization Settings page](/kb/organization-settings). #### **V3 Model Release for PT > EN** We are excited to introduce an improved and larger Translation and Adaptation V3 model for Portuguese (PT) > English (EN). We will be releasing additional V3 models. Please visit our [Supported Languages](/kb/v2-language-models) page for more information on our available languages and models. #### **New Keyboard Shortcut** We released a new keyboard shortcut that will insert the top TM entry from the CAT sidebar into the segment editor. Use Ctrl + Shift + S to insert. #### **Setting to Automatically Run Quality Assurance Tools** We released a new sub-setting for Mandatory Quality Assurance Tools that would automatically run Quality Assurance Tools. When this is enabled, Quality Assurance Tools will run immediately after the selected workflow step is completed. For more information, please visit the [Mandatory Quality Assurance Tools KB page](/kb/mandatory-batch-qa-check). #### **Updated Default Roles - Customer, and Customer + LILT Create** To better reflect the needs of our platform customers, we’ve updated LILT’s default roles so there are two customer roles - Customer, and Customer + LILT Create. This differentiates which users have LILT Create permissions. Both of these roles also had the “User visibility” permission revoked so as to not reveal sensitive information. For more details, please reference [/kb/default-roles](/kb/default-roles). #### **Customer Review is now Secondary Review** We’ve updated our product verbiage to better reflect our customers' workflows, and we’ve renamed the Customer Review stage to Secondary Review. #### **Overwrite Confirmed Segments for Secondary Review** Forward and backward overwrite confirmed segments is now available in the Secondary Review stage. These are enabled by default, as they are for existing workflow stages. #### **Keyboard Shortcut to Insert Top TM Entry** Linguists and customers now have a keyboard shortcut to insert (copy & paste) the top TM entry from the CAT sidebar into the CAT editor - “Ctrl + Shift + S”. #### **Reordered Segment Context Panel** The segment context panel has been reorganized to reflect the importance of information during translation. The blocks now display TM results, Termbase results, and MT results. #### **Word Count in Linguist Assignment Emails** We have added data to linguist assignment emails to provide further details. Translation assignment emails now include the number of Exact Match words across the project. Review assignment emails now include the number of Repetitions & Exact Match words across the project. #### **Additional Language Models** We are happy to announce the expansion of our capability to deliver high quality output translations. Learn more about our [supported languages](/kb/v2-language-models) updates. #### **Block Copy and Paste Functionality** LILT Translate now supports blocking any usage of copy and paste. This will prevent all copy and pasting within source and target text, and can be applied through the org settings page. For more information, please visit the [Organization Settings page](/kb/organization-settings). ### **LILT Manage** #### **Edit Model Names** You can now edit the names of your model based on your preferred naming conventions for your teams. #### **New LLM Support** We’ve grown the number of models we support in LILT. To access them, these models need to be provided by you in order to leverage them. **New LLM Services for LILT Create** OpenAI * GPT-4o * GPT-4o-mini Anthropic * Claude 3.5 Sonnet * Claude 3 Haiku * Claude 3 Sonnet * Claude 3 Opus AI21 Labs * Jamba-Instruct * Jurassic-2 Ultra * Jurassic-2 Mid Google * Gemini 1.0 Ultra * Gemini 1.5 Pro * Gemini 1.0 Pro * Gemini 1.0 Nano * Gemini 1.5 Flash * PaLM 2 **New LLM Services for LILT Translate** * GPT-4 * GPT-4o * GPT-4o-mini #### Data Labeling LILT announced the release of our Data Labeling feature at our Winter AI Day. This feature is an AI-optimized and human reinforced solution to build high-quality, reliable, and multilingual training data sets used to train foundational Large Language Models. We designed this feature for the world’s leading Generative AI companies, and we are working with those companies to train their foundational LLMs. LILT Label can help: * \*\*Expand your data pool \*\*- Training LLMs on non-English languages helps avoid biases and apply cultural nuances in a secure environment. * **Ensure data quality**, because our responses are sourced from native-speaking, domain experts to ensure accuracy and quality. * **Accelerate the labeling process**, with dedicated interfaces to intuitively build and annotate data. To learn more, check out our announcement at our Winter AI Day: [https://resources.lilt.com/ai-day-winter24-ty](https://resources.lilt.com/ai-day-winter24-ty) ## **Security and Stability Improvements** We fixed 90+ issues related to security and stability so that our customers would have a more delightful experience. 1. **Translation Consistency & Performance Enhancements** * We've improved the handling of batch updates and resolved translation inconsistencies, ensuring greater accuracy in translation quality. * Addressed timeout and performance issues in AI Review and Instant Translate features. 2. **User Experience & Interface Enhancements** * Enhanced the UI across multiple areas, ensuring consistency with our design system. Notable fixes include copy/paste functionality, action button alignment, and improved handling of notifications and tooltips. * Updated the Create page and other components for a cleaner, more intuitive interface. 3. **Connector & Integration Updates** * Added Box to our Connector Builder for seamless integration. * Fixed encoding issues in XTM custom MT integration * Improved Contentful workflow, including publishing and translation warnings. 4. **Domains & Permissions** * Improved user access and permission handling in Domains, with fixes for non-Admin behavior and verification processes. 5. **Job & Document Management Improvements** * Enhanced document handling, ensuring large batch jobs and project details load efficiently and correctly. 6. **Technical & Performance Fixes** * Addressed load performance issues, specifically for Figma projects and the Linguist Homepage. * Removed outdated dependencies to improve system reliability and responsiveness. We continue to prioritize your feedback and are committed to delivering a better experience with every update. Thank you for your continued support and insights! ## **Included Patch Updates** * **User Creation:** Fixed admin-client create-user command * **Logging Issues:** Fixed logging issue on front-end due to production log obfuscation * **Services Errors:** Fixed bug causing various services to occasionally throw a 500 Internal Server Error (Data sources, instant translate, job creation) * **Document Deletion with Comments:** Fixed an issue when documents would not be deleted when segments had comments * **Untranslated Segments**: Fixed the issue when untranslated segments would not appear in the target file if they are within the same paragraph as a translated/confirmed segment. * **Inconsistent Letter Case in Data Sources:** Fixed the issue of inconsistent letter cases in the custom properties of a data source. ## **Cloud-only Features** ### **LILT Translate** #### **Linguist Stats Data Refresh** Linguists now have visibility into when the data in Linguist stats was last refreshed, to provide visibility into how recent the data is. ### **LILT Manage** #### **LILT Financial File Download** We are excited to introduce a new feature that allows you to download your monthly financial report directly from the LILT platform. This report will help you easily track your localization spending and stay on top of your financials. * **Format:** The report is available in Excel format. * **Availability:** You can download the report every month. And this is available on a per-customer basis - please contact LILT sales with any questions regarding access. This enhancement is designed to provide you with greater transparency and control over your localization budget. ### **LILT Create** #### Instant Video Dubbing We are excited to announce Instant Video dubbing, where you can pair your existing custom models with text-to-speech and voice selection capabilities to receive a dubbed video in a new language within seconds. This offering allows you to consolidate your workflows into one easy-to-use product, expand your audience reach, and maintain brand accuracy by using your fine-tuned models. Interested in learning more? Check out our announcement at our Winter AI Day: [https://resources.lilt.com/ai-day-winter24-ty](https://resources.lilt.com/ai-day-winter24-ty) ### **LILT Connect** #### **Box App Center Integration** We're excited to announce that LILT is now available on the Box App Center, making it easier than ever to integrate your translation workflow directly with Box. With this integration, you can seamlessly manage and translate content stored in Box, streamlining localization processes for global teams. Try it today and experience efficient, high-quality translations right from your Box environment. #### **Contentful x LILT Connector Updates:** **Support for Rich Text Embedding** We are introducing a new feature for the Contentful x LILT connector to better support embedded entries within Rich Text fields. With this update, the connector will automatically recognize and include embedded entries in the translation process, just like linked entries. This enhancement will eliminate the need for manual intervention, ensuring a smoother and more efficient localization workflow for content that includes embedded assets. **Default Locale** We are working on an update to address issues with the Contentful x LILT connector for customers using a default locale other than **en-US**. Currently, when a customer’s default locale is set to a different variant, such as **en**, the connector does not operate as expected. While a force extract is possible, it does not allow for content to be sent organically using this source language, and the workflow statuses in Contentful are not updated properly. This update will ensure the connector can seamlessly handle non-**en-US** default locales, allowing for efficient content management and status updates, even at scale with multiple stakeholders involved. **Auto-Publish Upon Delivery** We are introducing a new feature in the Contentful x LILT connector that allows content to be automatically published upon delivery from LILT to Contentful. With this option, once translations are completed and delivered back into Contentful, the content can be immediately published without requiring manual intervention. This streamlines the content publishing process, saving time and ensuring quicker go-to-market for localized content. #### **LILT x Shopify Connector Updates:** * **Shopify - Feature to Select Only Active Products** * Added an option to filter and select only active products within the Shopify connector. This improvement enhances the user experience by allowing more granular control over product selection during the translation process. * **LILT Shopify App Not Showing Metaobjects** * Fixed a bug where metaobjects were not being displayed in the True Classic LILT Shopify App. This correction ensures that all relevant data is visible to users, improving the user experience. * **Adjust All Products Filtering** * Enhanced the product filtering capabilities to provide more comprehensive options within the Shopify connector. The improvements include: * **Product Count:** Added a count of available products within each section for better visibility and management. * **Filter Updates:** Changed the filter label from "All Active Products" to "All Products" to reflect the inclusion of all product statuses. * **Selection Options:** Introduced new filtering options, allowing users to select between "All Active," "All Archived," and "All Draft" products, offering more granular control over product data management. * **Shopify Connector Import Issues** * Addressed urgent issues related to product import functionality within the Shopify Connector. This critical fix resolves import errors that were affecting data synchronization. * **Shopify Connector - Export Products by Tag** * Added a new feature to export products based on tags in the Shopify Connector. This functionality enables more targeted data exports, enhancing the ability to manage and utilize product data. #### **LILT x S3 Connector Updates** * **Duplicate Projects Created During Connector Job** * Fixed an issue where duplicate projects were being created during connector jobs. This correction ensures that only a single project is generated per job, preventing redundancy and reducing confusion in project management. * **Expand S3 to Select Source Based on a Directory Path** * Enhanced the S3 storage-based connector to allow users to select the source based on a specific directory path. This update provides greater flexibility in defining the source data, making it easier to manage large datasets within S3. * **Add Ability to Create/Set a File-Level Metadata Field When Returning Target Files** * Introduced the ability to create or set metadata fields at the file level when returning target files. This enhancement allows users to attach custom metadata to files, enabling better organization and retrieval of data within S3. * **Allow the S3 connector to Use a Different Bucket for Outputs** * Updated the rclone-based S3 connector to support using a different bucket for output files. This feature provides more control over where processed data is stored, improving flexibility in managing output destinations. # LILT 5.1 Release Notes Source: https://support.lilt.com/kb/2025-q1-lilt-5-1-0-release-notes 2025 Q1 Release ## **On-Prem Features and Security Updates** ### **LILT Translate** #### **Introducing LILT AI Review Agent: Achieve Unprecedented Translation Accuracy & Speed!** LILT AI Review Agent is a groundbreaking automated editor that acts as an intelligent, independent layer of quality assurance for both AI and human translations. By proactively identifying and correcting errors, it dramatically improves accuracy and streamlines your review process. Say goodbye to review bottlenecks and hello to near-perfect translations, faster than ever before. This innovative feature reduces review time by automating corrections, delivers highly accurate translations with minimal human input, minimizes inconsistencies in manual reviews, speeds up the entire localization lifecycle, and leverages a separate AI model for unbiased quality checks. **Resources** * [AI Review Article](/kb/ai-review) ### **Organization-Level QA Configuration: Tailored Quality Assurance for Your Enterprise** *Tracker items number 26 and 59* Implement custom QA configurations at the organization level, applying language-specific quality checks across your entire workflow. This empowers you to achieve higher quality translations by catching more errors with language-specific QA rules. You'll have more control, easily managing QA configurations as an administrator, and benefit from customizable access, ensuring the right people handle QA files with granular permissions. Ultimately, this leads to streamlined workflows and valuable time savings. **Resources** * [Custom QA Setup](/kb/custom-qa) ### **Domain-Level Reviewer Error Logging Customization: Enhanced Control and Flexibility** Set domain-level preferences for reviewer error logging. This allows for workflow automation, automatically applying settings per domain, and provides greater control, optimizing settings based on specific business needs. ### **Project Instructions: Direct Communication for Faster Turnarounds** Add project-specific instructions directly in the job submission portal. This leads to a streamlined workflow, reducing back-and-forth communication, and faster turnaround, providing instructions directly to linguists. You'll also gain greater control, ensuring accurate project execution with upfront details. ### **Instant Translate Homepage** We launched a new AI translation workflow designed for specialized organizations, providing fast and secure AI translations without requiring full platform access for individual linguists. **Resources** * [Instant Translate Homepage](/kb/instant-translate-homepage) ### **LILT V3 models now available!** Our latest purpose-built AI model builds on our V2 model in a few critical ways: * Expanded V3 parameters by 5X (compared to V2) * Improved ability to gather broader context for more informed translation choices * Trained model on a novel Reinforced Learning from Human Feedback (RLHF) concept (EXTERNAL LINK:[*see published paper*](https://arxiv.org/abs/2409.17673)) - so translations sound more natural * Significantly improved quality and efficiency outputs * Added additional language pairs Read more about [supported language pairs](/kb/v2-language-models). ## **Email alerts in Japanese now available** Email alerts are now translated to Japanese for all profiles set to Japanese. This is available to all on-prem customers. ### **Added CVEs and STIGs** We’ve implemented security CVEs and Security Technical Implementation Guides (STIGs) for onboarding. ### **Domains in API and Connectors: Streamlined Workflows and Accurate Billing** Assign Domains to jobs submitted via API and Connectors for improved workflow alignment and reporting. This allows for workflow automation, automatically applying correct settings for each job. You'll also experience improved tracking and reporting with Domain-specific analytics, seamless integration, ensuring CMS Connector jobs follow customer preferences, and accurate billing, tagging Domains for precise cost allocation. **Resources** * [Domains Knowledge Base Article](/kb/user-domains-documentation) ## **Cloud-only Features** ### **LILT Translate** #### **Revamped LILT AEM Connector: Seamlessly Integrate Translation into Your Content Workflow!** The newly redesigned LILT AEM Connector offers a powerful and intuitive integration of LILT's translation capabilities directly within your Adobe Experience Manager environment. Eliminate cumbersome manual content transfers and unlock a streamlined localization process. This enhanced connector provides greater configurability to adapt to your unique and complex translation needs, empowering marketing teams to translate website and other content faster, maintain consistent brand messaging, and accelerate time-to-market. This integration works directly within AEM, preserving content formatting and crucial context, eliminates manual steps for significant efficiency gains, and easily handles high volumes of content updates with minimal manual effort. ### **Enterprise-Grade SSO and MFA: Enhanced Security and Simplified Access** We now offer enterprise-grade Single Sign-On (SSO) and Multi-Factor Authentication (MFA) integrations. This results in simplified enterprise access, streamlining logins for large organizations. You'll also benefit from enhanced security with robust multi-factor authentication, and efficient user management through automated provisioning and control. ### **Support for Drupal v11 and other API enhancements!** LILT now supports Drupal v11, allowing users on this version to access LILT’s full suite of products and services right within Drupal. We've also automated backend notifications within the Drupal Connector further boosting efficiency of translations sent through this Connector. ### **New Contentstack features supported via the LILT Connector** Additional Contentstack features are now supported when pushing translations through the Contentstack LILT Connector. Newly supported features include: nested entries, filter search, select all and publish upon delivery. Now users can continue working within Contentstack and push translations to LILT without ever leaving the Contentstack CMS. ### **Job notifications now available via Connector** Receive automatic notifications on key updates such as changes to documents and job progress right within your business systems. These “webhook style notifications” can be implemented with any of LILT’s 60+ Connectors, so users never have to leave their content management or business systems in order to track status updates. # LILT 5.2 Release Notes Source: https://support.lilt.com/kb/2025Q2ReleaseNotes 2025 Q2-Q3 Release # **On-Prem Features and Security Updates** ### **Structured PDF Translations** You can now upload a text-based PDF directly to Lilt and get a translated PDF back while retaining original formatting for both Instant and Verified Translation jobs. LILT’s new PDF translation feature automatically extracts the text, translates it, and reconstructs the document, ensuring that your tables, columns, and images stay right where they should be. Check out more about how it works [here](https://support.lilt.com/kb/image-and-scanned-pdf-file-translation#pdf-translation) ### **Language & Locale Management API** We now have a new language & locale management API, delivering a more efficient and robust way to handle translation pairs in the Lilt platform. This powerful API brings several key benefits:⁠⁠​ **Streamlined Workflow:** Automatically creates missing languages and locales when setting up new translation pairs, eliminating manual setup steps⁠⁠​\ **Intelligent MT Integration:** Automatically enables machine translation for supported language pairs (60+ languages), ensuring optimal translation quality with zero configuration⁠⁠​\ **Enhanced Reliability:** All pair creation happens in a single transaction, preventing incomplete setups and ensuring data integrity⁠⁠​\ **Error-Proof Operations:** Comprehensive validation with clear error messages and graceful handling of duplicates, making integration seamless and reducing support requests⁠⁠​ This API represents a significant step forward in making language management more accessible and error-resistant for both administrators and developers. Find out more [here](https://support.lilt.com/kb/additional-languages#adding-additional-languages) ### Improve Translation Memory Management Prioritize Recency Organization Setting LILT released a new organization-level setting that allows for recency-based match prioritization. If enabled, 101% matches will be treated as equivalent to 100% matches, prioritizing recency over context precision. This supports customers who want to use the most recent 100+% match translation, regardless of context, without decreasing the strength of TM matches. ### Prioritize Recency Organization Setting LILT released a new organization-level setting that allows for recency-based match prioritization. If enabled, 101% matches will be treated as equivalent to 100% matches, prioritizing recency over context precision. This supports customers who want to use the most recent 100+% match translation, regardless of context, without decreasing the strength of TM matches.\ Find out more [**here**](https://support.lilt.com/kb/translation-memory-matching#DataSourceMemoryMatching-Prioritizerecencysetting)**.** ### Instant Translate Analytics We've introduced a powerful new set of analytics specifically for our government users, focusing on **Instant Translation**. These new metrics provide insights into translation efficiency, user activity, and overall ROI. All metrics can be aggregated at the organization, domain, language pair, and user level. Find out more [**here**](https://support.lilt.com/kb/lilt-analytics-v2)**:** ## **LILT 5.2.1** ### **Native AWS RDS and S3 Support** LILT 5.2.1 introduces native support for Amazon Web Services (AWS) cloud infrastructure, allowing organizations to leverage AWS's managed services for enhanced scalability, reliability, and operational efficiency. This release includes built-in support for: * **Amazon RDS** for managed database services, providing automated backups, high availability, and simplified maintenance. Learn more about [Using Amazon RDS Instead of Local MySQL](https://support.lilt.com/system-administration/using-rds-instead-of-mysql). * **Amazon S3** for secure and scalable object storage, offering enterprise-grade data durability and availability. See our guide on [Using S3 instead of MinIO](https://support.lilt.com/system-administration/using-s3-instead-of-minio). These integrations reduce operational overhead while providing enterprise-grade infrastructure capabilities for mission-critical translation workloads. # **Breaking Changes** ## ElasticSearch ElasticSearch has undergone a major renovation, to switch to the ECK operator and upgrade from version 7 to version 8.\ In order to successfully install this version of LILT, the following should be executed by a system administrator *prior to installing this version of LILT*: * Uninstall the existing ElasticSearch helm installation * Ensure ElasticSearch PersistentVolume(s) and PersistentVolumeClaim(s) for elastic have been removed ## Troubleshooting ### Certificate Issues with Dataflow and Internal Tools If you experience connectivity problems, particularly with Dataflow or when connecting to internal tools, the TLS certificates may need to be regenerated. To resolve this: 1. Remove the `lilt/certs` folder from your installation directory 2. Remove the TLS certificate secrets from your Kubernetes cluster by running: ```bash theme={null} kubectl delete secret tls-server-certificates -n lilt kubectl delete secret tls-server-certificates-minio -n lilt kubectl delete secret tls-client-certificates -n lilt ``` 3. Re-run the `install-lilt.sh` script to regenerate certificates This will create fresh certificates and resolve most connectivity issues between internal services. # AI Providers Source: https://support.lilt.com/kb/3rd-party-llm-support-for-the-contextual-ai-engine In this article, we describe how to set-up your AI Providers to integrate third party models within LILT. This article is meant for anyone interested in using and managing their own LLMs within the LILT platform. *Administrator role or equivalent API Access role permission is required to configure LLMs in LILT.* ## Configuring and Editing LLM Integrations and Settings ### Manage AI Providers LILT enables administrators to set-up and manage LLMs all within the LILT platform. To set-up and manage an LLM: 1. Use the sidebar to navigate to “Manage” then select “AI Providers”. 2. On the first tab, you will see the various providers we support including Google, DeepL, OpenAI, AWS, and Azure. In addition, we also support Custom Models - please contact the LILT team to learn more! 3. From the desired LLM card, select “Configure” 1. 4. Enter the required configurations for your LLM (e.g. API key, JSON credentials, bucket name, Password, etc). For more information on configuration details, see the relevant pages: 1. [DeepL Configuration](/kb/deepl-configuration) 2. [Google Configuration](/kb/google-configuration) 3. [AWS Configuration](/kb/aws-configuration) 4. [OpenAI Configuration](/kb/openai-configuration) 5. Other selections: 1. Use Terms = allows selected terminology entries from the LILT Data Source attached to the model to be used for fine tuning Models built from this LLM. 2. Allow fine-tuning = allows LILT to share memory entries from selected LILT Data Sources to create more contextualized models. 5. Once you click Verify and Save, you will be able to see all of the associated services that are enabled for your organization based on the credentials provided. 6. Once you’ve configured your AI Providers, click on the “Services” Tab 1. Here you will see all of the different services (i.e. Translation, Create, etc.) you can access in LILT and the corresponding 3rd party AI services to power it in your platform. Screenshot2025 12 02at15 36 22 Pn ### Edit LLM Credentials and Settings Once an LLM is set-up, you can edit the API key, Password, and settings by doing the following: 1. Use the sidebar to navigate to “Manage” then select “AI Providers” 2. From the desired AI Provider, select “Edit” 3. Edit the API Key or Password, and toggle “Enable for your organization”, “Use Terms”, “Allow fine-tuning” as needed, and Save. # LILT 5.3 Release Notes Source: https://support.lilt.com/kb/5.3.0ReleaseNotes 2025 Q4 Release # **On-Prem Features and Updates** ## **Multimodal OCR Service** LILT 5.3 introduces a powerful new neural-based OCR service that delivers significantly improved accuracy for image and scanned PDF translation. The multimodal OCR service leverages advanced machine learning models to better extract text from complex documents, including those with mixed content types, tables, and challenging layouts. **Key Benefits:** * Enhanced accuracy for scanned PDFs and images * Improved handling of complex document layouts * Better recognition of tables and formatted content * Seamless integration with existing translation workflows **Configuration:** To enable the multimodal OCR service, update your `values.yaml`: ```yaml theme={null} ocr: enabled: true env: MQ_PWD: "" # Add to secrets.yaml ``` ## **Enhanced LLM Inference Architecture** LILT 5.3 restructures the LLM inference system into dedicated, optimized services for different AI models. This architectural improvement provides better resource management, improved performance, and more granular control over AI capabilities. ### **New Specialized Inference Services:** **Llama vLLM Inference** * Optimized inference for Llama language models * GPU-accelerated processing (requires 4 GPUs) * High-performance vLLM backend * Resource requirements: 100G memory, 5-14 CPUs **Whisper Speech-to-Text** * Real-time speech-to-text transcription * GPU-accelerated for faster processing * Supports multiple languages * Ideal for audio/video translation workflows **Gemma Model Inference** * Dedicated inference for Gemma3 models * Optimized for specific translation tasks * GPU-accelerated processing **Emma-500 Model Inference** * Specialized inference for Emma-500 models * Advanced language understanding capabilities **Configuration:** Enable specific inference services based on your needs: ```yaml theme={null} llama-vllm-inference: enabled: true # Enable Llama models llm-inference-whisper: enabled: true # Enable speech-to-text gemma-vllm-inference: enabled: true # Enable Gemma models emma-500-vllm-inference: enabled: true # Enable Emma-500 models ``` **GPU Requirements:** Ensure GPU nodes are available and labeled with `capability: gpu`. ## **Third-Party MT Batch Processing** A new CPU-based batch worker specifically designed for third-party machine translation (3pMT) processing has been added. This dedicated worker improves throughput and reliability for integrations with external MT providers. **Features:** * Dedicated CPU-based processing for 3pMT * Configurable worker pools * 24G memory for large document handling * Improved batch processing reliability **Configuration:** ```yaml theme={null} batch-worker-cpu-3pmt: enabled: true env: BATCH_WORKERS_MANAGER_3PMT_CPU_MAX_WORKERS: "1" BATCH_WORKERS_MANAGER_3PMT_CPU_STANDBY_WORKERS: "0" ``` ## **Enhanced Document Conversion** Document conversion timeouts have been made configurable, allowing better handling of large and complex documents. The new timeout settings apply to both the converter and file-translation services. **Configuration:** ```yaml theme={null} converter: env: APRYSE_TIMEOUT_MINUTES: "5" # Adjust based on document complexity file-translation: env: APRYSE_TIMEOUT_MINUTES: "5" # Adjust based on document complexity ``` Increase timeout values for particularly large or complex documents to prevent conversion failures. ## **MySQL SSL Support** LILT 5.3 adds comprehensive SSL/TLS support for MySQL connections, enhancing security for database communications. SSL is now enabled by default with flexible configuration options. **Configuration:** ```yaml theme={null} file-job: env: MYSQL_SSL_MODE: "PREFERRED" MYSQL_SSL_ENABLED: "true" memory: env: MYSQL_SSL_MODE: "PREFERRED" MYSQL_SSL_ENABLED: "true" ``` **SSL Modes:** * `REQUIRED`: Forces SSL connections (recommended for production) * `PREFERRED`: Uses SSL if available, falls back to unencrypted * `DISABLED`: Disables SSL (not recommended) ## **Core Platform Updates** ### **Internal Architecture Improvements** **Service Naming Standardization** * AV scanner service renamed to `lilt-av-scan` for consistency * ConfigMap and Secret resources standardized with `lilt-` prefix * Improved service discovery and management *** # **Breaking Changes** ## **LLM Inference Service Restructuring** The generic `llm-inference` service has been **removed** and replaced with specialized inference services. This change improves resource utilization and provides better control over AI model deployment. **Migration Required:** If you previously had `llm-inference` enabled, you must: 1. **Disable the old service:** ```yaml theme={null} llm-inference: enabled: false # Remove this service ``` 2. **Enable the appropriate replacement services:** ```yaml theme={null} # For Llama models llama-vllm-inference: enabled: true # For speech-to-text llm-inference-whisper: enabled: true # For Gemma models gemma-vllm-inference: enabled: true # For Emma-500 models emma-500-vllm-inference: enabled: true ``` 3. **Update GPU node labels** if not already configured: ```bash theme={null} kubectl label nodes capability=gpu ``` ## **ConfigMap and Secret Name Changes** Several services now reference standardized `lilt-configmap` and `lilt-secrets` instead of service-specific resources. **Affected Services:** * Translation Memory (tm) * Lexicon **Migration Steps:** 1. Ensure your deployment creates resources with the new names: * `lilt-configmap` (previously `front-configmap`) * `lilt-secrets` (previously `front-secrets`) 2. If using custom Helm templates, update references: ```yaml theme={null} # Old: configMapName: front-configmap secretsName: front-secrets # New: configMapName: lilt-configmap secretsName: lilt-secrets ``` ## **Init Container File Path Changes** Services using the two-stage init container pattern (lexicon, file-job) must update file path configurations. **Old Format:** ```yaml theme={null} lexicon: init: filePaths: "s3://lilt/lexicon-data/..." file-job: init: filePaths: "s3://lilt/tesseract/..." ``` **New Format:** ```yaml theme={null} lexicon: init: filePaths: "lexicon-data/..." # Remove s3://lilt/ prefix file-job: init: filePaths: "tesseract/..." # Remove s3://lilt/ prefix ``` **Action Required:** If you have customized init container configurations, update file paths to remove the `s3://lilt/` prefix. *** # **New Configuration Requirements** ## **Required Secrets** ### **Core-API S3 Credentials** Add to `secrets.yaml`: ```yaml theme={null} core-api: onpremValues: env: S3_ACCESS_KEY: "" S3_SECRET_KEY: "" ``` Set these to match your MinIO or S3-compatible storage credentials. ### **Multimodal OCR (If Enabling)** Add to `secrets.yaml`: ```yaml theme={null} multimodal: env: MQ_PWD: "" ``` ## **Optional Configuration Updates** ### **Backend Configuration Toggle** A new toggle allows enabling/disabling backend configuration features: ```yaml theme={null} front: onpremValues: backend_config: enabled: false # Set to true if needed ``` ### **BigQuery Integration** For customers using BigQuery analytics: ```yaml theme={null} core-api: env: BIG_QUERY_ENABLED: "false" # Set to true if using BigQuery ``` ### **Batch Worker Memory** Batch worker memory limits have been increased for improved performance: ```yaml theme={null} batchv4: resources: requests: memory: 2G # Increased from 1G limits: memory: 2G ``` **Action Required:** Ensure worker nodes have sufficient memory capacity. *** # **Infrastructure Requirements** ## **GPU Node Requirements** If enabling LLM inference services, ensure GPU nodes are available: | Service | GPU Count | Memory | CPU | | ----------------------- | --------- | -------- | -------- | | llama-vllm-inference | 4 | 100G | 5-14 | | llm-inference-whisper | Yes | Variable | Variable | | gemma-vllm-inference | Yes | Variable | Variable | | emma-500-vllm-inference | Yes | Variable | Variable | **Required Node Label:** `capability: gpu` **Setup:** ```bash theme={null} kubectl label nodes capability=gpu ``` ## **Worker Node Requirements** CPU-intensive services require worker nodes: | Service | Memory | CPU | | --------------------- | -------- | -------- | | batch-worker-cpu-3pmt | 24G | 1 | | Other batch workers | Variable | Variable | **Required Node Label:** `node-type: worker` **Setup:** ```bash theme={null} kubectl label nodes node-type=worker ``` *** # **Troubleshooting** ## **LLM Inference Services Not Starting** **Symptom:** LLM inference pods stuck in `Pending` state **Solution:** 1. Verify GPU nodes are available: ```bash theme={null} kubectl get nodes -l capability=gpu ``` 2. Check GPU resources: ```bash theme={null} kubectl describe nodes -l capability=gpu | grep nvidia.com/gpu ``` 3. Ensure proper node labels: ```bash theme={null} kubectl label nodes capability=gpu ``` ## **Multimodal OCR Connection Issues** **Symptom:** Multimodal service cannot connect to RabbitMQ **Solution:** 1. Verify RabbitMQ credentials in `secrets.yaml`: ```yaml theme={null} multimodal: env: MQ_PWD: "" ``` 2. Check RabbitMQ connectivity: ```bash theme={null} kubectl logs -n lilt deployment/multimodal-ocr ``` ## **Batch Worker Memory Issues** **Symptom:** Batch workers being OOMKilled **Solution:** 1. Verify node capacity: ```bash theme={null} kubectl describe nodes -l node-type=worker | grep -A 5 Allocatable ``` 2. Increase memory if needed: ```yaml theme={null} batch-worker-cpu-3pmt: resources: requests: memory: 32G # Increase if needed limits: memory: 32G ``` ## **ConfigMap/Secret Not Found Errors** **Symptom:** Services failing with "configmap 'lilt-configmap' not found" **Solution:** Ensure the main Lilt chart creates these resources. Check your Helm templates include: ```yaml theme={null} apiVersion: v1 kind: ConfigMap metadata: name: lilt-configmap namespace: lilt --- apiVersion: v1 kind: Secret metadata: name: lilt-secrets namespace: lilt ``` ## **S3/MinIO Connection Issues** **Symptom:** Services cannot access S3/MinIO storage **Solution:** 1. Verify S3 credentials in `secrets.yaml`: ```yaml theme={null} core-api: onpremValues: env: S3_ACCESS_KEY: "" S3_SECRET_KEY: "" ``` 2. Verify internal MinIO endpoint is accessible: ```bash theme={null} kubectl exec -n lilt deployment/core-api -- curl -k https://minio.lilt.svc.cluster.local:9000 ``` # Job Form Editor Source: https://support.lilt.com/kb/Job-Form-Editor The Job Form Editor allows you to customize your job submission experience with organization-wide custom job properties. This feature enables you to capture important metadata, such as billing codes, department information, PO numbers, or job identifiers, at the job level, ensuring consistent data collection across your organization. ## Who this is for * **Admins** who configure job submission for an organization or a specific domain. * Teams who need to collect consistent **job-level metadata** at submission time. ## What you can do in the Custom Job Form Editor * **Show / hide** optional sections of the Job Submission flow (so submitters only see what they need). * Configure **defaults** (for example, default language settings or whether Verified is the default). * Add **job-level custom properties** to capture organization-specific tracking information. * Configure at **two levels**: * **Organization-level** (applies by default) * **Domain-level** (overrides organization defaults for that domain) ## Where to find it 1. In the LILT platform, open **Manage**. 2. Select **Job Form Editor**. 3. Choose whether you’re editing the **Organization** form or a **Domain** form by using the Domain selector at the top of the page. Image ## How organization vs. domain configuration works * **Organization form** defines the default job submission experience. * **Domain form** can: * Use the organization form as-is by selecting "Use organization form for this domain.", or * Override which fields/steps are shown and which defaults apply for that domain. Image ### Recommended setup approach 1. Configure the **organization** form first. 2. Only create **domain overrides** when a domain truly needs a different submission experience. *** # Configure your Job Submission form ## Step 1: Review required vs. optional sections Some steps are always required for Job Submission (for example, file upload), while other steps can be optional depending on your organization’s setup. In the Custom Job Form Editor: * Ensure required steps are present. * For optional steps, decide whether to: * Show them to all submitters, * Hide them entirely, or * Make them conditional (if available in your deployment). * PO Number and Invoice Split are populated for LILT services customers with information from their account, but can be hidden if not relevant. ## Step 2: Set defaults Use defaults to minimize work for submitters and reduce incorrect submissions. Common defaults include: * **Instant vs. Verified** default behavior Image * **Default source / target languages** (when applicable) Image ## Step 3: Add job-level custom properties Custom job fields are best for metadata you want to capture *every time* a job is created. Custom properties added to a job will automatically propagate to all projects within that job. Common use cases include: * **Internal billing and chargebacks**: Capture department codes or cost centers to allocate translation costs * **PO number tracking**: Link jobs to purchase orders for procurement workflows * **Project categorization**: Tag jobs by campaign, customer, or project type for better organization * **Compliance tracking**: Record certification requirements or compliance flags * **Multi-team coordination**: Identify which team or division requested the translation work ### Supported field types Depending on your configuration, custom fields may include: * **Text** * **Checkbox** * **Picklist / dropdown** * **URL** ### Make a field required (optional) If a field is required, submitters cannot complete Job Submission until it’s filled in. Image ### Important notes * Custom properties only apply to jobs created **after** the property is defined. They are not backfilled to existing jobs. * All user roles can see and use custom properties if they are enabled for your organization. * If you delete a custom property, it will no longer appear during job creation, but historical data is preserved. ## Step 4: Save and publish After making changes: 1. **Save / Publish** the form. 2. Start a **new** Job Submission to confirm the updated flow is displayed as expected. *** # What happens after a job is created ## Where to see custom field values Custom job field values are stored as job metadata and can be viewed on the job after submission in [Job Settings](https://support.lilt.com/kb/navigating-the-jobs-list#job-settings). ## Editing values after submission If enabled in your deployment, you can edit job metadata after creation in Job Settings (useful when a PO number is issued later). ## Filtering and reporting If enabled, jobs can be **filtered** using the custom fields configured in the Job Form Editor on the Jobs page. For example, filter by PO number, department, or other tracking fields. *** # Troubleshooting ## I updated the form, but the Job Submission page didn’t change * Confirm you edited the correct scope (**Organization** vs **Domain**). * Confirm you **published** changes. * Start a **new** job submission (changes may not apply to already-created jobs). ## A domain change affected other domains Domain overrides should only apply to the selected domain. If you see changes leaking across domains, capture: * Which domain you edited * Which domains are unexpectedly affected * A screenshot or short screen recording …and report it to your LILT support contact. ## Job submission is blocked even though all fields look complete * Check for a required field that is: * Hidden behind a collapsed section, or * Off-screen (scroll to the top and look for validation highlights) * If quoting is enabled, confirm any quote-required steps are completed. *** # Admin best practices * Keep the submission form **minimal** for most domains; add complexity only where it drives real business value. * Use **consistent naming** for custom fields so reporting and filtering remains clean. * Avoid creating a custom field with the same name as a standard field (for example, “Status”) to prevent confusion. # LILT MCP Server Source: https://support.lilt.com/kb/LILT-mcp The LILT MCP (Model-Context Protocol) server integrates with LILT Enterprise APIs to provide translation capabilities within Anthropic's Claude or other platforms that support hosting MCP servers.