Welcome to the Smartling Help Center!

Smartling's Translation Management Platform is a solution that prioritizes process automation and collaboration so that teams can quickly and cost-effectively localize websites, apps, and documents with minimal IT involvement.

The Help Center is Smartling's documentation repository for the UI and API.

Search results for "{{ search.query }}"

No results found for "{{search.query}}". 
View All Results

General Info

 

This section contains technical documentation (API v2) for developers on integrating the power of the Smartling platform into your project. The more effort you put into integration and automation, the less time spent administering translation work.

For API v1 and UI documentation:

  • For API v1, click here. Version 1 is in maintenance and will not release any new endpoints. When possible, use API v2 for the latest endpoints.

  • For business rules, and general information on managing translations in Smartling, see the Documentation section.

API

Smartling's API is extensive and still growing. Almost any action you can take inside the Smartling Dashboard can also be done via API, and if it can't yet, we're probably working on it. Watch this space for updates as we release new endpoints.

This documentation covers Smartling API version 2. Version 1 is set to be deprecated on October 1, 2017 and should be avoided in new integrations. (Deprecation of v1: For customers using API v1, it will continue to work as-is after October 1, 2017, but we do recommend migrating to v2.)

Files

If your project uses translatable resource files, you can customize how Smartling parses your file into translatable strings. Consult the File Support section of our documentation for more information on all file types supported by Smartling, directives you can add to files to change how they are parsed, and advice for working with common frameworks.

Available APIs

 
API
Description

Authentication

The Authentication API provides the methods to authenticate API calls.

Strings

The Strings API allows for creating individual strings not associated with files and downloading translated strings.

Issues

The Issues API allows for manipulation of source and translation issues.

Files

The Files API allows for uploading, downloading and checking status on files in the Smartling platform.

Jobs

The Jobs API allows for packaging and tracking of content within Smartling during the translation process.

Glossary

The Glossary API allows for managing individual glossary terms and translations and for importing and exporting Glossary files.

Context

The Context API supports uploading various forms of context - images and HTML - and associated the context with content in Smartling.

New in v2

 

Smartling is rolling out a new, expanded suite of APIs. Beginning with Authentication and Files APIs. API v1 is still supported but will be deprecated on October 1 2017.

Version 2 of FilesAPI will be familiar to you if you’ve used v1 but there are some important differences to keep in mind while you’re getting started.

See our migration guide for help getting started.

Authentication

V2 APIs replace the single API key with Oauth 2.0 authentication, requiring an access token to be included in the header of every request. Tokens are obtained via an Authenticate request containing a User ID and User Secret. See Authentication for more info.

Path Variables

Some V2 URLs contain path variables that you need to consider when you write your calls. In FilesAPI there are two path variables that may appear in a URL.

  • projectId - the unique identifier for a Smartling project. You can find this information in the Smartling dashboard at Project Settings > API.

  • locale - the locale code for a translated file. You can find a full list of locale codes used in each of your projects in the Smartling dashboard at Project Settings > API.

New Terminology

Some terminology and parameter names in v2 are different from their v1 equivalents. Changes include

To bring the API in line with Smartling's Dashboard terminology, the API uses 'authorize' instead of 'approve'. For example, the localesToApprove parameter in the v1 version of Upload call is now localeIdsToAuthorize in v2
URLs now use hyphens (-) instead of underscores (_). For example: /last_modified is now /last-modified

Arrays

Most Smartling API arguments are strings, but some v2 calls take arrays as arguments to return information on multiple files or locales.

www-url-encoded:

?localeId[]=de-DE&localeId[]=fr-FR
Don’t forget the square brackets for array values, even if you’re only passing a single argument.

Form Parameters:

-F "localeId[]=fr-FR" -F "localeId[]=de-DE"

JSON:

{"localeIds":["es-ES","zh-CN"]}

New Options

If you’re already using v1 of Smartling’s File API, you may be able to improve on your integration with the new, more powerful calls included in v2. Significant new options include:

You now have four different options for downloading files:

  • Download a single translated file
  • Download all locales for a single file as a .ZIP archive
  • Download multiple files for multiple locales as a .ZIP archive
  • Download translations for all locales in a single CSV file
    Choose between detailed status of a file in a single locale or a summary for all locales.
    Check last modified dates for a selected locale

Migrate to v2

 

Many of Smartling’s v1 API methods are scheduled to be deprecated October 1 2017, so all users should start preparing to transition to v2 methods. Migrating your existing integrations from v1 to v2 requires four steps.

Create an authentication strategy

Where v1 requests were authorized with an API key, v2 requests use Oauth 2.0. A valid access token must be included in the header of each request. This means that you need to set up some way of passing a valid token to your API requests. See Authentication for full details. Depending on how you are using the API, there are two main approaches:

  • Make a separate Authentication request before each request to obtain an access token. If accessing the API intermittently or as part of a script, this is likely to be the easiest solution.
  • Set up a process to obtain and periodically refresh an access token, then make it available as a variable. Consider this approach if you’re integrating Smartling into an application or making a high volume of requests.

Change your requests to use path variables

While v1 request URLs were static, v2 APIs use path variables to identify projects and locales. To switch to v2, you’ll need to update how you assemble your requests to generate the correct request URL for the project and locale you want to access.

Switch over to v2 URLs

Smartling’s v2 API gives you some new options for managing your content (see New in v2 for details). Consider taking advantage of the new endpoints when you switch to v2. To maintain your current functionality, see the table below for the most direct v2 equivalent of each v1 endpoint.

Update necessary parameters - especially Arrays

Many v2 requests use similar parameters to their v1 equivalents, with a few key differences. Parameters that referenced ‘Approve’ in v1, now use ‘Authorize’ to match the terminology used in the Smartling Dashboard. Additionally, some requests now take Array arguments. These are marked in the documentation for each request. Array arguments must be passed in array format, even if there is only one value.

You should now be ready to start using Smartling API v2.

Callbacks

 

Some events in Smartling can trigger callbacks to a specified URL. Callbacks usually let you know when an action is completed. For example, a file or string is translated in a particular locale or a translation job is complete.

General Information

  • Callbacks are issued from IP 184.73.255.141. To make sure you receive necessary callbacks, you should whitelist this IP address.

Callbacks

String is translated for a locale

This callback is sent to the URL provided in the Create Strings request. It can be sent as a GET or POST request, thouh only the POST request includes translations. The POST request looks like:

{
  "projectId": "51df0cf05",
  "hashcode": "3325fc569a651bef02a93732e48701b4",
  "localeId": "fr-FR",
  "type": "string.localeCompleted",
  "translations": [
    {
      "translation": "Bonjour!",
      "pluralForm": null,
      "modifiedDate": "2016-12-01T14:18:00Z"
    }
  ]
}

A GET request includes the same information - with the exception of the translations object as querystring parameters: ?projectID=9db9036e6 etc.

Type of Callback Received for Different Job Entities (jobs, strings, files)

Jobs
A job callback is sent when a job is Completed, Cancelled or a Locale of the Job is Completed

Job Completed:
The callback will contain the translationJobUid, type=job.completed

Locale Completed:
The callback will contain the translationJobUid, type=job.localeCompleted, localeId
Job Cancelled
The callback will contain the translationJobUid, type=job.cancelled, ts

Strings
String Completed:
For now, a callback will only be sent when the string is completed for a locale. Additional types may be added down the road.
The callback will contain the hashcode, projectId, localeId and a type=string.localeCompleted

Files
File Completed:
No type has been added to File callbacks. It is only sent when the file is complete. The callback will contain fileUri and "locale" (Note, this is locale, not localeId).

Rate Limiting

 

Smartling API imposes rate limits on requests to ensure that resources are shared fairly among clients. If you make a high number of requests in a short time period, some requests may fail.

If rate limiting is applied, a 429 MAX_OPERATIONS_LIMIT_EXCEEDED response will be sent. Your integration should be setup to wait and retry a request if a 429 response is received.

Where possible, spread out your requests to avoid running into rate-limiting issues.

Response Format

 

Success

Success responses are encoded into a generalized JSON structure with two basic properties: a response code, and a custom data object.

{
    "response": {
        "code": "SUCCESS",
        "data": {
            "localeId": "de-DE",
            "lastModified": "[YYYY-MM-DDThh:mm:ssZ]"
        }
    }
}

Errors

Error responses include an array of errors, each with a key and message explaining the details of the error. Some errors may give additional details.

{
    "response": {
         "code": "VALIDATION_ERROR",
         "errors": [{
              "key": "parse.error",
              "message": "There was a problem loading your file. No source strings found; Check your configuration http://goo.gl/OW6Q1o",
              "details": {
                   "errorId": "cse8rqnf"
              }
         }]
  }
}

Response Codes

Value Description HTTP Code
SUCCESS If the service request was processed normally 200
ACCEPTED It an asynchronous task, such as a file upload, has begun, but is not completed at the time the response is sent. 202
VALIDATION_ERROR If something specific was wrong with the request parameters provided. One or more will describe the particular invalid parameter. 400
AUTHENTICATION_ERROR If the provided credentials were not valid. 401
AUTHORIZATION_ERROR Legacy error code from API 401
RESOURCE_LOCKED The requested file is currently being processed by another operation. The file will be unlocked after the operation completes. See Upload for more details. 423
MAX_OPERATIONS_LIMIT_EXCEEDED Too many simultaneous API requests per project or file. 429
GENERAL_ERROR If an unexpected error occurred during the service request processing. 500
MAINTENANCE_MODE_ERROR If Smartling has entered maintenance mode, all API services will return this error. After exiting maintenance mode all services should return to normal. 503

SDKs

 

Smartling makes a variety of SDKs available for Java, Python, and PHP.

CLI (Command Line Interface)

 

In addition to our language specific SDKs, clients have used our BASH scripts or otherwise directly accessed the Smartling API. The CLI (Command Line Interface) tool is designed as a replacement for direct access, and replaces our BASH scripts for accessing v2 of the API. Follow these steps to get you started with uploading, downloading, and getting a full list of files in Smartling's Files API.

Download and Documentation

All the details for installing and using the CLI tool are in the public GitHub page. Go to Smartling CLI.

Best Practices for Storing Credentials

The most convenient way to use the tool is to create configuration file(s) that will store your basic credentials and preferences. The 'init' command can help with this.

Your config file has sensitive information. We recommend using best practices for securely storing your credentials.

The following information from Amazon Web Services covers this topic and the same is applicable to your Smartling CLI Tool initialization file.

Authentication

 

Authenticate

Authenticates the user with a User Identifier and Secret. Returns an access token that can be attached to the header of any API request to authenticate the user, and a refresh token which can be used to obtain a new access token.

 
posthttps://api.smartling.com/auth-api/v2/authenticate
curl --request POST \
  --url https://api.smartling.com/auth-api/v2/authenticate
var request = require("request");

var options = { method: 'POST',
  url: 'https://api.smartling.com/auth-api/v2/authenticate' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/auth-api/v2/authenticate")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.smartling.com/auth-api/v2/authenticate");

xhr.send(data);
import requests

url = "https://api.smartling.com/auth-api/v2/authenticate"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": {
      "accessToken": "b816424c-2e95-11e7-93ae-92361f002671",
      "refreshToken": "c0a6f410-2e95-11e7-93ae-92361f002671",
      "expiresIn": 480,
      "refreshExpiresIn": 3660,
      "tokenType": "Bearer"
    }
  }
}

Body Params

userIdentifier
string
required

API v2 user identifier

userSecret
string
required

API v2 user secret

Response

Access and refresh tokens

Unexpected error

responseobject
response.codestring
response.errorsarray

Refresh access token

Returns a renewed access token that can be attached to the header of any API request to authenticate the user, and a refresh token which can be used to obtain a new access token.

 
posthttps://api.smartling.com/auth-api/v2/authenticate/refresh
curl --request POST \
  --url https://api.smartling.com/auth-api/v2/authenticate/refresh
var request = require("request");

var options = { method: 'POST',
  url: 'https://api.smartling.com/auth-api/v2/authenticate/refresh' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/auth-api/v2/authenticate/refresh")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.smartling.com/auth-api/v2/authenticate/refresh");

xhr.send(data);
import requests

url = "https://api.smartling.com/auth-api/v2/authenticate/refresh"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Body Params

refreshToken
string
required

The refresh token returned from a previous authentication request

Response

Access and refresh tokens

Unexpected error

responseobject
response.codestring
response.errorsarray

Create Strings

 

Create Strings

Uploads an array of strings to a Smartling project. A maximum of 100 strings can be created per request. A request with more than 100 items will return an error. Each string has a character limit of 10 000.

Note that you cannot authorize a string via API. Once you have created the strings, they will need to be authorized by a content owner in the Smartling Dashboard.

Smartling creates a unique hashcode for each string based on the parsed string text and any variant or namespace metadata provided. If you upload a string with the same text, variant and namespace, and therefore the same hashcode, the existng string will be overwritten. This will not change the text of the string, but may update other metadata, such as placeholder and callback values. If the string is currently inactive, overwriting it will cause it to be reactivated. Overwritten strings return "overWritten": "true" in the response object.

