> ## Documentation Index
> Fetch the complete documentation index at: https://docs.reap.video/llms.txt
> Use this file to discover all available pages before exploring further.

# Get Translation Languages

> Retrieve all supported languages for caption translation

> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.

## Overview

Get a comprehensive list of all supported source and target languages for caption translation. This endpoint returns language codes and display names for transcription source languages and translation target languages.

## Response

<ResponseField name="sourceLanguages" type="array">
  Array of supported source languages for transcription

  <Expandable title="Source Language Object">
    <ResponseField name="code" type="string">
      Language code (e.g., "en", "es", "fr")
    </ResponseField>

    <ResponseField name="name" type="string">
      Human-readable language name (e.g., "English", "Español", "Français")
    </ResponseField>

    <ResponseField name="displayName" type="string" optional>
      Optional display name for the language
    </ResponseField>
  </Expandable>
</ResponseField>

<ResponseField name="targetLanguages" type="array">
  Array of supported target languages for translation

  <Expandable title="Target Language Object">
    <ResponseField name="code" type="string">
      Language code (e.g., "en")
    </ResponseField>

    <ResponseField name="name" type="string">
      Human-readable language name (e.g., "English")
    </ResponseField>

    <ResponseField name="displayName" type="string" optional>
      Optional display name for the language
    </ResponseField>
  </Expandable>
</ResponseField>

## Language Coverage

We support over **100 languages** for transcription and translation, including:

<CardGroup cols={2}>
  <Card title="Major Languages" icon="globe">
    English, Spanish, French, German, Italian, Portuguese, Chinese, Japanese, Korean, Arabic, Russian
  </Card>

  <Card title="Asian Languages" icon="earth-asia">
    Hindi, Bengali, Tamil, Telugu, Vietnamese, Thai, Indonesian, Malay, Tagalog
  </Card>

  <Card title="European Languages" icon="flag">
    Dutch, Swedish, Norwegian, Danish, Finnish, Polish, Czech, Hungarian, Greek, Romanian
  </Card>

  <Card title="Other Languages" icon="language">
    Hebrew, Turkish, Ukrainian, Persian, Urdu, Swahili, and many more
  </Card>
</CardGroup>

## Example Request

<CodeGroup>
  ```bash cURL theme={"system"}
  curl -X GET "https://public.reap.video/api/v1/automation/get-translation-languages" \
    -H "Authorization: Bearer YOUR_API_KEY" \
    -H "Content-Type: application/json"
  ```

  ```javascript JavaScript theme={"system"}
  const response = await fetch('https://public.reap.video/api/v1/automation/get-translation-languages', {
    method: 'GET',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    }
  });

  const languages = await response.json();
  console.log('Source languages:', languages.sourceLanguages.length);
  console.log('Target languages:', languages.targetLanguages.length);
  ```

  ```python Python theme={"system"}
  import requests

  headers = {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
  }

  response = requests.get(
      'https://public.reap.video/api/v1/automation/get-translation-languages',
      headers=headers
  )

  languages = response.json()
  print(f"Source languages: {len(languages['sourceLanguages'])}")
  print(f"Target languages: {len(languages['targetLanguages'])}")

  # Find a specific language
  spanish = next((lang for lang in languages['sourceLanguages'] if lang['code'] == 'es'), None)
  if spanish:
      print(f"Spanish: {spanish['name']}")
  ```

  ```php PHP theme={"system"}
  <?php
  $ch = curl_init('https://public.reap.video/api/v1/automation/get-translation-languages');
  curl_setopt($ch, CURLOPT_HTTPHEADER, [
      'Authorization: Bearer YOUR_API_KEY',
      'Content-Type: application/json'
  ]);
  curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  $response = curl_exec($ch);
  curl_close($ch);
  $languages = json_decode($response, true);
  echo 'Source languages: ' . count($languages['sourceLanguages']) . "\n";
  echo 'Target languages: ' . count($languages['targetLanguages']) . "\n";
  ?>
  ```

  ```go Go theme={"system"}
  package main
  import (
      "encoding/json"
      "fmt"
      "io/ioutil"
      "net/http"
  )
  func main() {
      url := "https://public.reap.video/api/v1/automation/get-translation-languages"
      req, _ := http.NewRequest("GET", url, nil)
      req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
      req.Header.Set("Content-Type", "application/json")
      client := &http.Client{}
      resp, _ := client.Do(req)
      defer resp.Body.Close()
      body, _ := ioutil.ReadAll(resp.Body)
      
      var languages map[string]interface{}
      json.Unmarshal(body, &languages)
      fmt.Printf("Source languages: %d\n", len(languages["sourceLanguages"].([]interface{})))
      fmt.Printf("Target languages: %d\n", len(languages["targetLanguages"].([]interface{})))
  }
  ```

  ```java Java theme={"system"}
  import java.io.BufferedReader;
  import java.io.InputStreamReader;
  import java.net.HttpURLConnection;
  import java.net.URL;
  public class GetTranslationLanguagesExample {
      public static void main(String[] args) throws Exception {
          URL url = new URL("https://public.reap.video/api/v1/automation/get-translation-languages");
          HttpURLConnection conn = (HttpURLConnection) url.openConnection();
          conn.setRequestMethod("GET");
          conn.setRequestProperty("Authorization", "Bearer YOUR_API_KEY");
          conn.setRequestProperty("Content-Type", "application/json");
          BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream()));
          StringBuilder response = new StringBuilder();
          String line;
          while ((line = br.readLine()) != null) {
              response.append(line);
          }
          br.close();
          System.out.println(response.toString());
      }
  }
  ```
