> ## 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.

# Create Dubbing

> Create AI-powered voice dubbing for videos in different languages

> **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

Transform your video content with AI-powered voice dubbing. This endpoint creates natural-sounding voiceovers in different languages while preserving the original speaker's tone and emotion. Perfect for localizing content for global audiences.

## Rate Limiting

This endpoint is rate limited to 10 requests per minute per API key.

<Note>
  Use the [Get Dubbing Languages](/api-reference/get-dubbing-languages) endpoint to retrieve all supported language codes.
</Note>

## Video Requirements

<CardGroup cols={2}>
  <Card title="Duration" icon="clock">
    **Minimum:** 3 seconds\
    **Maximum:** 15 minutes
  </Card>

  <Card title="File Size" icon="scale">
    **Maximum:** 5 GB
  </Card>

  <Card title="Format" icon="file-video">
    MP4 or MOV with clear audio
  </Card>

  <Card title="Content Type" icon="microphone">
    Works best with clear speech and dialogue
  </Card>
</CardGroup>

## Plan Limits

| Plan    | Concurrent Projects |
| ------- | ------------------- |
| Creator | 3                   |
| Studio  | 10                  |

Higher-tier plans allow you to process more videos simultaneously.

<Note>
  The Automation API requires an active subscription. [View pricing](https://reap.video/pricing) to compare plans.
</Note>

## Response

<ResponseField name="id" type="string">
  Unique project identifier
</ResponseField>

<ResponseField name="title" type="string">
  Project title (usually the filename)
</ResponseField>

<ResponseField name="thumbnail" type="string">
  URL to the project thumbnail image
</ResponseField>

<ResponseField name="billedDuration" type="number">
  Duration in seconds that will be billed to your account
</ResponseField>

<ResponseField name="status" type="string">
  Current processing status ("processing", "completed", "failed")
</ResponseField>

<ResponseField name="projectType" type="string">
  Type of project ("dubbing")
</ResponseField>

<ResponseField name="source" type="string">
  Source of the original video ("Upload")
</ResponseField>

<ResponseField name="language" type="string">
  Source language of the original video
</ResponseField>

<ResponseField name="dubbingLanguage" type="string">
  Target language for dubbing
</ResponseField>

<ResponseField name="metadata" type="object" optional>
  Video metadata including duration, resolution, format, etc.
</ResponseField>

<ResponseField name="urls" type="object" optional>
  Object containing project URLs and assets
</ResponseField>

<ResponseField name="createdAt" type="integer">
  Unix timestamp when the project was created
</ResponseField>

<ResponseField name="updatedAt" type="integer">
  Unix timestamp when the project was last updated
</ResponseField>

## Example Request

<CodeGroup>
  ```bash cURL theme={"system"}
  curl -X POST "https://public.reap.video/api/v1/automation/create-dubbing" \
    -H "Authorization: Bearer YOUR_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "uploadId": "65f1a2b3c4d5e6f7a8b9c0d1",
      "sourceLanguage": "en-US",
      "targetLanguage": "es-MX"
    }'
  ```

  ```javascript JavaScript theme={"system"}
  const response = await fetch('https://public.reap.video/api/v1/automation/create-dubbing', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      uploadId: '65f1a2b3c4d5e6f7a8b9c0d1',
      sourceLanguage: 'en-US',
      targetLanguage: 'es-MX'
    })
  });

  const project = await response.json();
  console.log('Dubbing project created:', project.id);
  console.log('Status:', project.status);
  ```

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

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

  data = {
      'uploadId': '65f1a2b3c4d5e6f7a8b9c0d1',
      'sourceLanguage': 'en-US',
      'targetLanguage': 'es-MX'
  }

  response = requests.post(
      'https://public.reap.video/api/v1/automation/create-dubbing',
      headers=headers,
      json=data
  )

  project = response.json()
  print(f"Dubbing project created: {project['id']}")
  print(f"Status: {project['status']}")
  ```

  ```php PHP theme={"system"}
  <?php
  $ch = curl_init('https://public.reap.video/api/v1/automation/create-dubbing');
  $data = [
      'uploadId' => '65f1a2b3c4d5e6f7a8b9c0d1',
      'sourceLanguage' => 'en-US',
      'targetLanguage' => 'es-MX'
  ];
  curl_setopt($ch, CURLOPT_HTTPHEADER, [
      'Authorization: Bearer YOUR_API_KEY',
      'Content-Type: application/json'
  ]);
  curl_setopt($ch, CURLOPT_POST, 1);
  curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
  curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  $response = curl_exec($ch);
  curl_close($ch);
  $project = json_decode($response, true);
  echo 'Dubbing project created: ' . $project['id'] . "\n";
  echo 'Status: ' . $project['status'] . "\n";
  ?>
  ```

  ```go Go theme={"system"}
  package main
  import (
      "bytes"
      "encoding/json"
      "fmt"
      "io/ioutil"
      "net/http"
  )
  func main() {
      url := "https://public.reap.video/api/v1/automation/create-dubbing"
      data := map[string]interface{}{
          "uploadId": "65f1a2b3c4d5e6f7a8b9c0d1",
          "sourceLanguage": "en-US",
          "targetLanguage": "es-MX",
      }
      payload, _ := json.Marshal(data)
      req, _ := http.NewRequest("POST", url, bytes.NewBuffer(payload))
      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)
      fmt.Println(string(body))
  }
  ```

  ```java Java theme={"system"}
  import java.io.*;
  import java.net.HttpURLConnection;
  import java.net.URL;
  public class CreateDubbingExample {
      public static void main(String[] args) throws Exception {
          URL url = new URL("https://public.reap.video/api/v1/automation/create-dubbing");
          HttpURLConnection conn = (HttpURLConnection) url.openConnection();
          conn.setRequestMethod("POST");
          conn.setRequestProperty("Authorization", "Bearer YOUR_API_KEY");
          conn.setRequestProperty("Content-Type", "application/json");
          conn.setDoOutput(true);
          String jsonInputString = "{" +
              "\"uploadId\": \"65f1a2b3c4d5e6f7a8b9c0d1\"," +
              "\"sourceLanguage\": \"en-US\"," +
              "\"targetLanguage\": \"es-MX\"}";
          try(OutputStream os = conn.getOutputStream()) {
              byte[] input = jsonInputString.getBytes("utf-8");
              os.write(input, 0, input.length);
          }
          BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream(), "utf-8"));
          StringBuilder response = new StringBuilder();
          String responseLine;
          while ((responseLine = br.readLine()) != null) {
              response.append(responseLine.trim());
          }
          System.out.println("Dubbing project: " + response.toString());
      }
  }
  ```
</CodeGroup>

## Example Response

<CodeGroup>
  <CodeGroup.Tab label="200 OK">
    ```json theme={"system"}
    {
      "id": "65f1a2b3c4d5e6f7a8b9c0d1",
      "title": "presentation.mp4",
      "thumbnail": "https://cdn.reap.video/thumbnails/65f1a2b3c4d5e6f7a8b9c0d1.jpg",
      "billedDuration": 450.5,
      "status": "processing",
      "projectType": "dubbing",
      "source": "Upload",
      "genre": "talking",
      "topics": [],
      "clipDurations": [],
      "selectedStart": 0,
      "selectedEnd": 450.5,
      "reframeClips": false,
      "exportResolution": 720,
      "exportOrientation": "landscape",
      "captionsPreset": null,
      "enableCaptions": false,
      "enableEmojis": false,
      "enableHighlights": false,
      "language": "en-US",
      "dubbingLanguage": "es-MX",
      "translateTranscription": false,
      "translationLanguages": [],
      "transcriptionScript": "native",
      "metadata": {
        "duration": 450.5,
        "width": 1920,
        "height": 1080,
        "fps": 30,
        "format": "mp4",
        "size": 89234567,
        "bitrate": 1500000
      },
      "urls": {
        "sourceVideo": "https://cdn.reap.video/source/65f1a2b3c4d5e6f7a8b9c0d1.mp4",
        "thumbnail": "https://cdn.reap.video/thumbnails/65f1a2b3c4d5e6f7a8b9c0d1.jpg"
      },
      "createdAt": 1710345600,
      "updatedAt": 1710345600
    }
    ```
  </CodeGroup.Tab>

  <CodeGroup.Tab label="400 Bad Request">
    ```json theme={"system"}
    {
      "detail": "Missing upload ID."
    }
    ```
  </CodeGroup.Tab>

  <CodeGroup.Tab label="400 Invalid Source Language">
    ```json theme={"system"}
    {
      "detail": "Invalid source language. Supported languages: en-US, es-ES, fr-FR, ..."
    }
    ```
  </CodeGroup.Tab>

  <CodeGroup.Tab label="400 Invalid Target Language">
    ```json theme={"system"}
    {
      "detail": "Invalid target language. Supported languages: en-US, es-ES, fr-FR, ..."
    }
    ```
  </CodeGroup.Tab>

  <CodeGroup.Tab label="404 Not Found">
    ```json theme={"system"}
    {
      "detail": "Upload not found."
    }
    ```
  </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": "Maximum concurrent projects reached. Please wait for the current projects to complete."
    }
    ```
  </CodeGroup.Tab>

  <CodeGroup.Tab label="500 Internal Server Error">
    ```json theme={"system"}
    {
      "detail": "Failed to create project. Please contact support."
    }
    ```
  </CodeGroup.Tab>