Most uploads will return a 200 response indicating success. If processing the request takes longer than 60 seconds, a 202 request will be returned, including a processUid value that can be used to check on the progress of the request.

If you set up a POST callback for the string, you can automatically receive the translation for a string as soon as it is complete. See Callbacks for more details.

 
posthttps://api.smartling.com/strings-api/v2/projects/projectId
curl --request POST \
  --url https://api.smartling.com/strings-api/v2/projects/projectId
var request = require("request");

var options = { method: 'POST',
  url: 'https://api.smartling.com/strings-api/v2/projects/projectId' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/strings-api/v2/projects/projectId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.smartling.com/strings-api/v2/projects/projectId");

xhr.send(data);
import requests

url = "https://api.smartling.com/strings-api/v2/projects/projectId"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": {
      "wordCount": 4,
      "stringCount": 1,
      "processUid": "d6414f8c-4gdf-4415-9a69-f8e7902ca9ec",
      "items": [
        {
          "variant": "variant value",
          "stringText": "Search results for [city]:",
          "parsedStringText": "Search results for {0}:",
          "hashcode": "bd603147d945h3ec74d6874422ebe4e0",
          "overWritten": "true"
        }
      ]
    }
  }
}

Path Params

projectId
uuid
required

Body Params

placeholderFormat
string

Specifies a standard placeholder format. Accepted values are none, c, ios, python, java, yaml, qt, resx. For more detail on placeholders see Placeholders in Resource Files

placeholderFormatCustom
string

Specifies a custom placeholder with a Java Regular Expression. For example \[.+?\] would capture all values surrounded by square brackets as placeholders. For more detail on placeholders see Placeholders in Resource Files

namespace
string

Used to generate the unique hashcode for all strings in the request. If you want to have two versions of a string with the same text and variant metadata, you can keep them unique by assigning a different namespace to each string. If not provided, default value is smartling.strings-api.default.namespace. A NULL value is permitted.

strings
array of objects
stringText
variant
callbackUrl
callbackMethod
instruction
maxLength
format

Response

Strings

Strings

Unexpected error

responseobject
response.codestring
response.errorsarray

Check String Status

 

Check string status

If a Create Strings request takes longer than 60 seconds to process, a 202 response will be returned, indicating that the process of creating strings is continuing but not yet complete. This response will include a proccessUid value which can be used to check the progress of the request. This request returns a processState value of open, indicating that the request is still continuing, closed, indicating the request has successfully completed, and failed, meaning the request could not be completed.

Processes have a limited lifespan after they are complete. This request will fail if you specify an expired processUid.

 
gethttps://api.smartling.com/strings-api/v2/projects/projectId/processes/processUid
curl --request GET \
  --url https://api.smartling.com/strings-api/v2/projects/projectId/processes/processUid
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.smartling.com/strings-api/v2/projects/projectId/processes/processUid' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/strings-api/v2/projects/projectId/processes/processUid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.smartling.com/strings-api/v2/projects/projectId/processes/processUid");

xhr.send(data);
import requests

url = "https://api.smartling.com/strings-api/v2/projects/projectId/processes/processUid"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

projectId
uuid
required
processUid
uuid
required

Response

Success response

Unexpected error

responseobject
response.codestring
response.errorsarray

Get Source Strings

 

Get source strings

Returns source strings from Smartling. You can get strings by specifying a file you want strings for, or you can specify individual strings by hashcode.

If you do not specify at least one of these parameters (hashcodes or fileUri) no results will be returned.

Note that if you use this call to get strings not created with the strings API, you may see differences in the response.

You may see a value for parsedStringText but a null value for stringText. The stringText records the raw input received by the String API so will only appear for strings uploaded via String API.
If you are getting a GDN string, the original placeholder values you used will not be returned, as these are not saved by Smartling. GDN strings will have placeholders in the format {0}, {1}, etc.

 
gethttps://api.smartling.com/strings-api/v2/projects/projectId/source-strings
curl --request GET \
  --url https://api.smartling.com/strings-api/v2/projects/projectId/source-strings
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.smartling.com/strings-api/v2/projects/projectId/source-strings' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/strings-api/v2/projects/projectId/source-strings")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.smartling.com/strings-api/v2/projects/projectId/source-strings");

xhr.send(data);
import requests

url = "https://api.smartling.com/strings-api/v2/projects/projectId/source-strings"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

projectId
uuid
required

Form Data

hashcodes
array of strings

Hashcodes for each string you want to get source strings for.

fileUri
string

URI of a file you want to get strings for.

limit
number

Pagination setting. By default responses will be limited to 500 per request. This is also the maximum allowed value.

offset
number

Pagination setting. Default is 0.

Response

Success response

Unexpected error

responseobject
response.codestring
response.errorsarray

Get Translations

 

Get translations

Returns translated strings from Smartling. You can get translations by specifying a file you want strings for, or you can specify individual strings by hashcode.

If you do not specify at least one of these parameters (hashcodes or fileUri) no results will be returned.

Note that if you use this call to get strings not created with the strings API, you may see differences in the response.

Only authorized and active strings will be returned. Excluded, unauthorized & inactive strings will not be returned.

You may see a value for parsedStringText but a null value for stringText. The stringText records the raw input received by the String API so will only appear for strings uploaded via String API.
If you are getting a GDN string, the original placeholder values you used will not be returned, as these are not saved by Smartling. GDN strings will have placeholders in the format {0}, {1}, etc.

 
gethttps://api.smartling.com/strings-api/v2/projects/projectId/translations
curl --request GET \
  --url https://api.smartling.com/strings-api/v2/projects/projectId/translations
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.smartling.com/strings-api/v2/projects/projectId/translations' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/strings-api/v2/projects/projectId/translations")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.smartling.com/strings-api/v2/projects/projectId/translations");

xhr.send(data);
import requests

url = "https://api.smartling.com/strings-api/v2/projects/projectId/translations"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

projectId
uuid
required

Form Data

hashcodes
array of strings

Hashcodes for each string you want to get translations for.

targetLocaleId
string

Smartling ID for the language you want to get translations for.

retrievalType
string

Sets the types of translations you want returned. published will only return translations that have completed their workflows and been published. pending will return any saved translations.

fileUri
string

URI of a file you want to get translations for.

limit
number

Pagination setting. By default responses will be limited to 500 per request. This is also the maximum allowed value.

offset
number

Pagination setting. Default is 0.

Response

Success response

Unexpected error

responseobject
response.codestring
response.errorsarray

Dictionaries

 

Get Issue Types

This request returns all current issue types. Smartling may occasionally add or change the list of allowed issue types.

 
gethttps://api.smartling.com/issues-api/v2/dictionary/issue-types
curl --request GET \
  --url https://api.smartling.com/issues-api/v2/dictionary/issue-types
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.smartling.com/issues-api/v2/dictionary/issue-types' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/issues-api/v2/dictionary/issue-types")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.smartling.com/issues-api/v2/dictionary/issue-types");

xhr.send(data);
import requests

url = "https://api.smartling.com/issues-api/v2/dictionary/issue-types"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": {
      "totalCount": 2,
      "items": [
        {
          "description": "Source",
          "issueTypeCode": "SOURCE",
          "subTypes": [
            {
              "issueSubTypeCode": "CLARIFICATION",
              "description": "Clarification"
            },
            {
              "issueSubTypeCode": "MISSPELLING",
              "description": "Misspelling"
            }
          ]
        },
        {
          "description": "Translation",
          "issueTypeCode": "TRANSLATION",
          "subTypes": [
            {
              "issueSubTypeCode": "POOR_TRANSLATION",
              "description": "Poor Translation"
            },
            {
              "issueSubTypeCode": "DOES_NOT_FIT_SPACE",
              "description": "Doesn't Fit Space"
            },
            {
              "issueSubTypeCode": "PLACEHOLDER_ISSUE",
              "description": "Placeholder Issue"
            },
            {
              "issueSubTypeCode": "GENERAL_ISSUE",
              "description": "General Issue"
            },
            {
              "issueSubTypeCode": "REVIEW_TRANSLATION",
              "description": "Revieanslation"
            }
          ]
        }
      ]
    }
  }
}

Response

Get Issue States

Currently the only allowed issue states are OPENED and RESOLVED but Smartling may introduce additional states in future. This request returns all current allowed states.

 
gethttps://api.smartling.com/issues-api/v2/dictionary/issue-states
curl --request GET \
  --url https://api.smartling.com/issues-api/v2/dictionary/issue-states
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.smartling.com/issues-api/v2/dictionary/issue-states' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/issues-api/v2/dictionary/issue-states")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.smartling.com/issues-api/v2/dictionary/issue-states");

xhr.send(data);
import requests

url = "https://api.smartling.com/issues-api/v2/dictionary/issue-states"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": {
      "totalCount": 2,
      "items": [
        {
          "description": "Opened",
          "issueStateCode": "OPENED"
        },
        {
          "description": "Resolved",
          "issueStateCode": "RESOLVED"
        }
      ]
    }
  }
}

Response

Issues

 

Create Issue

Creates a new issue for a string.

Issue text is treated as plain text. Smartling will save the text as provided and will not attempt to render this text with any special formatting in its UIs; it will not be rendered as HTML or markdown. Consumers of the issue API should be aware and escape the text as needed before attempting to render it. Maximum length is 4000 characters.
 
posthttps://api.smartling.com/issues-api/v2/projects/projectId/issues
curl --request POST \
  --url https://api.smartling.com/issues-api/v2/projects/projectId/issues
var request = require("request");

var options = { method: 'POST',
  url: 'https://api.smartling.com/issues-api/v2/projects/projectId/issues' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/issues-api/v2/projects/projectId/issues")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.smartling.com/issues-api/v2/projects/projectId/issues");

xhr.send(data);
import requests

url = "https://api.smartling.com/issues-api/v2/projects/projectId/issues"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": {
      "string": {
        "hashcode": "c32c16cddafd63dfa0dc12449372a093",
        "localeId": null
      },
      "resolvedByUserUid": null,
      "reportedByUserUid": "661801f19693",
      "createdDate": "2015-11-10T16:01:22Z",
      "resolvedDate": null,
      "issueText": "asdfsd",
      "issueUid": "dceaa996d417",
      "projectId": "e8fa915fa",
      "issueTypeCode": "SOURCE",
      "issueSubTypeCode": "CLARIFICATION",
      "issueStateCode": "OPENED",
      "issueTextModifiedDate": null
    }
  }
}

Path Params

projectId
string
required

Body Params

issueText
string
required

Free text field explaining an issue.

issueTypeCode
string
required

Identifies the issue type. issueTypeCode is either SOURCE or TRANSLATION. Each have their own set of issueSubType values

issueSubTypeCode
string
required

For issueTypeCode=SOURCE - CLARIFICATION | MISSPELLING, For issueTypeCode=TRANSLATION - POOR_TRANSLATION | DOES_NOT_FIT_SPACE | PLACEHOLDER_ISSUE | GENERAL_ISSUE | REVIEW_TRANSLATION

string
object
 
string.hashcode
string
required

Unique identifier for a string in Smartling. Used by the Issues API to attach an issue to a string. You can get the hashcode for a string via String API.

string.localeId
string
required

An identifying code for a language in Smartling.

Response

Edit Issue

Replaces the text of an issue with new text. Note that only the author of the issue can perform this action. The issueTextModifiedDate property of an issue object shows when it was last updated.

Issue text is treated as plain text. Smartling will save the text as provided and will not attempt to render this text with any special formatting in its UIs; it will not be rendered as HTML or markdown. Consumers of the issue API should be aware and escape the text as needed before attempting to render it. Maximum length is 4000 characters.
 
puthttps://api.smartling.com/issues-api/v2/projects/projectId/issues/issueUid/issueText
curl --request PUT \
  --url https://api.smartling.com/issues-api/v2/projects/projectId/issues/issueUid/issueText
var request = require("request");

var options = { method: 'PUT',
  url: 'https://api.smartling.com/issues-api/v2/projects/projectId/issues/issueUid/issueText' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/issues-api/v2/projects/projectId/issues/issueUid/issueText")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "https://api.smartling.com/issues-api/v2/projects/projectId/issues/issueUid/issueText");

xhr.send(data);
import requests

url = "https://api.smartling.com/issues-api/v2/projects/projectId/issues/issueUid/issueText"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": {
      "issueText": "Edited issue text.",
      "issueTextModifiedDate": "2015-11-10T16:01:22Z"
    }
  }
}

Path Params

projectId
string
required
issueUid
string
required

Body Params

issueText
string
required

Free text field explaining an issue.

Response

Open or Close Issue

The state of the issue. Accepted values are OPENED or RESOLVED.

 
puthttps://api.smartling.com/issues-api/v2/projects/projectId/issues/issueUid/state
curl --request PUT \
  --url https://api.smartling.com/issues-api/v2/projects/projectId/issues/issueUid/state
var request = require("request");