</CodeGroup>

## Example Response

<CodeGroup>
  <CodeGroup.Tab label="200 OK">
    ```json theme={"system"}
    {
      "sourceLanguages": [
        {
          "code": "en",
          "name": "English"
        },
        {
          "code": "zh",
          "name": "中文"
        },
        {
          "code": "de",
          "name": "Deutsch"
        },
        {
          "code": "es",
          "name": "Español"
        },
        {
          "code": "ru",
          "name": "Русский"
        },
        {
          "code": "ko",
          "name": "한국어"
        },
        {
          "code": "fr",
          "name": "Français"
        },
        {
          "code": "ja",
          "name": "日本語"
        },
        {
          "code": "pt",
          "name": "Português"
        },
        {
          "code": "tr",
          "name": "Türkçe"
        },
        {
          "code": "pl",
          "name": "Polski"
        },
        {
          "code": "nl",
          "name": "Nederlands"
        },
        {
          "code": "ar",
          "name": "العربية"
        },
        {
          "code": "it",
          "name": "Italiano"
        },
        {
          "code": "hi",
          "name": "हिन्दी"
        },
        {
          "code": "vi",
          "name": "Tiếng Việt"
        },
        {
          "code": "he",
          "name": "עברית"
        },
        {
          "code": "uk",
          "name": "Українська"
        },
        {
          "code": "el",
          "name": "Ελληνικά"
        },
        {
          "code": "th",
          "name": "ไทย"
        }
      ],
      "targetLanguages": [
        {
          "code": "en",
          "name": "English"
        }
      ]
    }
    ```
  </CodeGroup.Tab>

  <CodeGroup.Tab label="401 Unauthorized">
    ```json theme={"system"}
    {
      "detail": "Unauthorized - Invalid or missing API key"
    }
    ```
  </CodeGroup.Tab>

  <CodeGroup.Tab label="429 Too Many Requests">
    ```json theme={"system"}
    {
      "detail": "Too Many Requests - Rate limit exceeded"
    }
    ```
  </CodeGroup.Tab>

  <CodeGroup.Tab label="500 Internal Server Error">
    ```json theme={"system"}
    {
      "detail": "Internal Server Error - Something went wrong on our end"
    }
    ```
  </CodeGroup.Tab>
</CodeGroup>

## Language Selection Guide

### Source Languages

Source languages are used for:

* **Transcription**: Specify the language of speech in your video
* **Auto-detection**: If not specified, the language will be auto-detected
* **Accuracy**: Specifying the correct language improves transcription accuracy

### Target Languages

Target languages determine:

* **Translation output**: The language captions will be translated to
* **Currently supported**: English (more languages coming soon)

## Difference from Dubbing Languages

| Feature  | Translation Languages         | Dubbing Languages              |
| -------- | ----------------------------- | ------------------------------ |
| Purpose  | Caption/subtitle translation  | Voice dubbing                  |
| Format   | Simple codes (e.g., "en")     | Regional codes (e.g., "en-US") |
| Output   | Text captions                 | Audio voiceover                |
| Use with | Create Clips, Create Captions | Create Dubbing                 |

## Rate Limiting

This endpoint is subject to the standard rate limit of **10 requests per minute**.

## Common Use Cases

<CardGroup cols={2}>
  <Card title="Language Selection UI" icon="list">
    Populate language dropdowns in your application
  </Card>

  <Card title="Validation" icon="check-circle">
    Validate language codes before creating projects
  </Card>

  <Card title="Multilingual Content" icon="globe">
    Plan content strategy for different language audiences
  </Card>

  <Card title="Auto-detection Fallback" icon="wand-magic-sparkles">
    Show users available languages when auto-detection is uncertain
  </Card>
</CardGroup>

## Best Practices

<Tip>
  **Language Selection Tips:**

  * Use auto-detection when unsure of the source language
  * Specify the language explicitly for better transcription accuracy
  * Consider your target audience when choosing translation languages
  * Test with sample content to evaluate transcription quality
</Tip>

## Next Steps

Use the language codes from this endpoint when creating projects:

* [Create Clips](/api-reference/create-clips) - Use `language` and `translationLanguage` parameters
* [Create Captions](/api-reference/create-captions) - Use `language` and `translationLanguage` parameters
* [Create Transcription](/api-reference/create-transcription) - Use `language` and `translationLanguage` parameters


## OpenAPI

````yaml GET /automation/get-translation-languages
openapi: 3.1.0
info:
  title: Reap Automation API
  description: AI-powered video processing automation API
  version: 1.0.0
servers:
  - url: https://public.reap.video/api/v1
security:
  - bearerAuth: []
paths:
  /automation/get-translation-languages:
    get:
      summary: Get Translation Languages
      description: Retrieve all supported languages for caption translation
      operationId: getTranslationLanguages
      responses:
        '200':
          description: Successful response
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/LanguagesResponse'
components:
  schemas:
    LanguagesResponse:
      type: object
      properties:
        sourceLanguages:
          type: array
          items:
            $ref: '#/components/schemas/DubSubLanguage'
        targetLanguages:
          type: array
          items:
            $ref: '#/components/schemas/DubSubLanguage'
    DubSubLanguage:
      type: object
      properties:
        code:
          type: string
        name:
          type: string
        displayName:
          type: string
          nullable: true
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer

````