</CodeGroup>

## Processing Workflow

<Steps>
  <Step title="Audio Extraction">
    Extract and analyze the audio track from your video
  </Step>

  <Step title="Speech Recognition">
    Transcribe the original speech with precise timing
  </Step>

  <Step title="Language Translation">
    Translate the transcription to the target language
  </Step>

  <Step title="Voice Synthesis">
    Generate natural-sounding speech in the target language
  </Step>

  <Step title="Audio Synchronization">
    Sync the new audio with the original video timing
  </Step>

  <Step title="Final Rendering">
    Combine dubbed audio with original video
  </Step>
</Steps>

## Language Pair Quality

Different language pairs have varying quality levels:

<CardGroup cols={2}>
  <Card title="Premium Quality" icon="star">
    **English ↔ Spanish, French, German, Portuguese**\
    Highest quality voice models and cultural adaptation
  </Card>

  <Card title="High Quality" icon="thumbs-up">
    **English ↔ Italian, Dutch, Japanese, Korean**\
    Excellent voice quality with good cultural nuances
  </Card>

  <Card title="Good Quality" icon="check">
    **English ↔ Chinese, Arabic, Hindi, Russian**\
    Good voice quality, suitable for most content types
  </Card>

  <Card title="Standard Quality" icon="circle-check">
    **Other language pairs**\
    Standard quality, continuously improving
  </Card>