var options = { method: 'PUT',
  url: 'https://api.smartling.com/issues-api/v2/projects/projectId/issues/issueUid/state' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/issues-api/v2/projects/projectId/issues/issueUid/state")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "https://api.smartling.com/issues-api/v2/projects/projectId/issues/issueUid/state");

xhr.send(data);
import requests

url = "https://api.smartling.com/issues-api/v2/projects/projectId/issues/issueUid/state"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": {
      "issueStateCode": "RESOLVED"
    }
  }
}

Path Params

projectId
string
required
issueUid
string
required

Body Params

issueStateCode
string
required

The state of the issue. Accepted values are OPENED or RESOLVED.

Response

Get Issue Details

Returns detailed information on a single issue. Note that the resolvedByUserUid and reportedByUserUid values are not currently usable for identifying the users who created or resolved issues. In future, a People API will be exposed for looking up user details.

 
gethttps://api.smartling.com/issues-api/v2/projects/projectId/issues/issueUid
curl --request GET \
  --url https://api.smartling.com/issues-api/v2/projects/projectId/issues/issueUid
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.smartling.com/issues-api/v2/projects/projectId/issues/issueUid' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/issues-api/v2/projects/projectId/issues/issueUid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.smartling.com/issues-api/v2/projects/projectId/issues/issueUid");

xhr.send(data);
import requests

url = "https://api.smartling.com/issues-api/v2/projects/projectId/issues/issueUid"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": {
      "string": {
        "hashcode": "c32c16cddafd63dfa0dc12449372a093",
        "localeId": "ru-RU"
      },
      "resolvedByUserUid": null,
      "reportedByUserUid": "661801f19693",
      "createdDate": "2015-11-10T16:01:22Z",
      "resolvedDate": null,
      "issueText": "This translation is incorrect. Please fix.",
      "issueUid": "dceaa996d417",
      "projectId": "e8fa915fa",
      "issueTypeCode": "TRANSLATION",
      "issueSubTypeCode": "POOR_TRANSLATION",
      "issueStateCode": "OPENED",
      "issueTextModifiedDate": null
    }
  }
}

Path Params

projectId
string
required
issueUid
string
required

Response

Comments

 

Create Comment

Create a comment for an issue.

Comment text is treated as plain text. Smartling will save the text as provided and will not attempt to render this text with any special formatting in its UIs; it will not be rendered as HTML or markdown. Consumers of the issue API should be aware and escape the text as needed before attempting to render it. Maximum length is 4000 characters.
 
posthttps://api.smartling.com/issues-api/v2/projects/projectId/issues/issueUid/comments
curl --request POST \
  --url https://api.smartling.com/issues-api/v2/projects/projectId/issues/issueUid/comments
var request = require("request");

var options = { method: 'POST',
  url: 'https://api.smartling.com/issues-api/v2/projects/projectId/issues/issueUid/comments' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/issues-api/v2/projects/projectId/issues/issueUid/comments")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.smartling.com/issues-api/v2/projects/projectId/issues/issueUid/comments");

xhr.send(data);
import requests

url = "https://api.smartling.com/issues-api/v2/projects/projectId/issues/issueUid/comments"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": {
      "issueCommentUid": "a75fea779bbb",
      "commentText": "comment text",
      "createdByUserUid": "661801f19693",
      "createdDate": "2015-12-22T12:34:49Z",
      "commentTextModifiedDate": null
    }
  }
}

Path Params

projectId
string
required
issueUid
string
required

Body Params

commentText
string
required

Text of the comment you want to make.

Response

Get Comments

Returns all comments on an issue. Note that the createdByUserUid value is not currently usable for identifying the users who created comments. In future, a People API will be exposed for looking up user details.

 
gethttps://api.smartling.com/issues-api/v2/projects/projectId/issues/issueUid/comments
curl --request GET \
  --url https://api.smartling.com/issues-api/v2/projects/projectId/issues/issueUid/comments
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.smartling.com/issues-api/v2/projects/projectId/issues/issueUid/comments' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/issues-api/v2/projects/projectId/issues/issueUid/comments")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.smartling.com/issues-api/v2/projects/projectId/issues/issueUid/comments");

xhr.send(data);
import requests

url = "https://api.smartling.com/issues-api/v2/projects/projectId/issues/issueUid/comments"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": {
      "items": [
        {
          "issueCommentUid": "a75fea779bbb",
          "commentText": "comment text",
          "createdByUserUid": "661801f19693",
          "createdDate": "2015-12-22T12:34:49Z",
          "commentTextModifiedDate": null
        }
      ],
      "totalCount": 1
    }
  }
}

Path Params

projectId
string
required
issueUid
string
required

Response

Edit Comment Text

Replaces the text of an issue with new text. Note that only the author of the issue can perform this action. The commentTextModifiedDate property of an issue object shows when it was last updated.

Comment text is treated as plain text. Smartling will save the text as provided and will not attempt to render this text with any special formatting in its UIs; it will not be rendered as HTML or markdown. Consumers of the issue API should be aware and escape the text as needed before attempting to render it. Maximum length is 4000 characters.
 
posthttps://api.smartling.com/issues-api/v2/projects/projectId/issues/issueUid/comments/issueCommentUid
curl --request POST \
  --url https://api.smartling.com/issues-api/v2/projects/projectId/issues/issueUid/comments/issueCommentUid
var request = require("request");

var options = { method: 'POST',
  url: 'https://api.smartling.com/issues-api/v2/projects/projectId/issues/issueUid/comments/issueCommentUid' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/issues-api/v2/projects/projectId/issues/issueUid/comments/issueCommentUid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.smartling.com/issues-api/v2/projects/projectId/issues/issueUid/comments/issueCommentUid");

xhr.send(data);
import requests

url = "https://api.smartling.com/issues-api/v2/projects/projectId/issues/issueUid/comments/issueCommentUid"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": {
      "issueCommentUid": "a75fea779bbb",
      "commentText": "comment text",
      "createdByUserUid": "661801f19693",
      "createdDate": "2015-12-22T12:34:49Z",
      "commentTextModifiedDate": "2016-12-22T12:34:49Z"
    }
  }
}

Path Params

projectId
string
required
issueUid
string
required
issueCommentUid
string
required

Body Params

commentText
string
required

Text of the comment you want to make.

Response

Get Comment Details

Returns detailed information on a single issue comment. Note that the createdByUserUid value is not currently usable for identifying the users who created comments. In future, a People API will be exposed for looking up user details.

 
gethttps://api.smartling.com/issues-api/v2/projects/projectId/issues/issueUid/comments/issueCommentUid
curl --request GET \
  --url https://api.smartling.com/issues-api/v2/projects/projectId/issues/issueUid/comments/issueCommentUid
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.smartling.com/issues-api/v2/projects/projectId/issues/issueUid/comments/issueCommentUid' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/issues-api/v2/projects/projectId/issues/issueUid/comments/issueCommentUid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.smartling.com/issues-api/v2/projects/projectId/issues/issueUid/comments/issueCommentUid");

xhr.send(data);
import requests

url = "https://api.smartling.com/issues-api/v2/projects/projectId/issues/issueUid/comments/issueCommentUid"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": {
      "createdByUserUid": "661801f19693",
      "createdDate": "2015-12-22T11:54:27Z",
      "commentText": "test comment",
      "issueCommentUid": "ac5211a26eca",
      "commentTextModifiedDate": null
    }
  }
}

Path Params

projectId
string
required
issueUid
string
required
issueCommentUid
string
required

Response

Find Issues

Returns a list of issues matching specified filter options. You can filter based on the date issues were created, target languages, strings, issue types and states and the user who opened the issue. Unless otherwise specified, request will return a maximum of 30 results. All parameters are optional.

 
posthttps://api.smartling.com/issues-api/v2/projects/projectId/issues/list
curl --request POST \
  --url https://api.smartling.com/issues-api/v2/projects/projectId/issues/list
var request = require("request");

var options = { method: 'POST',
  url: 'https://api.smartling.com/issues-api/v2/projects/projectId/issues/list' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/issues-api/v2/projects/projectId/issues/list")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.smartling.com/issues-api/v2/projects/projectId/issues/list");

xhr.send(data);
import requests

url = "https://api.smartling.com/issues-api/v2/projects/projectId/issues/list"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": {
      "items": [
        {
          "string": {
            "hashcode": "c32c16cddafd63dfa0dc12449372a093",
            "localeId": "ru-RU"
          },
          "resolvedByUserUid": null,
          "reportedByUserUid": "661801f19693",
          "createdDate": "2015-12-21T16:38:48Z",
          "resolvedDate": null,
          "issueText": "does not fit space",
          "issueUid": "902372ac8e1e",
          "projectId": "e8fa915fa",
          "issueTypeCode": "TRANSLATION",
          "issueSubTypeCode": "DOES_NOT_FIT_SPACE",
          "issueStateCode": "OPENED",
          "issueTextModifiedDate": null
        }
      ],
      "totalCount": 1
    }
  }
}

Path Params

projectId
string
required

Body Params

createdDateBefore
string
createdDateAfter
string
resolvedDateBefore
string
resolvedDateAfter
string
stringFilter
object
 
stringFilter.hashcodes
array of strings
stringFilter.localeIds
array of strings
sortBy
object
 
sortBy.items
array of objects
direction
fieldName
limit
integer
offset
integer
reportedByUserUid
string
issueStateCodes
array of strings
issueTypeCodes
array of strings
issueSubTypeCodes
array of strings

Response

Count Issues

Returns a count of issues matching specified filter options. You can filter based on the date issues were created, strings, target languages, issue types and states and the user who opened the issue.. All parameters are optional.

 
posthttps://api.smartling.com/issues-api/v2/projects/projectId/issues/count
curl --request POST \
  --url https://api.smartling.com/issues-api/v2/projects/projectId/issues/count
var request = require("request");

var options = { method: 'POST',
  url: 'https://api.smartling.com/issues-api/v2/projects/projectId/issues/count' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/issues-api/v2/projects/projectId/issues/count")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.smartling.com/issues-api/v2/projects/projectId/issues/count");

xhr.send(data);
import requests

url = "https://api.smartling.com/issues-api/v2/projects/projectId/issues/count"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": {
      "count": 2
    }
  }
}

Path Params

projectId
string
required

Body Params

createdDateBefore
string
createdDateAfter
string
resolvedDateBefore
string
resolvedDateAfter
string
stringFilter
object
 
stringFilter.hashcodes
array of strings
stringFilter.localeIds
array of strings
reportedByUserUid
string
issueStateCodes
array of strings
issueTypeCodes
array of strings
issueSubTypeCodes
array of strings

Response

Upload

 

Upload a file

Upload original source content to Smartling

Example

  curl -X POST -H "Authorization: Bearer {token}" -F "file=@file.properties;type=text/plain" -F "fileUri=file.properties"  -F "fileType=javaProperties" 'https://api.smartling.com/files-api/v2/projects/{projectId}/file'
 
posthttps://api.smartling.com/files-api/v2/projects/projectId/file
curl --request POST \
  --url https://api.smartling.com/files-api/v2/projects/projectId/file
var request = require("request");

var options = { method: 'POST',
  url: 'https://api.smartling.com/files-api/v2/projects/projectId/file' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/files-api/v2/projects/projectId/file")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.smartling.com/files-api/v2/projects/projectId/file");

xhr.send(data);
import requests

url = "https://api.smartling.com/files-api/v2/projects/projectId/file"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": {
      "overWritten": true,
      "stringCount": 10,
      "wordCount": 2
    }
  }
}
{
  "response": {
    "code": "SUCCESS",
    "data": {
      "message": "Your file was successfully uploaded. Word and string counts are not available right now."
    }
  }
}
{
  "response": {
    "code": "VALIDATION_ERROR",
    "errors": {
      "key": "unknown.field",
      "message": "The field unknown.parameter was not expected. Please consult the documentation to verify the fields you are submitting.",
      "details": "unknown.parameter"
    }
  }
}
{
  "response": {
    "code": "RESOURCE_LOCKED",
    "errors": {
      "key": "resource.locked",
      "message": "The file is currently being processed and will be available in a few minutes."
    }
  }
}
{
  "response": {
    "code": "MAX_OPERATIONS_LIMIT_EXCEEDED",
    "errors": {
      "key": "too.many.requests",
      "message": "The limit of 10 concurrent Smartling file API operations for this project has been exceeded."
    }
  }
}

Path Params

projectId
uid
required

Form Data

file
file
required

The file contents to upload

fileUri
string
required

Value that uniquely identifies the uploaded file. This ID can be used to request the file back. We recommend you use file path + file name, similar to how version control systems identify the file. Example: /myproject/i18n/ui.properties

fileType
string
required

Unique identifier for the file type

authorize
boolean

Determines whether content in the file is authorized (available for translation) in all locales upon submitting the file via the Smartling Dashboard. An error message will return if there are insufficient translation funds and authorized is set to true. If a string has been completely excluded for translation from all languages, or excluded from translation for a specific language, authorize will NOT authorize it. Note: to specify a limited list of locales to authorize, use the localeIdsToAuthorize[] parameter

Value Description
true Content will be available for translation in all locales on upload
false Content will be added to the "Awaiting Authorization" queue on upload
localeIdsToAuthorize[]
array of strings

