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

# Get Dubbing Transcript

> Retrieves the transcript in the specified language of a specific end to end dubbing run using the provided `run_id`.

This endpoint serves as a bridge between your media content and its written representation. When you've completed a dubbing run using Camb.ai's powerful dubbing technology, it gives you access to all that valuable spoken content in text form, unlocking new possibilities for how you can use and share your content.

<Info>
  The `{language}` path parameter is your language selector. It determines which linguistic version of your transcript you'll receive - you can choose either the original source language or any of the target languages you've dubbed your content into.
</Info>

## Understanding Response Options

The transcript endpoint gives you two distinct ways to receive your transcript data, each designed for different implementation scenarios:

* **Direct content delivery** (`data_type=raw_data`): The transcript text comes straight to you in the HTTP response body. This immediate delivery is perfect for when you need to process or display the text right away in your application.
* **File-based delivery** (`data_type=file`): You receive a pre-signed URL that links to a ready-to-download transcript file. This approach works wonderfully when you need to store, share, or download the transcript as a distinct file.

Your choice between these options depends on your workflow and how you intend to use the transcript data in your application.

## Choosing the Right Format for Your Needs

Transcripts come in three carefully designed formats, each optimized for different applications:

| Format          | Description                                         | Ideal Applications                                                                      |
| :-------------- | :-------------------------------------------------- | :-------------------------------------------------------------------------------------- |
| `txt` (default) | Clean, simple plain text without timing information | Content analysis, text extraction, SEO optimization, and general reading                |
| `srt`           | SubRip Subtitle format with precise timestamps      | Professional video editing software, most desktop video players, and subtitle embedding |
| `vtt`           | WebVTT format optimized for web environments        | HTML5 video players, web applications, and accessibility compliance on websites         |

The format you choose should align with how you plan to use the transcript. For example, if you're adding subtitles to a web video player, WebVTT (`vtt`) would be your best choice because of its native support in HTML5 environments. If you're editing in professional software like Adobe Premiere, the `srt` format would integrate more seamlessly with your workflow.

## Implementation Example: Bringing It All Together

Let's walk through a complete example of how you might implement transcript retrieval in your application. This Python code sample demonstrates the process from request to application:

```python [expandable] theme={null}
import requests
import os

# Your authentication and identification details
API_KEY = "your_api_key_here"
RUN_ID = 12345  
LANGUAGE = 1  # Language ID (e.g., `1` for English-United States)

# Set up your request parameters
url = f"https://client.camb.ai/apis/transcript/{RUN_ID}/{LANGUAGE}"
headers = {"x-api-key": API_KEY}
params = {
    "format_type": "vtt",  # Choosing WebVTT for web video integration
    "data_type": "file"    # Getting a downloadable file
}

# Make the request to the Camb.ai API
response = requests.get(url, headers=headers, params=params)

# Process the response based on its status
if response.status_code == 200:
    if params["data_type"] == "file":
        # Extract the file URL from the response
        file_url = response.json()["transcript"]
        print(f"Success! Transcript file available at: {file_url}")
        
        # Download the transcript file to your local environment
        transcript_response = requests.get(file_url)
        
        # Save the file with appropriate naming
        filename = f"transcript_{RUN_ID}_{LANGUAGE}.{params['format_type']}"
        with open(filename, "wb") as f:
            f.write(transcript_response.content)
            
        print(f"Transcript downloaded and saved as {filename}")
    else:
        # For direct content, display or process the text
        print("Transcript content retrieved successfully:")
        
        # Here you might process the text further, such as:
        # - Storing in a database
        # - Analyzing for keywords
        # - Displaying in your application interface
        
        # For this example, we'll just show the first 150 characters
        preview = response.text[:150] + "..." if len(response.text) > 150 else response.text
        print(f"Preview: {preview}")
else:
    # Handle any errors that might occur
    print(f"Error {response.status_code}: Could not retrieve transcript")
    print(f"Details: {response.text}")
```

This code not only retrieves your transcript but also demonstrates proper error handling and different processing paths based on your chosen response type. Notice how we create a meaningful filename that includes both the run ID and language - this kind of attention to detail helps keep your transcripts organized when working with multiple videos or languages.

## Building a Complete Workflow

The transcript endpoint works best as part of a complete content processing workflow. Consider how it connects with these related endpoints:

