> ## 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 Dubbing Languages

> Retrieve all supported languages for video dubbing

> **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 video dubbing projects. This endpoint returns language codes and display names for both source language detection and target language dubbing.

## Response

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

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

    <ResponseField name="name" type="string">
      Human-readable language name (e.g., "English (United States)", "Spanish (Spain)")
    </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 dubbing

  <Expandable title="Target Language Object">
    <ResponseField name="code" type="string">
      Language code (e.g., "en-US", "es-ES", "fr-FR")
    </ResponseField>

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

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

## Language Coverage

We support over **80 languages** for dubbing, including:

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

  <Card title="Regional Variants" icon="map">
    Multiple regional variants for major languages (e.g., en-US, en-GB, en-AU)
  </Card>

  <Card title="Emerging Markets" icon="trending-up">
    Hindi, Bengali, Tamil, Telugu, Urdu, Vietnamese, Thai, Indonesian
  </Card>

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

## Example Request

<CodeGroup>
  ```bash cURL theme={"system"}
  curl -X GET "https://public.reap.video/api/v1/automation/get-dubbing-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-dubbing-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-dubbing-languages',
      headers=headers
  )

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

  # Find English variants
  english_targets = [lang for lang in languages['targetLanguages'] if 'English' in lang['name']]
  print(f"English variants: {len(english_targets)}")
  ```

  ```php PHP theme={"system"}
  <?php
  $ch = curl_init('https://public.reap.video/api/v1/automation/get-dubbing-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-dubbing-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;
  import com.google.gson.Gson;
  import com.google.gson.JsonObject;
  import com.google.gson.JsonArray;
  public class GetDubbingLanguagesExample {
      public static void main(String[] args) throws Exception {
          URL url = new URL("https://public.reap.video/api/v1/automation/get-dubbing-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();
          
          Gson gson = new Gson();
          JsonObject languages = gson.fromJson(response.toString(), JsonObject.class);
          JsonArray sourceLanguages = languages.getAsJsonArray("sourceLanguages");
          JsonArray targetLanguages = languages.getAsJsonArray("targetLanguages");
          System.out.println("Source languages: " + sourceLanguages.size());
          System.out.println("Target languages: " + targetLanguages.size());
      }
  }
  ```
</CodeGroup>

## Example Response

The response includes the full supported source and target language lists. This example is shortened for readability; call the endpoint for the current complete list.

<CodeGroup>
  <CodeGroup.Tab label="200 OK">
    ```json theme={"system"}
    {
      "sourceLanguages": [
        {
          "code": "en-US",
          "name": "English (United States)"
        },
        {
          "code": "es-ES",
          "name": "Spanish (Spain)"
        },
        {
          "code": "fr-FR",
          "name": "French (France)"
        }
      ],
      "targetLanguages": [
        {
          "code": "en-US",
          "name": "English (United States)"
        },
        {
          "code": "es-MX",
          "name": "Spanish (Mexico)"
        },
        {
          "code": "fr-FR",
          "name": "French (France)"
        }
      ]
    }
    ```
  </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:

* **Automatic detection**: If not specified, we'll auto-detect the source language
* **Accuracy improvement**: Specifying the source language improves dubbing quality
* **Regional variants**: Choose the specific regional variant for better voice matching

### Target Languages

Target languages determine:

* **Voice characteristics**: Each language has native speaker voice models
* **Cultural adaptation**: Regional variants include local pronunciation and cultural nuances
* **Quality levels**: Popular language pairs have higher quality voice models

## Popular Language Pairs

<CardGroup cols={2}>
  <Card title="English to Spanish" icon="language">
    **en-US** → **es-MX** (North America)\
    **en-GB** → **es-ES** (Europe)
  </Card>

  <Card title="English to French" icon="language">
    **en-US** → **fr-CA** (North America)\
    **en-GB** → **fr-FR** (Europe)
  </Card>

  <Card title="English to German" icon="language">
    **en-US** → **de-DE**\
    High quality for business content
  </Card>

  <Card title="English to Portuguese" icon="language">
    **en-US** → **pt-BR** (Brazil)\
    **en-GB** → **pt-PT** (Portugal)
  </Card>
</CardGroup>

## 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 dropdowns and selection interfaces
  </Card>

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

  <Card title="Localization Planning" icon="globe">
    Plan content localization strategies
  </Card>

  <Card title="Quality Assessment" icon="star">
    Choose optimal language pairs for your content
  </Card>
</CardGroup>

## Best Practices

<Tip>
  **Language Selection Tips:**

  * Use specific regional variants when targeting specific markets
  * Consider cultural context when choosing between regional variants
  * Test with sample content to evaluate voice quality for your use case
  * Use auto-detection for source language if uncertain
</Tip>

## Next Steps

Use the language codes from this endpoint when creating dubbing projects:

* [Create Dubbing](/api-reference/create-dubbing) - Create a dubbing project with specific source and target languages


## OpenAPI

````yaml GET /automation/get-dubbing-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-dubbing-languages:
    get:
      summary: Get Dubbing Languages
      description: Retrieve all supported languages for video dubbing
      operationId: getDubbingLanguages
      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

````