This value, if set, authorizes strings for translation into specific locales. Use the project/locale/list call to get the list of locales for the project or see them in the dashboard on the API settings page. Use multiple localeIdsToAuthorize parameter pairs to authorize more than one locale. You can add languages by uploading the file again and indicating the language to authorize with localeIdsToAuthorize or all languages with authorize, or in the dashboard using the "Show Partially Authorized" filter option from the Awaiting Authorization list. If string has been completely excluded for translation from all languages, or excluded from translation for a specific language, localesIdsToAuthorize will NOT authorize it. Note: Do not set the authorize parameter to TRUE if you want to specify individual locales to authorize. Submitting an upload with both of these parameters set will result in a validation error.

smartling.namespace
string

For accounts created after July 31st 2015 only. Define a custom namespace for the file. This works for Application Resource Files only. For Business Documents, see Update File. Note: while this parameter shares the format of other file directives, it will not work as an inline directive and must be specified in the API call.

smartling.file_charset
string

Specifies a custom charset for text-format files. The value should be the name of the character set. See a full list of supported character sets here.

If this directive is not used, Smartling will use the Content-Type request header to determine if the content is encoded with UTF-16, UTF-16B or UTF-16LE. If there is no Content-Type header, Smartling will examine the file for UTF-16 characters. If none are detected, UTF-8 encoding will be used.

Note: Once this property has been set for a file, it cannot be changed. If you reupload the file, it will use the original charset, even if you change the directive. An error will be returned if this directive is used when uploading binary-format file types, such as Office or IDML files.

smartling.[command]
string

Provides custom parser configuration for supported file types. See Supported File Types for more details.

callbackUrl
url

A GET request that creates a callback to a URL when a file is 100% published for a locale. The callback gives the fileUri and locale with the format http[/s]://your.url?locale=xx-XX&fileUri=your.file. If you upload the file again, without a callbackUrl, it will remove any previous callbackUrl for that file. The RequestBin (http://requestb.in) service is a convenient way to test callback. RequestBin generates a short-lived disposable URL that displays all posted requests.

If a callback fails, Smartling will make multiple attempts to reach the designated URL, however, we do not keep retrying a failed callback indefinitely. Try to make sure your callback URL is as stable as possible and be aware that callbacks are not a 100% reliable way of being notified that a file is published.

Response

Files API Upload success response

If the upload has begun but is taking more than a minute to complete

codestring
dataobject
data.messagestring

If something specific was wrong with the request parameters provided.

responseobject
response.codestring
response.errorsarray

Provided credentials were not valid.

responseobject
response.codestring
response.errorsarray

The requested file is currently being processed by another operation. The file will be unlocked after the operation completes.

responseobject
response.codestring
response.errorsarray

Too many simultaneous API requests per project or file.

responseobject
response.codestring
response.errorsarray

Error

responseobject
response.codestring
response.errorsarray

Download

 

Download original file

Download the original version of the requested file from Smartling

Example

  curl -H "Authorization: Bearer {token}" "https://api.smartling.com/files-api/v2/projects/{projectId}/file?fileUri={your-file-URI}"

It is important to check the HTTP response status code. If Smartling finds and returns the file normally, you will receive a 200 SUCCESS response. If you receive any other response status code than 200, the requested file will not be part of the response.

When you upload a UTF-16 character encoded file, then /file/get requests for that file will have a character encoding of UTF-16. All other uploaded files will return with a character encoding of UTF-8.

You can always use the content-type header in the response of a file/get request to determine the character encoding.

The filename is based on the fileUri associated with the requested file. In most cases, the filename is exactly the fileUri provided. The only exception to this is with .pot gettext files. When a .pot file is specified as the fileUri, Smartling returns a .po file.

 
gethttps://api.smartling.com/files-api/v2/projects/projectId/file
curl --request GET \
  --url 'https://api.smartling.com/files-api/v2/projects/projectId/file?fileUri=fileUri'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.smartling.com/files-api/v2/projects/projectId/file',
  qs: { fileUri: 'fileUri' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/files-api/v2/projects/projectId/file?fileUri=fileUri")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.smartling.com/files-api/v2/projects/projectId/file?fileUri=fileUri");

xhr.send(data);
import requests

url = "https://api.smartling.com/files-api/v2/projects/projectId/file"

querystring = {"fileUri":"fileUri"}

response = requests.request("GET", url, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

projectId
string
required

Query Params

fileUri
string
required

Value that uniquely identifies the downloaded file

Response

Download original file

Error

responseobject
response.codestring
response.errorsarray

Download translated file from Smartling

Download the requested file from Smartling

It is important to check the HTTP response status code. If Smartling finds and returns the file normally, you will receive a 200 SUCCESS response. If you receive any other response status code than 200, the requested file will not be part of the response.

When you upload a UTF-16 character encoded file, then /file/get requests for that file will have a character encoding of UTF-16. All other uploaded files will return with a character encoding of UTF-8.

You can always use the content-type header in the response of a file/get request to determine the character encoding.

Example

  curl -H "Authorization: Bearer {token}" "https://api.smartling.com/files-api/v2/projects/{projectId}/locales/{localeId}/file?fileUri={your-file-Uri}"
 
gethttps://api.smartling.com/files-api/v2/projects/projectId/locales/localeId/file
curl --request GET \
  --url 'https://api.smartling.com/files-api/v2/projects/projectId/locales/localeId/file?fileUri=fileUri'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.smartling.com/files-api/v2/projects/projectId/locales/localeId/file',
  qs: { fileUri: 'fileUri' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/files-api/v2/projects/projectId/locales/localeId/file?fileUri=fileUri")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.smartling.com/files-api/v2/projects/projectId/locales/localeId/file?fileUri=fileUri");

xhr.send(data);
import requests

url = "https://api.smartling.com/files-api/v2/projects/projectId/locales/localeId/file"

querystring = {"fileUri":"fileUri"}

response = requests.request("GET", url, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

projectId
string
required
localeId
string
required

Query Params

fileUri
string
required

Value that uniquely identifies the downloaded file

retrievalType
string

Determines the desired format for the download. Applies to translated files only.

retrievalType Description
pending Smartling returns any translations (including non-published translations)
published Smartling returns only published/pre-published translations.
pseudo Smartling returns a modified version of the original text with certain characters transformed and the text expanded. For example, the uploaded string "This is a sample string", will return as "T~hís ~ís á s~ámpl~é str~íñg". Pseudo translations enable you to test how a longer string integrates into your application
contextMatchingInstrumented Smartling returns a modified version of the original file with strings wrapped in a specific set of Unicode symbols that can later be recognized and matched by the Chrome Context Capture Extension
includeOriginalStrings
boolean

Specifies whether Smartling will return the original string or an empty string where no translation is available. This parameter is supported for gettext, java properties, custom XML, and JSON files only

Value Description
true If there is no translation, Smartling returns the original string
false If there is no translation, Smartling returns an empty string

Response

Download file translated to specified locale **Note**: The filename in response is based on the fileUri associated with the requested file. In most cases, the filename is exactly the fileUri provided. The only exception to this is with .pot gettext files. When a .pot file is specified as the fileUri, Smartling returns a .po file

Error

responseobject
response.codestring
response.errorsarray

Download translated files from Smartling as a ZIP

Download the requested translated files from Smartling as a ZIP

It is important to check the HTTP response status code. If Smartling finds and returns the file normally, you will receive a 200 SUCCESS response. If you receive any other response status code than 200, the requested files will not be part of the response.

When you upload a UTF-16 character encoded file, then /file/get requests for that file will have a character encoding of UTF-16. All other uploaded files will return with a character encoding of UTF-8.

You can always use the content-type header in the response of a file/get request to determine the character encoding.

Example

  curl -X GET -H "Authorization: Bearer {token}" 'https://api.smartling.com/files-api/v2/projects/{projectId}/files/zip?localeIds[]=de-DE&fileUris[]=yourfile.json'
 
gethttps://api.smartling.com/files-api/v2/projects/projectId/files/zip
curl --request GET \
  --url 'https://api.smartling.com/files-api/v2/projects/projectId/files/zip?fileUris%5B%5D=fileUris%5B%5D&localeIds%5B%5D=localeIds%5B%5D'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.smartling.com/files-api/v2/projects/projectId/files/zip',
  qs: 
   { 'fileUris[]': 'fileUris[]',
     'localeIds[]': 'localeIds[]' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/files-api/v2/projects/projectId/files/zip?fileUris%5B%5D=fileUris%5B%5D&localeIds%5B%5D=localeIds%5B%5D")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.smartling.com/files-api/v2/projects/projectId/files/zip?fileUris%5B%5D=fileUris%5B%5D&localeIds%5B%5D=localeIds%5B%5D");

xhr.send(data);
import requests

url = "https://api.smartling.com/files-api/v2/projects/projectId/files/zip"

querystring = {"fileUris[]":"fileUris[]","localeIds[]":"localeIds[]"}

response = requests.request("GET", url, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

projectId
string
required

Query Params

fileUris[]
array of strings
required

Smartling Values that each uniquely identify a file

localeIds[]
array of strings
required

List of locales to download

retrievalType
string

Determines the desired format for the download. Applies to translated files only.

retrievalType Description
pending Smartling returns any translations (including non-published translations)
published Smartling returns only published/pre-published translations.
pseudo Smartling returns a modified version of the original text with certain characters transformed and the text expanded. For example, the uploaded string "This is a sample string", will return as "T~hís ~ís á s~ámpl~é str~íñg". Pseudo translations enable you to test how a longer string integrates into your application
contextMatchingInstrumented Smartling returns a modified version of the original file with strings wrapped in a specific set of Unicode symbols that can later be recognized and matched by the Chrome Context Capture Extension
includeOriginalStrings
boolean

Specifies whether Smartling will return the original string or an empty string where no translation is available. This parameter is supported for gettext, java properties, custom XML, and JSON files only

Value Description
true If there is no translation, Smartling returns the original string
false If there is no translation, Smartling returns an empty string
fileNameMode
string

Determines how files in the zip file will be named. If not set, the full original file path will be used as the filename

fileNameMode Description
UNCHANGED Full original file path is used
TRIM_LEADING Remove all except the last path segment. e.g. /en/strings/nav.properties becomes nav.properties
LOCALE_LAST Adds a locale folder to the file path directly before the filename. e.g. /strings/nav.properties becomes /strings/en/nav.properties
localeMode
string

Determines how locales will be handled in the downloaded zip

localeMode Description
LOCALE_IN_PATH Locale code is added to the end of the file path. e.g. /strings/es-ES/nav.properties
LOCALE_IN_NAME Locale code is added to the end of the file name e.g. /strings/nav_es-ES.properties
LOCALE_IN_NAME_AND_PATH Locale code is added to both the path and the filename. e.g. /strings/es-ES/nav_es-ES.properties
zipFileName
string

Name for the downloaded zip file. If unset, default is translations.zip

Response

Error

responseobject
response.codestring
response.errorsarray

List

 

List Files

List recently uploaded files

Returns a maximum of 500 files.

Example

  curl -H "Authorization: Bearer {token}" "https://api.smartling.com/files-api/v2/projects/{projectId}/files/list?fileTypes[]=json&uriMask=strings"
 
gethttps://api.smartling.com/files-api/v2/projects/projectId/files/list
curl --request GET \
  --url https://api.smartling.com/files-api/v2/projects/projectId/files/list
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.smartling.com/files-api/v2/projects/projectId/files/list' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/files-api/v2/projects/projectId/files/list")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.smartling.com/files-api/v2/projects/projectId/files/list");

xhr.send(data);
import requests

url = "https://api.smartling.com/files-api/v2/projects/projectId/files/list"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": {
      "totalCount": 2,
      "items": [
        {
          "fileUri": "/files/translation_import.csv",
          "created": "2017-09-06T20:29:15Z",
          "lastUploaded": "2017-09-06T20:29:15Z",
          "fileType": "csv",
          "hasInstructions": false
        },
        {
          "fileUri": "/files/4.properties",
          "created": "2017-05-27T12:45:36Z",
          "lastUploaded": "2017-05-27T12:45:36Z",
          "fileType": "javaProperties",
          "hasInstructions": false
        }
      ]
    }
  }
}

Path Params

projectId
string
required

Query Params

uriMask
string

Return only files with a URI containing the given substring. Case is ignored. For example, the value .json will match strings.json and STRINGS.JSON but not json.strings

fileTypes[]
array of strings
lastUploadedAfter
YYYY-MM-DDThh:mm:ssZ

Return all files uploaded after the specified date

lastUploadedBefore
YYYY-MM-DDThh:mm:ssZ

Return all files uploaded before the specified date

orderBy
string

Sets the name and direction of the parameter to order results by. If ascending or descending is not specified, the default is ascending

limit
integer

See Limit and Offset. In order to get consistent pagination, please make sure to specify the orderBy parameter

offset
integer

Response

Error

responseobject
response.codestring
response.errorsarray

List File Types

Return a list of all file types currently represented in the project

 
gethttps://api.smartling.com/files-api/v2/projects/projectId/file-types
curl --request GET \
  --url https://api.smartling.com/files-api/v2/projects/projectId/file-types
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.smartling.com/files-api/v2/projects/projectId/file-types' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/files-api/v2/projects/projectId/file-types")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.smartling.com/files-api/v2/projects/projectId/file-types");