* [Create Dubbing Run](end-to-end-dubbing) - Start the process by submitting your video for dubbing
* [Check Dubbing Status](get-end-to-end-dubbing-status) - Monitor progress and determine when your transcript will be available
* [Get Dubbed Media](get-dubbed-run-info) - Retrieve the dubbed media that corresponds to your transcript

By combining these endpoints, you can create powerful automation workflows that transform, translate, and repurpose your content with minimal manual intervention.


## OpenAPI

````yaml get /transcript/{run_id}/{language}
openapi: 3.1.0
info:
  title: FastAPI
  version: 0.1.0
servers:
  - url: https://client.camb.ai/apis
security: []
paths:
  /transcript/{run_id}/{language}:
    get:
      tags:
        - Dub
      summary: Get Dubbed Run Transcript
      operationId: get_dubbed_run_transcript_dub_transcript__run_id___language__get
      parameters:
        - name: run_id
          in: path
          required: true
          schema:
            $ref: '#/components/schemas/RunIDParam'
        - name: language
          in: path
          required: true
          schema:
            $ref: '#/components/schemas/Languages'
        - name: format_type
          in: query
          required: false
          schema:
            $ref: '#/components/schemas/TranscriptFileFormat'
            default: txt
            title: Format Type
          description: >-
            The format to use for the transcription output. Either `srt`, `vtt`
            or `txt`. Defaults to `txt`.
        - name: data_type
          in: query
          required: false
          schema:
            $ref: '#/components/schemas/TranscriptDataType'
            default: file
            title: Data Type
          description: >-
            The data type for the transcription being returned. Returns the raw
            data of the transcription or a presigned url for the file that
            contains the transcript contents in the specified format.
      security:
        - APIKeyHeader: []
components:
  schemas:
    RunIDParam:
      type: integer
      title: Run ID
      description: >-
        The unique identifier for the run, which was generated during the
        creation process and returned upon task completion.
    Languages:
      type: integer
      enum:
        - 1
        - 2
        - 3
        - 4
        - 5
        - 6
        - 7
        - 8
        - 9
        - 10
        - 11
        - 12
        - 13
        - 14
        - 15
        - 16
        - 17
        - 18
        - 19
        - 20
        - 21
        - 22
        - 23
        - 24
        - 25
        - 26
        - 27
        - 28
        - 29
        - 30
        - 31
        - 32
        - 33
        - 34
        - 35
        - 36
        - 37
        - 38
        - 39
        - 40
        - 41
        - 42
        - 43
        - 44
        - 45
        - 46
        - 47
        - 48
        - 49
        - 50
        - 51
        - 52
        - 53
        - 54
        - 55
        - 56
        - 57
        - 58
        - 59
        - 60
        - 61
        - 62
        - 63
        - 64
        - 65
        - 66
        - 67
        - 68
        - 69
        - 70
        - 71
        - 72
        - 73
        - 74
        - 75
        - 76
        - 77
        - 78
        - 79
        - 80
        - 81
        - 82
        - 83
        - 84
        - 85
        - 86
        - 87
        - 88
        - 89
        - 90
        - 91
        - 92
        - 93
        - 94
        - 95
        - 96
        - 97
        - 98
        - 99
        - 100
        - 101
        - 102
        - 103
        - 104
        - 105
        - 106
        - 107
        - 108
        - 109
        - 110
        - 111
        - 112
        - 113
        - 114
        - 115
        - 116
        - 117
        - 118
        - 119
        - 120
        - 121
        - 122
        - 123
        - 124
        - 125
        - 126
        - 127
        - 128
        - 129
        - 130
        - 131
        - 132
        - 133
        - 134
        - 135
        - 136
        - 139
        - 140
        - 141
        - 142
        - 143
        - 144
        - 145
        - 146
        - 147
        - 148
        - 149
        - 150
      title: Languages
      default: 1
    TranscriptFileFormat:
      type: string
      enum:
        - srt
        - vtt
        - txt
      default: txt
      title: TranscriptFileFormat
    TranscriptDataType:
      type: string
      enum:
        - raw_data
        - file
      default: file
      title: TranscriptDataType
  securitySchemes:
    APIKeyHeader:
      type: apiKey
      in: header
      name: x-api-key
      description: >-
        The `x-api-key` is a custom header required for authenticating requests
        to our API. Include this header in your request with the appropriate API
        key value to securely access our endpoints. You can find your API key(s)
        in the 'API' section of our studio website.

````