</CardGroup>

## Monitoring Progress

Monitor the dubbing project using these endpoints:

1. **[Get Project Status](/api-reference/get-project-status)** - Quick status check
2. **[Get Project Details](/api-reference/get-project-details)** - Full project information
3. **[Get Project Clips](/api-reference/get-project-clips)** - Retrieve finished dubbed video

## Best Practices

<Tip>
  **Dubbing Optimization Tips:**

  * Use high-quality source audio for better results
  * Choose appropriate regional language variants for your target audience
  * Test with shorter clips first to evaluate voice quality
  * Consider the cultural context of your target language
  * Ensure clear speech in the original video for best results
</Tip>

## Common Use Cases

<CardGroup cols={2}>
  <Card title="Global Content Platforms" icon="globe">
    Automatically localize content libraries for international audiences
  </Card>

  <Card title="E-Learning Providers" icon="graduation-cap">
    Scale course content to new markets without re-recording
  </Card>

  <Card title="Enterprise Communications" icon="building">
    Dub internal videos for multinational teams
  </Card>

  <Card title="Media Localization Services" icon="languages">
    Offer AI dubbing as a service to your clients
  </Card>
</CardGroup>

## Next Steps

After creating a dubbing project:

1. Monitor progress with [Get Project Status](/api-reference/get-project-status)
2. Retrieve the dubbed video with [Get Project Clips](/api-reference/get-project-clips)
3. Use the dubbed content in your applications or download for distribution