xhr.send(data);
import requests

url = "https://api.smartling.com/files-api/v2/projects/projectId/file-types"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": {
      "items": [
        "csv",
        "javaProperties"
      ]
    }
  }
}

Path Params

projectId
string
required

Response

Error

responseobject
response.codestring
response.errorsarray

Status

 

Status - All Locales

Return information on a specific file

Example

  curl -X GET -H "Authorization: Bearer {token}" 'https://api.smartling.com/files-api/v2/projects/{projectId}/file/status?fileUri=file.properties'
 
gethttps://api.smartling.com/files-api/v2/projects/projectId/file/status
curl --request GET \
  --url 'https://api.smartling.com/files-api/v2/projects/projectId/file/status?fileUri=fileUri'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.smartling.com/files-api/v2/projects/projectId/file/status',
  qs: { fileUri: 'fileUri' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/files-api/v2/projects/projectId/file/status?fileUri=fileUri")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.smartling.com/files-api/v2/projects/projectId/file/status?fileUri=fileUri");

xhr.send(data);
import requests

url = "https://api.smartling.com/files-api/v2/projects/projectId/file/status"

querystring = {"fileUri":"fileUri"}

response = requests.request("GET", url, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": {
      "fileUri": "/files/test_translation_import.csv",
      "lastUploaded": "2017-09-06T20:29:15Z",
      "created": "2017-09-06T20:29:15Z",
      "fileType": "csv",
      "parserVersion": 4,
      "hasInstructions": false,
      "directives": {
        "file_uri_as_namespace": "true"
      },
      "namespace": {
        "name": "/files/test_trans_import.csv"
      },
      "totalStringCount": 1,
      "totalWordCount": 1,
      "totalCount": 1,
      "items": [
        {
          "localeId": "ru-RU",
          "authorizedStringCount": 0,
          "authorizedWordCount": 0,
          "completedStringCount": 0,
          "completedWordCount": 0,
          "excludedStringCount": 0,
          "excludedWordCount": 0
        }
      ]
    }
  }
}

Path Params

projectId
string
required

Query Params

fileUri
string
required

Smartling value that uniquely identifies a file in Smartling

Response

Error

responseobject
response.codestring
response.errorsarray

Status - Single Locale / Extended Response

Return detailed status information on a specific file

Example

  curl -X GET -H "Authorization: Bearer {token}" 'https://api.smartling.com/files-api/v2/projects/{projectId}/locales/{localeId}/file/status?fileUri=file.properties'
 
gethttps://api.smartling.com/files-api/v2/projects/projectId/locales/localeId/file/status
curl --request GET \
  --url 'https://api.smartling.com/files-api/v2/projects/projectId/locales/localeId/file/status?fileUri=fileUri'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.smartling.com/files-api/v2/projects/projectId/locales/localeId/file/status',
  qs: { fileUri: 'fileUri' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/files-api/v2/projects/projectId/locales/localeId/file/status?fileUri=fileUri")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.smartling.com/files-api/v2/projects/projectId/locales/localeId/file/status?fileUri=fileUri");

xhr.send(data);
import requests

url = "https://api.smartling.com/files-api/v2/projects/projectId/locales/localeId/file/status"

querystring = {"fileUri":"fileUri"}

response = requests.request("GET", url, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": {
      "fileUri": "/files/4.properties",
      "lastUploaded": "2017-05-27T12:45:36Z",
      "created": "2017-05-27T12:45:36Z",
      "fileType": "javaProperties",
      "parserVersion": 4,
      "hasInstructions": false,
      "directives": null,
      "namespace": null,
      "totalStringCount": 5,
      "totalWordCount": 9,
      "authorizedStringCount": 4,
      "authorizedWordCount": 5,
      "completedStringCount": 0,
      "completedWordCount": 0,
      "excludedStringCount": 0,
      "excludedWordCount": 0
    }
  }
}

Path Params

projectId
string
required
localeId
string
required

Query Params

fileUri
string
required

Smartling value that uniquely identifies a file in Smartling

Response

Error

responseobject
response.codestring
response.errorsarray

Rename

 

Rename

Rename an uploaded file by changing the fileUri. After renaming the file, the file will only be identified by the new fileUri you provide

Example

  curl -X POST -H "Authorization: Bearer {token}" -F "fileUri=filename.properties" -F "newFileUri=filename2.properties" 'https://api.smartling.com/files-api/v2/projects/{projectId}/file/rename'
 
posthttps://api.smartling.com/files-api/v2/projects/projectId/file/rename
curl --request POST \
  --url https://api.smartling.com/files-api/v2/projects/projectId/file/rename
var request = require("request");

var options = { method: 'POST',
  url: 'https://api.smartling.com/files-api/v2/projects/projectId/file/rename' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/files-api/v2/projects/projectId/file/rename")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.smartling.com/files-api/v2/projects/projectId/file/rename");

xhr.send(data);
import requests

url = "https://api.smartling.com/files-api/v2/projects/projectId/file/rename"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": null
  }
}

Path Params

projectId
string
required

Form Data

fileUri
string
required

Current value that uniquely identifies the file

newFileUri
string
required

The new value for fileUri. We recommend that you use file path + file name, similar to how version control systems identify the file. Example: /myproject/i18n/ui.properties. This must be a fileUri that does not exist in the current Smartling project.

Response

Error

responseobject
response.codestring
response.errorsarray

Delete

 

Delete

Remove the file from Smartling. The file will no longer be available for download. Any complete translations for the file remain available for use within the system.

Smartling deletes files asynchronously and it typically takes a few minutes to complete. While deleting a file, you can not upload a file with the same fileUri.

Example

  curl -X POST -H "Authorization: Bearer {token}" -F "fileUri=filename.properties" 'https://api.smartling.com/files-api/v2/projects/{projectId}/file/delete'
 
posthttps://api.smartling.com/files-api/v2/projects/projectId/file/delete
curl --request POST \
  --url https://api.smartling.com/files-api/v2/projects/projectId/file/delete
var request = require("request");

var options = { method: 'POST',
  url: 'https://api.smartling.com/files-api/v2/projects/projectId/file/delete' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/files-api/v2/projects/projectId/file/delete")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.smartling.com/files-api/v2/projects/projectId/file/delete");

xhr.send(data);
import requests

url = "https://api.smartling.com/files-api/v2/projects/projectId/file/delete"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": null
  }
}

Path Params

projectId
string
required

Form Data

fileUri
string
required

Smartling value that uniquely identifies a file in Smartling

Response

Error

responseobject
response.codestring
response.errorsarray

Last Modified

 

Last Modified by locale

Return the date a file was last modified in a specified locale

Example

  curl -X GET -H "Authorization: Bearer {token}" 'https://api.smartling.com/files-api/v2/projects/{projectId}/locales/{localeId}/file/last-modified?fileUri=filename.properties'
 
gethttps://api.smartling.com/files-api/v2/projects/projectId/locales/localeId/file/last-modified
curl --request GET \
  --url 'https://api.smartling.com/files-api/v2/projects/projectId/locales/localeId/file/last-modified?fileUri=fileUri'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.smartling.com/files-api/v2/projects/projectId/locales/localeId/file/last-modified',
  qs: { fileUri: 'fileUri' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/files-api/v2/projects/projectId/locales/localeId/file/last-modified?fileUri=fileUri")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.smartling.com/files-api/v2/projects/projectId/locales/localeId/file/last-modified?fileUri=fileUri");

xhr.send(data);
import requests

url = "https://api.smartling.com/files-api/v2/projects/projectId/locales/localeId/file/last-modified"

querystring = {"fileUri":"fileUri"}

response = requests.request("GET", url, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": {
      "localeId": "ru-RU",
      "lastModified": "2017-09-06T20:25:18Z"
    }
  }
}

Path Params

projectId
string
required
localeId
string
required

Query Params

fileUri
string
required

Smartling value that uniquely identifies a file in Smartling

lastModifiedAfter
YYYY-MM-DDThh:mm:ssZ

Limits the return to only those file and locale combinations that have a lastModified date after the parameter lastModifiedAfter. The items array will be empty if the file has not been modified in any of the locales since the lastModifiedAfter date specified.

Response

Error

responseobject
response.codestring
response.errorsarray

Last Modified - all locales

Return the date a file was last modified in a each locale

Example

  curl -X GET -H "Authorization: Bearer {token}" 'https://api.smartling.com/files-api/v2/projects/{projectId}/file/last-modified?fileUri=filename.properties'
 
gethttps://api.smartling.com/files-api/v2/projects/projectId/file/last-modified
curl --request GET \
  --url 'https://api.smartling.com/files-api/v2/projects/projectId/file/last-modified?fileUri=fileUri'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.smartling.com/files-api/v2/projects/projectId/file/last-modified',
  qs: { fileUri: 'fileUri' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/files-api/v2/projects/projectId/file/last-modified?fileUri=fileUri")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.smartling.com/files-api/v2/projects/projectId/file/last-modified?fileUri=fileUri");

xhr.send(data);
import requests

url = "https://api.smartling.com/files-api/v2/projects/projectId/file/last-modified"

querystring = {"fileUri":"fileUri"}

response = requests.request("GET", url, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": {
      "totalCount": 1,
      "items": [
        {
          "localeId": "ru-RU",
          "lastModified": "2017-09-06T20:25:18Z"
        }
      ]
    }
  }
}

Path Params

projectId
string
required

Query Params

fileUri
string
required

Smartling value that uniquely identifies a file in Smartling

lastModifiedAfter
YYYY-MM-DDThh:mm:ssZ

Limits the return to only those file and locale combinations that have a lastModified date after the parameter lastModifiedAfter. The items array will be empty if the file has not been modified in any of the locales since the lastModifiedAfter date specified.

Response

Error

responseobject
response.codestring
response.errorsarray

Import

 

Import Translations

Example

  curl -X POST -H "Authorization: Bearer {token}" -F "file=@filename.properties" -F 'fileUri=filename.properties' -f fileType=javaProperties -F translationState=PUBLISHED 'https://api.smartling.com/files-api/v2/projects/{projectId}/locales/{localeId}/file/import'
 
posthttps://api.smartling.com/files-api/v2/projects/projectId/locales/localeId/file/import
curl --request POST \
  --url https://api.smartling.com/files-api/v2/projects/projectId/locales/localeId/file/import
var request = require("request");

var options = { method: 'POST',
  url: 'https://api.smartling.com/files-api/v2/projects/projectId/locales/localeId/file/import' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/files-api/v2/projects/projectId/locales/localeId/file/import")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.smartling.com/files-api/v2/projects/projectId/locales/localeId/file/import");

xhr.send(data);
import requests

url = "https://api.smartling.com/files-api/v2/projects/projectId/locales/localeId/file/import"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": {
      "wordCount": 6,
      "stringCount": 3,
      "translationImportErrors": []
    }
  }
}

Path Params

projectId
string
required
localeId
string
required

Form Data

file
file
required

The file contents to upload

fileUri
string
required

The Smartling URI for file that contains the original language strings already uploaded to Smartling

fileType
string
required

Unique identifier for the file type. To allow translation imports, XML and JSON files must be uploaded with source_key_paths defined

translationState
string
required

Value indicating the workflow state to import the translations into. Content will be imported into the language's default workflow

Value Description
PUBLISHED The translated content is published
POST_TRANSLATION The translated content is imported into the first step after translation - if there are none, it will be published
overwrite
boolean

Whether or not to overwrite existing translations

Response

Error

responseobject
response.codestring
response.errorsarray

Get Translations

Temporarily uploads a file, then returns a translated version for requested locales.

This call can be used instead of a standard upload/download if you keep different versions of a file in multiple branches or are triggering rebuilds, and don’t want your files in Smartling to be overwritten by out-of-date versions of a file.

To use the call, you upload a file and identify the Smartling URI where the main version of that file is saved. Smartling will match strings shared between the uploaded file and the main file and return any available translations.

Example

  curl -X POST -H "Authorization: Bearer {token}" -F "file=@filename.properties" -F 'fileUri=filename.properties' 'https://api.smartling.com/files-api/v2/projects/{projectId}/locales/{localeId}/file/get-translations'
 
posthttps://api.smartling.com/files-api/v2/projects/projectId/locales/localeId/file/get-translations
curl --request POST \
  --url https://api.smartling.com/files-api/v2/projects/projectId/locales/localeId/file/get-translations
var request = require("request");

var options = { method: 'POST',
  url: 'https://api.smartling.com/files-api/v2/projects/projectId/locales/localeId/file/get-translations' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/files-api/v2/projects/projectId/locales/localeId/file/get-translations")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.smartling.com/files-api/v2/projects/projectId/locales/localeId/file/get-translations");

xhr.send(data);
import requests

url = "https://api.smartling.com/files-api/v2/projects/projectId/locales/localeId/file/get-translations"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

projectId
string
required
localeId
string
required

Form Data

file
file
required

The file contents to upload

fileUri
string
required

The Smartling URI for file that contains the original language strings already uploaded to Smartling

retrievalType
string

Determines the desired format for the download. Applies to translated files only.

retrievalType Description
pending Smartling returns any translations (including non-published translations)
published Smartling returns only published/pre-published translations.
pseudo Smartling returns a modified version of the original text with certain characters transformed and the text expanded. For example, the uploaded string "This is a sample string", will return as "T~hís ~ís á s~ámpl~é str~íñg". Pseudo translations enable you to test how a longer string integrates into your application
contextMatchingInstrumented Smartling returns a modified version of the original file with strings wrapped in a specific set of Unicode symbols that can later be recognized and matched by the Chrome Context Capture Extension
includeOriginalStrings
boolean

Specifies whether Smartling will return the original string or an empty string where no translation is available. This parameter is supported for gettext, java properties, custom XML, and JSON files only

Value Description
true If there is no translation, Smartling returns the original string
false If there is no translation, Smartling returns an empty string

Response

Error

responseobject
response.codestring
response.errorsarray

Job

 

List Jobs

List / Search jobs within a project.

 

Header Auth

 Authentication is required for this endpoint.
gethttps://api.smartling.com/jobs-api/v3/projects/projectId/jobs
curl --request GET \
  --url https://api.smartling.com/jobs-api/v3/projects/projectId/jobs
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.smartling.com/jobs-api/v3/projects/projectId/jobs' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/jobs-api/v3/projects/projectId/jobs")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.smartling.com/jobs-api/v3/projects/projectId/jobs");

xhr.send(data);
import requests

url = "https://api.smartling.com/jobs-api/v3/projects/projectId/jobs"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": {
      "totalCount": 2,
      "items": [
        {
          "translationJobUid": "abc123abc",
          "jobName": "myJobName",
          "targetLocaleIds": [
            "fr-FR",
            "es"
          ],
          "description": "my job description",
          "dueDate": "2015-11-21T11:51:17Z",
          "referenceNumber": "myReferenceNumber1",
          "createdDate": "2015-11-21T11:51:17Z",
          "jobStatus": "IN_PROGRESS"
        },
        {
          "translationJobUid": "abc321xyz",
          "jobName": "myJobName",
          "targetLocaleIds": [
            "fr-FR",
            "de"
          ],
          "description": "my job description",
          "dueDate": "2015-11-21T11:51:17Z",
          "referenceNumber": "myReferenceNumber1",
          "createdDate": "2015-11-21T11:51:17Z",
          "jobStatus": "IN_PROGRESS"
        }
      ]
    }
  }
}

Path Params

projectId
string
required

Query Params

jobName
string

Param used for searching for jobs by jobName. Any entry is treated as a LIKE query on the name of the job.

translationJobUids
array of strings

Param used for searching for jobs by translationJobUid. Supports up to 500 translationJobUids.

translationJobStatus
array of strings

Param used for searching for jobs by jobStatus.

limit
integer

The limit on the number of jobs returned.

offset
integer

The offset to use when searching for jobs.

sortBy
string

The field to sort by.

sortDirection
string

The direction fo sort.

Response

OK

Create Job

Creates a job within Smartling.

 

Header Auth

 Authentication is required for this endpoint.
posthttps://api.smartling.com/jobs-api/v3/projects/projectId/jobs
curl --request POST \
  --url https://api.smartling.com/jobs-api/v3/projects/projectId/jobs
var request = require("request");

var options = { method: 'POST',
  url: 'https://api.smartling.com/jobs-api/v3/projects/projectId/jobs' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/jobs-api/v3/projects/projectId/jobs")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.smartling.com/jobs-api/v3/projects/projectId/jobs");

xhr.send(data);
import requests

url = "https://api.smartling.com/jobs-api/v3/projects/projectId/jobs"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": {
      "translationJobUid": "abc123abc",
      "jobName": "myJobName",
      "targetLocaleIds": [
        "fr-FR"
      ],
      "description": "my job description",
      "dueDate": "2015-11-21T11:51:17Z",
      "referenceNumber": "myReferenceNumber1",
      "callbackUrl": "https://www.callback.com/smartling/job",
      "callbackMethod": "GET|POST",
      "createdDate": "2015-11-21T11:51:17Z",
      "modifiedDate": "2015-11-21T11:51:17Z",
      "createdByUserUid": "userUid123abc",
      "modifiedByUserUid": "userUid321abc",
      "jobStatus": "IN_PROGRESS",
      "firstCompletedDate": "2015-11-21T11:51:17Z",
      "lastCompletedDate": "2015-11-21T11:51:17Z"
    }
  }
}
{
  "response": {
    "code": "VALIDATION_ERROR",
    "errors": [
      {
        "key": null
      }
    ],
    "message": "There is already a job with that name. Please provide a unique name.",
    "details": {
      "field": "jobName"
    }
  }
}

Path Params

projectId
uuid
required

Body Params

jobName
string

The name of the job to create. The name of the job must be unique within the Smartling project. jobName is required.

targetLocaleIds
array of strings

The array of localeId's to be used when creating the job. The locale\'s specified must be valid within the Smartling project.

description
string

The description of the job. The description is limited to 2,000 characters.

dueDate
date-time

The date the job is requested to be completed by.

referenceNumber
string

Customer specific number/identifier for the job.

callbackUrl
string

The URL for Smartling to invoke when the job is completed.

callbackMethod
string

The http method to call (GET|POST) when invoking the callbackUrl.

Response

Response after successfully creating a job.

Validation error during job creation.

Get a job

Get the details of a job.

 

Header Auth

 Authentication is required for this endpoint.
gethttps://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid
curl --request GET \
  --url https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid");

xhr.send(data);
import requests

url = "https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": {
      "translationJobUid": "jhcgalvnb6za",
      "jobName": "test job (Cancelled 2017/11/04 12:01:28)",
      "targetLocaleIds": [
        "uk-UA",
        "ru-RU"
      ],
      "description": null,
      "dueDate": null,
      "referenceNumber": null,
      "callbackUrl": null,
      "callbackMethod": null,
      "createdDate": "2017-11-03T14:18:37Z",
      "modifiedDate": "2017-11-04T12:01:28Z",
      "createdByUserUid": "518252370016",
      "modifiedByUserUid": "598d89cce43a",
      "firstCompletedDate": null,
      "lastCompletedDate": null,
      "jobStatus": "CANCELLED",
      "sourceFiles": [
        {
          "uri": "admin.properties",
          "name": "admin.properties"
        }
      ]
    }
  }
}
{
  "response": {
    "code": "NOT_FOUND_ERROR",
    "errors": [
      {
        "key": null,
        "message": null,
        "details": null
      }
    ]
  }
}

Path Params

projectId
string
required
translationJobUid
string
required

Response

Response for retrieving a job

Job not found error

Update a job

Updates the attributes of the job.

 

Header Auth

 Authentication is required for this endpoint.
puthttps://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid
curl --request PUT \
  --url https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid
var request = require("request");

var options = { method: 'PUT',
  url: 'https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid");

xhr.send(data);
import requests

url = "https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": {
      "translationJobUid": "jhcgalvnb6za",
      "jobName": "Test Job",
      "targetLocaleIds": [
        "uk-UA",
        "ru-RU"
      ],
      "description": "Description of the job",
      "dueDate": "2020-11-03T14:18:37Z",
      "referenceNumber": null,
      "callbackUrl": null,
      "callbackMethod": null,
      "createdDate": "2017-11-03T14:18:37Z",
      "modifiedDate": "2017-11-04T12:01:28Z",
      "createdByUserUid": "518252370016",
      "modifiedByUserUid": "598d89cce43a",
      "firstCompletedDate": null,
      "lastCompletedDate": null,
      "jobStatus": "AWAITING_AUTHORIZATION",
      "sourceFiles": [
        {
          "uri": "admin.properties",
          "name": "admin.properties"
        }
      ]
    }
  }
}
null
{
  "response": {
    "code": "NOT_FOUND_ERROR",
    "errors": [
      {
        "key": null,
        "message": null,
        "details": null
      }
    ]
  }
}

Path Params

projectId
string
required
translationJobUid
string
required

Body Params

jobName
string

The name of the job. The name of the job must be unique within the Smartling project.

description
string

The description of the job.

dueDate
date-time

The date the job is requested to be completed by.

referenceNumber
string

Customer specific number/identifier for the job.

callbackUrl
string

The URL for Smartling to invoke when the job is completed.

callbackMethod
string

The http method to call (GET|POST) when invoking the callbackUrl.

Response

Response after successfully updating a job

Validation error on updating a job

Job not found error

Job Search

Search for jobs based on hashcodes, fileUri's, and translationJobUid's

 

Header Auth

 Authentication is required for this endpoint.
posthttps://api.smartling.com/jobs-api/v3/projects/projectId/jobs/search
curl --request POST \
  --url https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/search
var request = require("request");

var options = { method: 'POST',
  url: 'https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/search' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/search")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/search");

xhr.send(data);
import requests

url = "https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/search"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": {
      "totalCount": 2,
      "items": [
        {
          "translationJobUid": "abc123abc",
          "jobName": "myJobName",
          "targetLocaleIds": [
            "uk-UA",
            "ru-RU"
          ],
          "description": "my job description",
          "dueDate": "2015-11-21T11:51:17Z",
          "referenceNumber": "myReferenceNumber1",
          "createdDate": "2015-11-21T11:51:17Z",
          "jobStatus": "IN_PROGRESS"
        },
        {
          "translationJobUid": "abc321xyz",
          "jobName": "myJobName",
          "targetLocaleIds": [
            "uk-UA",
            "ru-RU"
          ],
          "description": "my job description",
          "dueDate": "2015-11-21T11:51:17Z",
          "referenceNumber": "myReferenceNumber1",
          "createdDate": "2015-11-21T11:51:17Z",
          "jobStatus": "IN_PROGRESS"
        }
      ]
    }
  }
}

Path Params

projectId
string
required

Body Params

hashcodes
array of strings

(Optional) The hashcodes (string identifiers) to use to search for jobs. Any job containing the hashcodes specified will be returned.

fileUris
array of strings

(Optional) The fileUris (file identifiers) to use to search for jobs. Any job containing the fileUri specified will be returned.

translationJobUids
array of strings

(Optional) The translationJobUids (translation job identifiers) to use to search for jobs. Any job containing the fileUri specified will be returned.

Response

OK

List Files

List files within a job.

 

Header Auth

 Authentication is required for this endpoint.
gethttps://api.smartling.com/jobs-api/v3/projects/projectId/job/translationJobUid/files
curl --request GET \
  --url https://api.smartling.com/jobs-api/v3/projects/projectId/job/translationJobUid/files
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.smartling.com/jobs-api/v3/projects/projectId/job/translationJobUid/files' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/jobs-api/v3/projects/projectId/job/translationJobUid/files")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.smartling.com/jobs-api/v3/projects/projectId/job/translationJobUid/files");

xhr.send(data);
import requests

url = "https://api.smartling.com/jobs-api/v3/projects/projectId/job/translationJobUid/files"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": {
      "totalCount": 2,
      "items": [
        {
          "uri": "/file/app1.properties"
        },
        {
          "uri": "/file/app2.properties"
        }
      ]
    }
  }
}

Path Params

projectId
string
required
translationJobUid
string
required

Query Params

limit
integer

The limit on the number of files returned.

offset
integer

The offset to use when searching for files.

Response

OK

Get the progress for a file within the Job

Get the progress of a file within a job.

 

Header Auth

 Authentication is required for this endpoint.
gethttps://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/file/progress
curl --request GET \
  --url 'https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/file/progress?fileUri=fileUri'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/file/progress',
  qs: { fileUri: 'fileUri' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/file/progress?fileUri=fileUri")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/file/progress?fileUri=fileUri");

xhr.send(data);
import requests

url = "https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/file/progress"

querystring = {"fileUri":"fileUri"}

response = requests.request("GET", url, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": {
      "contentProgressReport": [
        {
          "targetLocaleId": "uk-UA",
          "targetLocaleDescription": "Ukrainian (Ukraine)",
          "workflowProgressReportList": [
            {
              "workflowUid": "091e04a9faca",
              "workflowName": "Project Default",
              "workflowStepSummaryReportItemList": [
                {
                  "workflowStepUid": "559ce40f2789",
                  "workflowStepName": "Translation",
                  "stringCount": 4,
                  "wordCount": 16,
                  "workflowStepType": "TRANSLATION"
                },
                {
                  "workflowStepUid": "704a4b554b85",
                  "workflowStepName": "Edit",
                  "stringCount": 0,
                  "wordCount": 0,
                  "workflowStepType": "POST_TRANSLATION__EDIT"
                },
                {
                  "workflowStepUid": "b50f989af2c3",
                  "workflowStepName": "Published",
                  "stringCount": 0,
                  "wordCount": 0,
                  "workflowStepType": "PUBLISH"
                }
              ]
            }
          ],
          "unauthorizedProgressReport": {
            "stringCount": 0,
            "wordCount": 0
          },
          "progress": {
            "totalWordCount": 16,
            "percentComplete": 25
          }
        },
        {
          "targetLocaleId": "ru-RU",
          "targetLocaleDescription": "Russian",
          "workflowProgressReportList": [
            {
              "workflowUid": "091e04a9faca",
              "workflowName": "Project Default",
              "workflowStepSummaryReportItemList": [
                {
                  "workflowStepUid": "559ce40f2789",
                  "workflowStepName": "Translation",
                  "stringCount": 1,
                  "wordCount": 4,
                  "workflowStepType": "TRANSLATION"
                },
                {
                  "workflowStepUid": "704a4b554b85",
                  "workflowStepName": "Edit",
                  "stringCount": 2,
                  "wordCount": 8,
                  "workflowStepType": "POST_TRANSLATION__EDIT"
                },
                {
                  "workflowStepUid": "b50f989af2c3",
                  "workflowStepName": "Published",
                  "stringCount": 1,
                  "wordCount": 4,
                  "workflowStepType": "PUBLISH"
                }
              ]
            }
          ],
          "unauthorizedProgressReport": {
            "stringCount": 0,
            "wordCount": 0
          },
          "progress": {
            "totalWordCount": 16,
            "percentComplete": 75
          }
        }
      ],
      "progress": {
        "totalWordCount": 32,
        "percentComplete": 50
      }
    }
  }
}