## OpenAPI

````yaml POST /automation/create-dubbing
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/create-dubbing:
    post:
      summary: Create Dubbing
      description: Create AI-powered voice dubbing for videos in different languages
      operationId: createDubbing
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/CreateDubbingRequest'
      responses:
        '200':
          description: Successful response
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AutomationProject'
components:
  schemas:
    CreateDubbingRequest:
      type: object
      required:
        - uploadId
        - sourceLanguage
        - targetLanguage
      properties:
        uploadId:
          type: string
          description: Upload ID from a previously uploaded file
        sourceLanguage:
          type: string
          description: Language code of the original video content (e.g. en-US, es-ES)
        targetLanguage:
          type: string
          description: Language code for the dubbing target (e.g. fr-FR, de-DE)
    AutomationProject:
      type: object
      properties:
        id:
          type: string
        title:
          type: string
        thumbnail:
          type: string
        billedDuration:
          type: number
        status:
          type: string
          enum:
            - queued
            - prepped
            - draft
            - processing
            - finalizing
            - completed
            - invalid
            - expired
            - failed
            - error
        projectType:
          type: string
          enum:
            - clipping
            - captions
            - reframe
            - dubbing
            - transcription
        source:
          type: string
          enum:
            - Upload
            - Youtube
            - Vimeo
            - TwitchVod
            - Twitter
            - RumbleEmbed
            - Generic
        genre:
          $ref: '#/components/schemas/VideoGenre'
        topics:
          type: array
          items:
            type: string
        clipDurations:
          type: array
          items:
            type: array
            items:
              type: integer
        selectedStart:
          type: number
          nullable: true
        selectedEnd:
          type: number
          nullable: true
        reframeClips:
          type: boolean
        exportResolution:
          type: integer
        exportOrientation:
          $ref: '#/components/schemas/VideoOrientation'
        captionsPreset:
          type: string
          nullable: true
        enableCaptions:
          type: boolean
        enableEmojis:
          type: boolean
        enableHighlights:
          type: boolean
        language:
          type: string
          nullable: true
        dubbingLanguage:
          type: string
          nullable: true
        translateTranscription:
          type: boolean
        translationLanguages:
          type: array
          items:
            type: string
        transcriptionScript:
          $ref: '#/components/schemas/TranscriptionScript'
        metadata:
          $ref: '#/components/schemas/VideoFileMeta'
        urls:
          type: object
        createdAt:
          type: integer
        updatedAt:
          type: integer
    VideoGenre:
      type: string
      enum:
        - talking
        - screenshare
        - gaming
      default: talking
    VideoOrientation:
      type: string
      enum:
        - landscape
        - portrait
        - square
    TranscriptionScript:
      type: string
      enum:
        - native
        - roman
      default: native
    VideoFileMeta:
      type: object
      properties:
        width:
          type: integer
        height:
          type: integer
        aspectRatio:
          type: string
        size:
          type: number
        bitrate:
          type: number
        fps:
          type: number
        duration:
          type: number
        rotation:
          type: integer
        resolution:
          type: integer
        codec:
          type: string
        codecFullName:
          type: string
        codecTag:
          type: string
        format:
          type: string
        formatFullName:
          type: string
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer

````