Path Params

projectId
string
required
translationJobUid
string
required

Query Params

fileUri
string
required

Response

Response for getting job progress of a file

Get Job Progress

Get the progress of a job.

 

Header Auth

 Authentication is required for this endpoint.
gethttps://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/progress
curl --request GET \
  --url https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/progress
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/progress' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/progress")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/progress");

xhr.send(data);
import requests

url = "https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/progress"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": {
      "contentProgressReport": [
        {
          "targetLocaleId": "uk-UA",
          "targetLocaleDescription": "Ukrainian (Ukraine)",
          "workflowProgressReportList": [
            {
              "workflowUid": "091e04a9faca",
              "workflowName": "Project Default",
              "workflowStepSummaryReportItemList": [
                {
                  "workflowStepUid": "559ce40f2789",
                  "workflowStepName": "Translation",
                  "stringCount": 4,
                  "wordCount": 16,
                  "workflowStepType": "TRANSLATION"
                },
                {
                  "workflowStepUid": "704a4b554b85",
                  "workflowStepName": "Edit",
                  "stringCount": 0,
                  "wordCount": 0,
                  "workflowStepType": "POST_TRANSLATION__EDIT"
                },
                {
                  "workflowStepUid": "b50f989af2c3",
                  "workflowStepName": "Published",
                  "stringCount": 0,
                  "wordCount": 0,
                  "workflowStepType": "PUBLISH"
                }
              ]
            }
          ],
          "unauthorizedProgressReport": {
            "stringCount": 0,
            "wordCount": 0
          },
          "progress": {
            "totalWordCount": 16,
            "percentComplete": 25
          }
        },
        {
          "targetLocaleId": "ru-RU",
          "targetLocaleDescription": "Russian",
          "workflowProgressReportList": [
            {
              "workflowUid": "091e04a9faca",
              "workflowName": "Project Default",
              "workflowStepSummaryReportItemList": [
                {
                  "workflowStepUid": "559ce40f2789",
                  "workflowStepName": "Translation",
                  "stringCount": 1,
                  "wordCount": 4,
                  "workflowStepType": "TRANSLATION"
                },
                {
                  "workflowStepUid": "704a4b554b85",
                  "workflowStepName": "Edit",
                  "stringCount": 2,
                  "wordCount": 8,
                  "workflowStepType": "POST_TRANSLATION__EDIT"
                },
                {
                  "workflowStepUid": "b50f989af2c3",
                  "workflowStepName": "Published",
                  "stringCount": 1,
                  "wordCount": 4,
                  "workflowStepType": "PUBLISH"
                }
              ]
            }
          ],
          "unauthorizedProgressReport": {
            "stringCount": 0,
            "wordCount": 0
          },
          "progress": {
            "totalWordCount": 16,
            "percentComplete": 75
          }
        }
      ],
      "progress": {
        "totalWordCount": 32,
        "percentComplete": 50
      }
    }
  }
}
{
  "response": {
    "code": "NOT_FOUND_ERROR",
    "errors": [
      {
        "key": null,
        "message": null,
        "details": null
      }
    ]
  }
}

Path Params

projectId
string
required
translationJobUid
string
required

Query Params

targetLocaleId
string

Response

Response for getting job progress.

Not found error

Job content

 

Add strings to a job

Add strings to a job. This is useful for clients who do not manage strings / content through files, but instead need to add strings by some other means other than files.

 

Header Auth

 Authentication is required for this endpoint.
posthttps://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/strings/add
curl --request POST \
  --url https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/strings/add
var request = require("request");

var options = { method: 'POST',
  url: 'https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/strings/add' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/strings/add")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/strings/add");

xhr.send(data);
import requests

url = "https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/strings/add"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": {
      "successCount": 100,
      "failCount": 0
    }
  }
}
{
  "response": {
    "code": "ACCEPTED",
    "data": {
      "message": "This process will continue asynchronously and may take up to a few minutes.",
      "url": "https://api.smartling.com/jobs-api/v3/projects/{projectId}/jobs/{translationJobUid}/processes/{processUid}"
    }
  }
}
{
  "response": {
    "code": "VALIDATION_ERROR",
    "errors": [
      {
        "key": null
      }
    ],
    "message": "Invalid locales [ad]",
    "details": {
      "field": "targetLocaleIds"
    }
  }
}

Path Params

projectId
string
required
translationJobUid
string
required

Body Params

moveEnabled
boolean

(Optional), default to false. By rule, a string for a locale can only be in one job. If the string identified in the request is already in a job for a locale then it won't be added. But, moveEnalbed=true can be specified and in this case the string will be moved into the specified job.

hashcodes
array of strings

The array of hashcodes to use to add to the job. The hashcodes must exist within Smartling for the project in order to be added to a job. Hashcodes are required when adding strings to a job. Hashcodes is limited to 1000 per API call.

targetLocaleIds
array of strings

The array of localeId's that the strings should be added to. If not specified, the strings will be added to all locales within that job. If specified, the strings will only be added for the locales provided. If the locale\'s were not already part of the job, then the job will be extended to contain the additional locales.

Response

Response after successfully adding strings to a job

Async response when adding strings to a job. When the system can not quickly add the strings to the job, then a 202 response is returned. The response contains a link and processUid to check the progress of the request. When a 202 is received, then the process of adding the content to the job will not be complete until the returned process has completed.

Validation error response

Remove strings from a job

Remove strings from a job. Any strings removed from the job will also be unathorized within Smartling.

 

Header Auth

 Authentication is required for this endpoint.
posthttps://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/strings/remove
curl --request POST \
  --url https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/strings/remove
var request = require("request");

var options = { method: 'POST',
  url: 'https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/strings/remove' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/strings/remove")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/strings/remove");

xhr.send(data);
import requests

url = "https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/strings/remove"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": {
      "successCount": 100,
      "failCount": 0
    }
  }
}
{
  "response": {
    "code": "ACCEPTED",
    "data": {
      "message": "This process will continue asynchronously and may take up to a few minutes.",
      "url": "https://api.smartling.com/jobs-api/v3/projects/{projectId}/jobs/{translationJobUid}/processes/{processUid}"
    }
  }
}

Path Params

projectId
string
required
translationJobUid
string
required

Body Params

hashcodes
array of strings

The hashcodes (string identifiers) that should be removed from the job.

localeIds
array of strings

(Optional) The array of localeId's that the strings should be removed from. If not specified, the strings will be removed from all locales within that job.

Response

Response after successfully removing strings to a job

Async response when adding strings to a job. When the system cannot quickly add the strings to the job, then a 202 response is returned. The response contains a link to check the progress of the request. When a 202 is received, then the process of removing the content from the job will not be complete until the returned process has completed.

Add a file to a job

Adds a file to the job. By default, the file will be added for all locales of the job. This can be changed by specifying the targetLocaleIds for the job to add the file into.
Validation rules:

  • A job can contain a maximum of 300 files
  • Content can not be added to the job if the job contains no locales and the request to add a file does not specify any locales
  • The file (specified by the fileUri) cannot be in the process of being uploaded / modified within Smartling. It should complete its upload process before being added to a job.
  • Any targetLocale's specified must be valid within the project the job has been created for.

 

Header Auth

 Authentication is required for this endpoint.
posthttps://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/file/add
curl --request POST \
  --url https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/file/add
var request = require("request");

var options = { method: 'POST',
  url: 'https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/file/add' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/file/add")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/file/add");

xhr.send(data);
import requests

url = "https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/file/add"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": {
      "successCount": 1,
      "failCount": 1
    }
  }
}
{
  "response": {
    "code": "ACCEPTED",
    "data": {
      "message": "This process will continue asynchronously and may take up to a few minutes.",
      "url": "https://api.smartling.com/jobs-api/v3/projects/{projectId}/jobs/{translationJobUid}/processes/{processUid}"
    }
  }
}
{
  "response": {
    "code": "VALIDATION_ERROR",
    "errors": [
      {
        "key": null,
        "message": "File not found: <fileUri>",
        "details": null
      }
    ]
  }
}

Path Params

projectId
string
required
translationJobUid
string
required

Body Params

fileUri
string

The uri of the file that has been uploaded to Smartling. fileUri is required.

targetLocaleIds
array of strings

The array of localeId's that the file should be added to. If not specified, the file will be added to all locales. If specified, the file will only be added for the locales provided. If the locale\'s were not already part of the job, then the job will be extended to contain the additional locales.

Response

Sync response when adding a file to a job. This is received when the system can quickly add the file and its content to the job.

Async response when adding a file to a job. When the system cannot quickly add the file and its content to the job, then a 202 response is returned. The response contains a link to check the progress of the request. When a 202 is received, then the process of adding the content to the job will not be complete until the returned process has completed.

Validation error adding file to a job

Remove a file from a job

Removes a file from a job. All content that is part of the file contained within that job will be removed from the job and will become unuathorized content.

 

Header Auth

 Authentication is required for this endpoint.
posthttps://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/file/remove
curl --request POST \
  --url https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/file/remove
var request = require("request");

var options = { method: 'POST',
  url: 'https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/file/remove' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/file/remove")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/file/remove");

xhr.send(data);
import requests

url = "https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/file/remove"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": {
      "successCount": 1,
      "failCount": 1
    }
  }
}
{
  "response": {
    "code": "ACCEPTED",
    "data": {
      "message": "This process will continue asynchronously and may take up to a few minutes.",
      "url": "https://api.smartling.com/jobs-api/v3/projects/{projectId}/jobs/{translationJobUid}/processes/{processUid}"
    }
  }
}
{
  "response": {
    "code": "NOT_FOUND_ERROR",
    "errors": [
      {
        "key": null,
        "message": null,
        "details": null
      }
    ]
  }
}

Path Params

projectId
string
required
translationJobUid
string
required

Body Params

fileUri
string

The uri of the file that is to be removed from the job.

Response

Sync response when removing a file to a job. This is received when the system can quickly remove the file and its content from the job.

Async response when removing a file from a job. When the system cannot quickly remove the file and its content to the job, then a 202 response is returned. The response contains a link to check the progress of the request. When a 202 is received, then the process of removing the file and it's contents from the job will not be complete until the returned process has completed.

Not found validation error

Add a locale to a job

Adds a locale to the job.

 

Header Auth

 Authentication is required for this endpoint.
posthttps://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/locales/localeId
curl --request POST \
  --url https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/locales/localeId
var request = require("request");

var options = { method: 'POST',
  url: 'https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/locales/localeId' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/locales/localeId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/locales/localeId");

xhr.send(data);
import requests

url = "https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/locales/localeId"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": null
  }
}
{
  "response": {
    "code": "ACCEPTED",
    "data": {
      "message": "This process will continue asynchronously and may take up to a few minutes.",
      "url": "https://api.smartling.com/jobs-api/v3/projects/{projectId}/jobs/{translationJobUid}/processes/{processUid}"
    }
  }
}

Path Params

projectId
string
required
translationJobUid
string
required
localeId
string
required

Query Params

syncContent
string

Default to true. When a new locale is being added to a job, by default all content in the job will be added to the job for the new locale. If set to false, then no content will be added to the job, but just a locale placeholder will be added to the job.

Response

Sync response when adding a locale to a job. This is received when the system can quickly add the locale and any content to the job.

Async response when adding a locale to a job. When the system cannot quickly add the locale and any content to the job, then a 202 response is returned. The response contains a link to check the progress of the request. When a 202 is received, then the process of adding the content to the job will not be complete until the returned process has completed.

Removes a locale from the job

Removes a locale from the job. When removing a locale from a job (and thus any content within that job for that locale), the content being removed will be unauthorized.

 

Header Auth

 Authentication is required for this endpoint.
deletehttps://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/locales/localeId
curl --request DELETE \
  --url https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/locales/localeId
var request = require("request");

var options = { method: 'DELETE',
  url: 'https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/locales/localeId' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/locales/localeId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/locales/localeId");

xhr.send(data);
import requests

url = "https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/locales/localeId"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": null
  }
}
{
  "response": {
    "code": "ACCEPTED",
    "data": {
      "message": "This process will continue asynchronously and may take up to a few minutes.",
      "url": "https://api.smartling.com/jobs-api/v3/projects/{projectId}/jobs/{translationJobUid}/processes/{processUid}"
    }
  }
}

Path Params

projectId
string
required
translationJobUid
string
required
localeId
string
required

Response

Sync response when removing a locale from a job. This is received when the system can quickly remove the locale and any content from the job.

Async response when removing a locale from a job. When the system cannot quickly remove the locale and any content from the job, then a 202 response is returned. The response contains a link to check the progress of the request. When a 202 is received, then the process of removing the content from the job will not be complete until the returned process has completed.

Job status

 

Close a job

Close a completed job. In order for a Job to be closed, it must be in a Completed state. All content from the job will be removed when it is Closed. Closing a job guarentees that no additional work will be done against the job.

 

Header Auth

 Authentication is required for this endpoint.
posthttps://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/close
curl --request POST \
  --url https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/close
var request = require("request");

var options = { method: 'POST',
  url: 'https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/close' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/close")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/close");

xhr.send(data);
import requests

url = "https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/close"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": null
  }
}
{
  "response": {
    "code": "VALIDATION_ERROR",
    "errors": [
      {
        "key": null,
        "message": "Only a job that is COMPLETE can be closed.",
        "details": null
      }
    ]
  }
}

Path Params

projectId
string
required
translationJobUid
string
required

Response

Response after successfully closing the job

Validation error when closing a job

Cancel a job

Cancel the job. All content within the job will be removed from the job and the content will be unauthorized.

 

Header Auth

 Authentication is required for this endpoint.
posthttps://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/cancel
curl --request POST \
  --url https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/cancel
var request = require("request");

var options = { method: 'POST',
  url: 'https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/cancel' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/cancel")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/cancel");

xhr.send(data);
import requests

url = "https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/cancel"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": null
  }
}
{
  "response": {
    "code": "ACCEPTED",
    "data": {
      "message": "This process will continue asynchronously and may take up to a few minutes.",
      "url": "https://api.smartling.com/jobs-api/v3/projects/{projectId}/jobs/{translationJobUid}/processes/{processUid}"
    }
  }
}
{
  "response": {
    "code": "VALIDATION_ERROR",
    "errors": [
      {
        "key": null,
        "message": "Job can be cancelled only in DRAFT, AWAITING_AUTHORIZATION, or IN_PROGRESS statuses",
        "details": null
      }
    ]
  }
}
{
  "response": {
    "code": "AUTHENTICATION_ERROR",
    "requestId": "47f37e51-b071-4384-84e2-6fefd510e354",
    "errors": [
      {
        "message": "Invalid token",
        "key": "invalid_token",
        "details": {}
      }
    ]
  }
}

Path Params

projectId
string
required
translationJobUid
string
required

Body Params

reason
string

Optional field that can be used to indicate the reason the job was cancelled.

Response

Response after successfully cancelling the job

Async response when cancelling a job. When the system can not quickly cancel the job, then a 202 response is returned. The response contains a link to check the progress of the request. When a 202 is received, then the process of canceling and removing the content from the job will not be complete until the returned process has completed.

Validation error when cancelling a job

Authentication error

Authorize a job

Authorize all content within the job. A job can only be authorized when it a) has content and b) is in an AWAITING_AUTHORIZATION state.

 

Header Auth

 Authentication is required for this endpoint.
posthttps://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/authorize
curl --request POST \
  --url https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/authorize
var request = require("request");

var options = { method: 'POST',
  url: 'https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/authorize' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/authorize")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/authorize");

xhr.send(data);
import requests

url = "https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/authorize"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": null
  }
}
null

Path Params

projectId
string
required
translationJobUid
string
required

Body Params

localeWorkflows
array of objects
targetLocaleId
workflowUid

Response

Response after successfully authorizing the job

Validation error when authorizing a job

Job actions

 

Check for an async process for a job

Check for an async process for a job

 

Header Auth

 Authentication is required for this endpoint.
gethttps://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/processes/processUid
curl --request GET \
  --url https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/processes/processUid
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/processes/processUid' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/processes/processUid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/processes/processUid");

xhr.send(data);
import requests

url = "https://api.smartling.com/jobs-api/v3/projects/projectId/jobs/translationJobUid/processes/processUid"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": {
      "processUid": "13424r5-qaswerxs-43435ff",
      "translationJobUid": "784578f-qaswerxs-43435ff",
      "processState": "IN_PROGRESS | COMPLETED | FAILED",
      "createdDate": "2015-11-21T11:51:17Z",
      "modifiedDate": "2015-11-21T11:51:17Z"
    }
  }
}

Path Params

projectId
string
required
translationJobUid
string
required
processUid
string
required

Response

Ok

Glossaries

 

List Glossaries for an Account

Returns a list of all glossaries in an account. Optional filters for glossary name and UID can be added.

 
gethttps://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries
curl --request GET \
  --url https://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries");

xhr.send(data);
import requests

url = "https://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": {
      "totalCount": 2,
      "items": [
        {
          "glossaryUid": "50d9dab5-6b8b-11e5-ba24-127b00b163a3",
          "name": "Another document tester-Glossary",
          "createdByUserUid": "ah27fhq8",
          "createdDate": "2015-11-21T01:51:17Z",
          "sourceLocaleId": "en-US",
          "description": "some desc"
        },
        {
          "glossaryUid": "50e5c8d3-6b8b-11e5-ba24-127b00b163a3",
          "name": "BizDocs test Max's project-Glossary",
          "createdByUserUid": "ah27fhq8",
          "createdDate": "2015-11-21T01:51:17Z",
          "sourceLocaleId": "en-US",
          "description": "some desc"
        }
      ]
    }
  }
}

Path Params

accountUid
string
required

Query Params

name
string

filter for glossary name in LIKE manner (case-insensitive)

glossaryUids
array of strings

filter for glossary uid in IN manner (might contain up to 100 uids separated by comma e.g glossaryUids=1234,4567)

Response

Success response

Unexpected error

responseobject
response.codestring
response.errorsarray

Create glossary

Creates a new Glossary in an account.

 
posthttps://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries
curl --request POST \
  --url https://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries
var request = require("request");

var options = { method: 'POST',
  url: 'https://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries");

xhr.send(data);
import requests

url = "https://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": {
      "glossaryUid": "50d9dab5-6b8b-11e5-ba24-127b00b163a3",
      "name": "Another document tester-Glossary",
      "description": "Description of a Glossary",
      "sourceLocaleId": "en-US",
      "createdByUserUid": "ah27fhq8",
      "createdDate": "2015-11-21T01:51:17Z"
    }
  }
}

Path Params

accountUid
string
required

Body Params

name
string
required
description
string
required
sourceLocaleId
string
required

A valid Smartling Locale ID

Response

Success response

Unexpected error

responseobject
response.codestring
response.errorsarray

Get glossary details

Gets the name, description, locale, and creation information for a glossary.

 
gethttps://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries/glossaryUid
curl --request GET \
  --url https://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries/glossaryUid
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries/glossaryUid' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries/glossaryUid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries/glossaryUid");

xhr.send(data);
import requests

url = "https://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries/glossaryUid"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

accountUid
string
required
glossaryUid
string
required

Response

Success response

Unexpected error

responseobject
response.codestring
response.errorsarray

Edit a glossary

Edits the name, description or source locale of a glossary. This will completely replace the name, description and source locale of the target glossary. If you do not provide a field, or leave it blank, any existing information will be deleted.

 
puthttps://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries/glossaryUid
curl --request PUT \
  --url https://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries/glossaryUid
var request = require("request");

var options = { method: 'PUT',
  url: 'https://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries/glossaryUid' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries/glossaryUid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "https://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries/glossaryUid");

xhr.send(data);
import requests

url = "https://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries/glossaryUid"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

accountUid
string
required
glossaryUid
string
required

Response

Success response

Unexpected error

responseobject
response.codestring
response.errorsarray

Delete Glossary

Deletes a Glossary. Note that if a Glossary has been assigned to a Linguistic Package, you will not be able to delete it. Linguistic Packages are managed in the Smartling Dashboard.

 
deletehttps://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries/glossaryUid
curl --request DELETE \
  --url https://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries/glossaryUid
var request = require("request");

var options = { method: 'DELETE',
  url: 'https://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries/glossaryUid' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries/glossaryUid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "https://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries/glossaryUid");

xhr.send(data);
import requests

url = "https://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries/glossaryUid"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": {
      "termText": "cold call",
      "partOfSpeechCode": "VERB",
      "definition": "",
      "notes": "",
      "caseSensitive": false,
      "exactMatch": false,
      "variations": "",
      "synonyms": "",
      "antonyms": "",
      "seo": false,
      "doNotTranslate": false,
      "translation": {
        "localeId": "fr-CA",
        "translatedTerm": "cold call french ca",
        "notes": "some notes from user",
        "translatorUserUid": "58870b8e965",
        "submittedForTranslation": true,
        "lockTranslation": false
      }
    }
  }
}

Path Params

accountUid
string
required
glossaryUid
string
required

Response

Success response

Unexpected error

responseobject
response.codestring
response.errorsarray

Glossary terms

 

Get glossary terms

Returns terms from a Glossary. Only the source term is included in this response.

 
gethttps://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries/glossaryUid/terms
curl --request GET \
  --url https://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries/glossaryUid/terms
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries/glossaryUid/terms' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries/glossaryUid/terms")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries/glossaryUid/terms");

xhr.send(data);
import requests

url = "https://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries/glossaryUid/terms"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": {
      "totalCount": 2,
      "items": [
        {
          "termUid": "e390a4d6-aef2-11e5-b159-0ad0c2f6b537",
          "termText": "cold calls",
          "caseSensitive": false,
          "exactMatch": false,
          "partOfSpeechCode": "UNSPECIFIED",
          "definition": "",
          "variations": "",
          "synonyms": "",
          "antonyms": "",
          "seo": false,
          "doNotTranslate": false,
          "deprecated": false,
          "notes": "",
          "createdDate": "2015-12-30T12:43:12Z",
          "modifiedDate": "2015-12-30T12:43:12Z"
        },
        {
          "termUid": "e390a4d6-aef2-11e5-b159-0ad0c2f6b538",
          "termText": "cold call",
          "caseSensitive": true,
          "exactMatch": false,
          "partOfSpeechCode": "VERB",
          "definition": "My definition",
          "variations": "",
          "synonyms": "",
          "antonyms": "",
          "seo": false,
          "doNotTranslate": false,
          "deprecated": false,
          "notes": "My notes",
          "createdDate": "2015-12-30T12:43:12Z",
          "modifiedDate": "2015-12-30T12:43:12Z"
        }
      ]
    }
  }
}

Path Params

accountUid
string
required
glossaryUid
string
required

Query Params

termText
string

filter for term text in LIKE manner (case-insensitive).

limit
integer

pagination portion size

offset
integer

pagination offset value

sort
string

sorting instructions. represents field to sort by and direction separated by coma (i.e. sort=termText,desc). We support sorting by all fields.

Response

Success response

Unexpected error

responseobject
response.codestring
response.errorsarray

Create glossary term

Creates a new glossary term. The only required parameter is termText. See our Glossary documentation for details on each term parameter. You can only add one translation object in this request. To add additional translations, use Edit Glossary term.

 
posthttps://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries/glossaryUid/terms
curl --request POST \
  --url https://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries/glossaryUid/terms
var request = require("request");

var options = { method: 'POST',
  url: 'https://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries/glossaryUid/terms' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries/glossaryUid/terms")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries/glossaryUid/terms");

xhr.send(data);
import requests

url = "https://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries/glossaryUid/terms"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "response": {
    "code": "SUCCESS",
    "data": {
      "termText": "cold call",
      "partOfSpeechCode": "VERB",
      "definition": "",
      "notes": "",
      "caseSensitive": false,
      "exactMatch": false,
      "variations": "",
      "synonyms": "",
      "antonyms": "",
      "seo": false,
      "doNotTranslate": false,
      "translation": {
        "localeId": "fr-CA",
        "translatedTerm": "cold call french ca",
        "notes": "some notes from user",
        "translatorUserUid": "58870b8e965",
        "submittedForTranslation": true,
        "lockTranslation": false
      }
    }
  }
}

Path Params

accountUid
string
required
glossaryUid
string
required

Response

Success response

Unexpected error

responseobject
response.codestring
response.errorsarray

Create glossary terms in batch

Creates a new glossary terms.Validation for the endpoint works in atomic fashion - either all terms passed validation, and then they all will be created, or non of them will be. Translation section is optional.

 
posthttps://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries/glossaryUid/terms/batch
curl --request POST \
  --url https://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries/glossaryUid/terms/batch
var request = require("request");

var options = { method: 'POST',
  url: 'https://api.smartling.com/glossary-api/v2/accounts/accountUid/glossaries/glossaryUid/terms/batch' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.smartling.com/glossary-api/v2/accounts/