# Delete Scheduled Stream
Source: https://lingopal.mintlify.app/api-reference/endpoint/delete-scheduled-stream

DELETE /v1/scheduled_streams/{schedule_id}
Remove a scheduled stream if its status is WAITING and api key matches

<Note>
  This endpoint allows you to delete a scheduled stream that is in WAITING status. Only streams that haven't started yet can be deleted.
</Note>

## Overview

The Delete Scheduled Stream endpoint allows you to remove a scheduled stream from the system. This is useful when you need to cancel a stream that hasn't started yet.

## Endpoint Details

* **Method:** `DELETE`
* **Endpoint:** `/v1/scheduled_streams/{schedule_id}`
* **Authentication:** Required (API Key)
* **Content-Type:** `application/json`

## Parameters

<ParamField type="string">
  The unique identifier of the scheduled stream to delete. This ID is returned when you create a scheduled stream.
</ParamField>

## Request Example

<CodeGroup>
  ```bash cURL theme={null}
  curl -X DELETE "https://streaming.lingopal.ai/v1/scheduled_streams/schedule_12345" \
    -H "X-API-Key: your-api-key-here" \
    -H "Content-Type: application/json"
  ```

  ```python Python theme={null}
  import requests

  url = "https://streaming.lingopal.ai/v1/scheduled_streams/schedule_12345"
  headers = {
      "X-API-Key": "your-api-key-here",
      "Content-Type": "application/json"
  }

  response = requests.delete(url, headers=headers)
  print(response.json())
  ```

  ```javascript JavaScript theme={null}
  const scheduleId = 'schedule_12345';
  const apiKey = 'your-api-key-here';

  fetch(`https://streaming.lingopal.ai/v1/scheduled_streams/${scheduleId}`, {
    method: 'DELETE',
    headers: {
      'X-API-Key': apiKey,
      'Content-Type': 'application/json'
    }
  })
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error('Error:', error));
  ```
</CodeGroup>

## Response

### Success Response (200)

<ResponseExample>
  ```json theme={null}
  {
    "message": "Scheduled stream deleted successfully",
    "schedule_id": "schedule_12345"
  }
  ```
</ResponseExample>

<ResponseField name="message" type="string">
  A success message confirming the deletion
</ResponseField>

<ResponseField name="schedule_id" type="string">
  The ID of the deleted scheduled stream
</ResponseField>

### Error Responses

#### Validation Error (422)

<ResponseExample>
  ```json theme={null}
  {
    "detail": [
      {
        "loc": ["schedule_id", 0],
        "msg": "Invalid schedule ID format",
        "type": "value_error"
      }
    ]
  }
  ```
</ResponseExample>

<ResponseField name="detail" type="array">
  Array of validation error details
</ResponseField>

<ResponseField name="detail[].loc" type="array">
  Location of the error in the request
</ResponseField>

<ResponseField name="detail[].msg" type="string">
  Error message describing the validation issue
</ResponseField>

<ResponseField name="detail[].type" type="string">
  Type of validation error
</ResponseField>

## Use Cases

* **Cancel Future Streams:** Remove scheduled streams that are no longer needed
* **Clean Up:** Delete test or outdated scheduled streams
* **Resource Management:** Free up system resources by removing unused scheduled streams

## Important Notes

<Warning>
  Only scheduled streams with status "WAITING" can be deleted. Streams that are already running or completed cannot be deleted.
</Warning>

<Info>
  The schedule\_id is returned when you create a scheduled stream using the POST /v1/scheduled\_streams endpoint.
</Info>

## Related Endpoints

* [List Scheduled Streams](/api-reference/endpoint/list-scheduled-streams) - Get all scheduled streams
* [Schedule Stream](/api-reference/endpoint/scheduled-streams) - Create a new scheduled stream
* [List Streams](/api-reference/endpoint/list-streams) - Get all active streams


# Launch Media Pipeline (Get RTMP Channel)
Source: https://lingopal.mintlify.app/api-reference/endpoint/get-rtmp-channel

GET /v1/rtmp_channel/{channel_id}
Get RTMP channel info by channel_id.

## Description

This endpoint retrieves information about a specific RTMP channel using its channel\_id. Use this as part of the RTMP streaming workflow to check the status or details of your RTMP channel. See the Quickstart guide for more information.

## Authentication

This endpoint requires an API Key.\
Include your API key in the `x-api-key` header:

```http theme={null}
x-api-key: YOUR_API_KEY
```

## Request

* **Method:** GET
* **Endpoint:** `/v1/rtmp_channel/{channel_id}`
* **Path Parameter:**
  * `channel_id` (string, required): Channel ID

## Response

* **Status:** 200 OK
* **Content-Type:** `application/json`

```json theme={null}
"string"
```

## Example Usage (cURL)

```bash theme={null}
curl -X GET "https://streaming.lingopal-dev.com/v1/rtmp_channel/your-channel-id" \
  -H "x-api-key: YOUR_API_KEY"
```


# Get Segment Translations
Source: https://lingopal.mintlify.app/api-reference/endpoint/get-segment-translations

GET /v1/translations/{stream_id}/{segment_id}
Get all language translations for a specific segment.

## Description

Get all language translations for a specific segment.

## Authentication

This endpoint requires an API Key.\
Include your API key in the `x-api-key` header:

```http theme={null}
x-api-key: YOUR_API_KEY
```

## Request

* **Method:** GET
* **Endpoint:** `/v1/translations/{stream_id}/{segment_id}`
* **Path Parameters:**
  * `stream_id` (string, required): Stream ID
  * `segment_id` (integer, required): Segment ID

## Response

* **Status:** 200 OK
* **Content-Type:** `application/json`

```json theme={null}
{
  "stream_id": "string",
  "segment_id": 0,
  "translations": [
    {
      "stream_id": "string",
      "language_id": "string",
      "segment_id": 0,
      "timestamp": "string",
      "end_time": "string",
      "original_content": "string",
      "speaker": "string",
      "id": 0,
      "content": "string",
      "edited": true,
      "created_at": "2025-12-05T20:36:19.884Z",
      "updated_at": "2025-12-05T20:36:19.884Z"
    }
  ],
  "total_languages": 0
}
```

## Example Usage (cURL)

```bash theme={null}
curl -X GET "https://streaming.lingopal-dev.com/v1/translations/your-stream-id/1" \
  -H "x-api-key: YOUR_API_KEY"
```


# Get Stream Config
Source: https://lingopal.mintlify.app/api-reference/endpoint/get-stream-config

GET /v1/streams/{stream_id}/config
This api is used to get specific stream config of previously run stream.

## Description

This endpoint retrieves the configuration for a specific stream. Use this to review or audit the settings used for a particular stream. See the Quickstart guide for usage context.

## Authentication

This endpoint requires an API Key.\
Include your API key in the `x-api-key` header:

```http theme={null}
x-api-key: YOUR_API_KEY
```

## Request

* **Method:** GET
* **Endpoint:** `/v1/streams/{stream_id}/config`
* **Path Parameter:**
  * `stream_id` (string, required): Stream ID

## Response

* **Status:** 200 OK
* **Content-Type:** `application/json`

```json theme={null}
"string"
```

## Example Usage (cURL)

```bash theme={null}
curl -X GET "https://streaming.lingopal-dev.com/v1/streams/your-stream-id/config" \
  -H "x-api-key: YOUR_API_KEY"
```


# Get Stream Info
Source: https://lingopal.mintlify.app/api-reference/endpoint/get-stream-info

GET /v1/streams/{stream_id}
Get stream info by stream_id.

## Description

This endpoint fetches detailed information about a specific stream using its stream\_id. Use this to check the status, configuration, and metadata of your stream. See the Quickstart guide for usage context.

## Authentication

This endpoint requires an API Key.\
Include your API key in the `x-api-key` header:

```http theme={null}
x-api-key: YOUR_API_KEY
```

## Request

* **Method:** GET
* **Endpoint:** `/v1/streams/{stream_id}`
* **Path Parameter:**
  * `stream_id` (string, required): Stream ID

## Response

* **Status:** 200 OK
* **Content-Type:** `application/json`

```json theme={null}
"string"
```

## Example Usage (cURL)

```bash theme={null}
curl -X GET "https://streaming.lingopal-dev.com/v1/streams/your-stream-id" \
  -H "x-api-key: YOUR_API_KEY"
```


# Get Transcript
Source: https://lingopal.mintlify.app/api-reference/endpoint/get-transcript

GET /v1/transcripts/{stream_id}/{segment_id}
Get a specific transcript by stream_id and segment_id.

## Description

This endpoint retrieves a specific transcript segment for a stream, identified by stream\_id and segment\_id. Use this to access or review individual transcript entries. See the Quickstart guide for usage context.

## Authentication

This endpoint requires an API Key.\
Include your API key in the `x-api-key` header:

```http theme={null}
x-api-key: YOUR_API_KEY
```

## Request

* **Method:** GET
* **Endpoint:** `/v1/transcripts/{stream_id}/{segment_id}`
* **Path Parameters:**
  * `stream_id` (string, required): Stream ID
  * `segment_id` (integer, required): Segment ID

## Response

* **Status:** 200 OK
* **Content-Type:** `application/json`

```json theme={null}
{
  "stream_id": "string",
  "segment_id": 0,
  "timestamp": "string",
  "end_time": "string",
  "original_content": "string",
  "speaker": "string",
  "id": 0,
  "content": "string",
  "edited": true,
  "created_at": "2025-07-15T17:58:06.841Z",
  "updated_at": "2025-07-15T17:58:06.841Z"
}
```

## Example Usage (cURL)

```bash theme={null}
curl -X GET "https://streaming.lingopal-dev.com/v1/transcripts/your-stream-id/1" \
  -H "x-api-key: YOUR_API_KEY"
```


# Get Transcripts
Source: https://lingopal.mintlify.app/api-reference/endpoint/get-transcripts

GET /v1/transcripts/{stream_id}
Get paginated transcripts for a stream.

## Description

This endpoint retrieves paginated transcripts for a stream, allowing you to review captions or subtitles generated during the stream. See the Quickstart guide for usage context.

## Authentication

This endpoint requires an API Key.\
Include your API key in the `x-api-key` header:

```http theme={null}
x-api-key: YOUR_API_KEY
```

## Request

* **Method:** GET
* **Endpoint:** `/v1/transcripts/{stream_id}`
* **Path Parameter:**
  * `stream_id` (string, required): Stream ID
* **Query Parameters:**
  * `page` (integer, optional, default: 1): Page number
  * `per_page` (integer, optional, default: 50): Items per page
  * `order` (string, optional, default: desc): Sort order ('asc' for oldest first, 'desc' for latest first)

## Response

* **Status:** 200 OK
* **Content-Type:** `application/json`

```json theme={null}
{
  "transcripts": [
    {
      "stream_id": "string",
      "segment_id": 0,
      "timestamp": "string",
      "end_time": "string",
      "original_content": "string",
      "speaker": "string",
      "id": 0,
      "content": "string",
      "edited": true,
      "created_at": "2025-07-15T17:53:51.562Z",
      "updated_at": "2025-07-15T17:53:51.562Z"
    }
  ],
  "total": 0,
  "page": 0,
  "per_page": 0,
  "has_next": true,
  "has_prev": true
}
```

## Example Usage (cURL)

```bash theme={null}
curl -X GET "https://streaming.lingopal-dev.com/v1/transcripts/your-stream-id?page=1&per_page=50&order=desc" \
  -H "x-api-key: YOUR_API_KEY"
```


# Get Translation
Source: https://lingopal.mintlify.app/api-reference/endpoint/get-translation

GET /v1/translations/{stream_id}/{segment_id}/{language_id}
Get a specific translation by stream_id, segment_id, and language_id.

## Description

Get a specific translation by `stream_id`, `segment_id`, and `language_id`.

## Authentication

This endpoint requires an API Key.\
Include your API key in the `x-api-key` header:

```http theme={null}
x-api-key: YOUR_API_KEY
```

## Request

* **Method:** GET
* **Endpoint:** `/v1/translations/{stream_id}/{segment_id}/{language_id}`
* **Path Parameters:**
  * `stream_id` (string, required): Stream ID
  * `segment_id` (integer, required): Segment ID
  * `language_id` (string, required): Language ID

## Response

* **Status:** 200 OK
* **Content-Type:** `application/json`

```json theme={null}
{
  "stream_id": "string",
  "language_id": "string",
  "segment_id": 0,
  "timestamp": "string",
  "end_time": "string",
  "original_content": "string",
  "speaker": "string",
  "id": 0,
  "content": "string",
  "edited": true,
  "created_at": "2025-12-05T20:41:00.215Z",
  "updated_at": "2025-12-05T20:41:00.215Z"
}
```

## Example Usage (cURL)

```bash theme={null}
curl -X GET "https://streaming.lingopal-dev.com/v1/translations/your-stream-id/1/en" \
  -H "x-api-key: YOUR_API_KEY"
```


# Get Translation Languages
Source: https://lingopal.mintlify.app/api-reference/endpoint/get-translation-languages

GET /v1/translations/{stream_id}/languages
Get all available languages for a stream.

## Description

Get all available languages for a stream.

## Authentication

This endpoint requires an API Key.\
Include your API key in the `x-api-key` header:

```http theme={null}
x-api-key: YOUR_API_KEY
```

## Request

* **Method:** GET
* **Endpoint:** `/v1/translations/{stream_id}/languages`
* **Path Parameter:**
  * `stream_id` (string, required): Stream ID

## Response

* **Status:** 200 OK
* **Content-Type:** `application/json`

```json theme={null}
{
  "languages": [
    "string"
  ],
  "total_languages": 0
}
```

## Example Usage (cURL)

```bash theme={null}
curl -X GET "https://streaming.lingopal-dev.com/v1/translations/your-stream-id/languages" \
  -H "x-api-key: YOUR_API_KEY"
```


# Get Translation Statistics
Source: https://lingopal.mintlify.app/api-reference/endpoint/get-translation-stats

GET /v1/translations/{stream_id}/stats
Get translation statistics for a stream.

## Description

Get translation statistics for a stream.

## Authentication

This endpoint requires an API Key.\
Include your API key in the `x-api-key` header:

```http theme={null}
x-api-key: YOUR_API_KEY
```

## Request

* **Method:** GET
* **Endpoint:** `/v1/translations/{stream_id}/stats`
* **Path Parameter:**
  * `stream_id` (string, required): Stream ID

## Response

* **Status:** 200 OK
* **Content-Type:** `application/json`

```json theme={null}
{
  "total_translations": 0,
  "edited_translations": 0,
  "unique_languages": [
    "string"
  ],
  "edit_percentage": 0,
  "language_stats": {}
}
```

## Example Usage (cURL)

```bash theme={null}
curl -X GET "https://streaming.lingopal-dev.com/v1/translations/your-stream-id/stats" \
  -H "x-api-key: YOUR_API_KEY"
```


# Get Translations
Source: https://lingopal.mintlify.app/api-reference/endpoint/get-translations

GET /v1/translations/{stream_id}
Get paginated translations for a stream.

## Description

Get paginated translations for a stream with optional filtering (language and edit status). Use this to browse or review translated segments for a specific stream.

## Authentication

This endpoint requires an API Key.\
Include your API key in the `x-api-key` header:

```http theme={null}
x-api-key: YOUR_API_KEY
```

## Request

* **Method:** GET
* **Endpoint:** `/v1/translations/{stream_id}`
* **Path Parameter:**
  * `stream_id` (string, required): Stream ID
* **Query Parameters:**
  * `page` (integer, optional, default: 1): Page number
  * `per_page` (integer, optional, default: 50): Items per page
  * `order` (string, optional, default: desc): Sort order ('asc' for oldest first, 'desc' for latest first)
  * `language_id` (string, optional): Filter by language ID
  * `edited` (boolean, optional): Filter by edit status

## Response

* **Status:** 200 OK
* **Content-Type:** `application/json`

```json theme={null}
{
  "translations": [
    {
      "stream_id": "string",
      "language_id": "string",
      "segment_id": 0,
      "timestamp": "string",
      "end_time": "string",
      "original_content": "string",
      "speaker": "string",
      "id": 0,
      "content": "string",
      "edited": true,
      "created_at": "2025-12-05T19:47:11.175Z",
      "updated_at": "2025-12-05T19:47:11.175Z"
    }
  ],
  "total": 0,
  "page": 0,
  "per_page": 0,
  "has_next": true,
  "has_prev": true
}
```

## Example Usage (cURL)

```bash theme={null}
curl -X GET "https://streaming.lingopal-dev.com/v1/translations/your-stream-id?page=1&per_page=50&order=desc&language_id=en&edited=true" \
  -H "x-api-key: YOUR_API_KEY"
```


# Introduction
Source: https://lingopal.mintlify.app/api-reference/endpoint/introduction

Get started with the Lingopal Cookbook - a Python client for connecting to the Lingopal transcription WebSocket service.

# 🚀 Lingopal Cookbook

This repository contains a simple Python client that connects to the Lingopal transcription WebSocket service using your stream ID and API key.

📌 **GitHub Repo:** [https://github.com/lingopal-ai/lingopal-reference](https://github.com/lingopal-ai/lingopal-reference)

## 📦 Installation

### ✅ Make sure Python 3.8+ is installed

Check your Python version:

```bash theme={null}
python3 --version
```

If you don't have Python, download it from [https://www.python.org/downloads/](https://www.python.org/downloads/).

### 📁 Set Up and Activate a Virtual Environment

In the root of this repo:

```bash theme={null}
python3 -m venv env
source env/bin/activate  # On Windows: env\Scripts\activate
```

### ⬇️ Install the dependencies

Install the package in editable/development mode:

```bash theme={null}
pip install -e .
```

## What's Next?

After installation, you can:

* [Start a stream via API](/api-reference/endpoint/start-stream-via-api)
* [Connect to the WebSocket client](/api-reference/endpoint/lingopal-websocket-client)
* Explore the examples in the `examples/` directory
* Check out the full API documentation

## Getting Help

* Visit our [GitHub repository](https://github.com/lingopal-ai/lingopal-reference) for the latest code and issues


# Lingopal WebSocket Client
Source: https://lingopal.mintlify.app/api-reference/endpoint/lingopal-websocket-client

Learn how to use the Lingopal WebSocket client to connect to transcription services and receive real-time messages.

## Run the example WebSocket client script:

```bash theme={null}
python examples/run_client.py <stream_id> <api_key>
```

## Arguments:

* **`<stream_id>`**: The stream UUID you get from Lingopal
* **`<api_key>`**: Your Lingopal API key
* **`[env]`** (optional):
  * `prod` (default): connect to production

## Example

```bash theme={null}
python examples/run_client.py 0684xxxx-xxxx-xxxx-xxxx a9e12xxxxxxx
```

## This will:

* Connect to the transcription WebSocket server
* Print any messages received from the server

## Notes

* The client uses the `websockets` library
* If connection fails due to a missing header argument, make sure you're using `websockets>=11.0`
* Example script is located at `examples/run_client.py`

## Usage

The WebSocket client allows you to receive real-time transcription data from your active streams. This is useful for:

* Real-time captioning applications
* Live translation services
* Stream monitoring and analytics
* Interactive applications that need immediate transcript updates

## Connection Details

The WebSocket client automatically handles:

* Authentication using your API key
* Connection to the appropriate environment (production by default)
* Message parsing and formatting
* Error handling and reconnection logic

For more information about the WebSocket protocol and message formats, see the [Introduction](/api-reference/endpoint/introduction) documentation.

## Getting Help

* Visit our [GitHub repository](https://github.com/lingopal-ai/lingopal-reference) for the latest code and issues


# List Scheduled Streams
Source: https://lingopal.mintlify.app/api-reference/endpoint/list-scheduled-streams

GET /v1/scheduled_streams
List all scheduled streams from the DynamoDB table

## Description

This endpoint lists all scheduled streams. Use this to view upcoming streams that have been scheduled. See the Quickstart guide for usage context.

## Authentication

This endpoint requires an API Key.\
Include your API key in the `x-api-key` header:

```http theme={null}
x-api-key: YOUR_API_KEY
```

## Request

* **Method:** GET
* **Endpoint:** `/v1/scheduled_streams`

## Response

* **Status:** 200 OK
* **Content-Type:** `application/json`

```json theme={null}
"string"
```

## Example Usage (cURL)

```bash theme={null}
curl -X GET "https://streaming.lingopal-dev.com/v1/scheduled_streams" \
  -H "x-api-key: YOUR_API_KEY"
```


# List Stream Config
Source: https://lingopal.mintlify.app/api-reference/endpoint/list-stream-configs

GET /v1/streams/configs
This api is used to list stream configs of previously run stream.

## Description

This endpoint lists configurations for previously run streams. Use this to review or compare settings across multiple streams. See the Quickstart guide for usage context.

## Authentication

This endpoint requires an API Key.\
Include your API key in the `x-api-key` header:

```http theme={null}
x-api-key: YOUR_API_KEY
```

## Request

* **Method:** GET
* **Endpoint:** `/v1/streams/configs`
* **Query Parameters:**
  * `page` (integer, optional, default: 1): Page number
  * `page_size` (integer, optional, default: 10): Number of items per page

## Response

* **Status:** 200 OK
* **Content-Type:** `application/json`

```json theme={null}
"string"
```

## Example Usage (cURL)

```bash theme={null}
curl -X GET "https://streaming.lingopal-dev.com/v1/streams/configs?page=1&page_size=10" \
  -H "x-api-key: YOUR_API_KEY"
```


# List Streams
Source: https://lingopal.mintlify.app/api-reference/endpoint/list-streams

GET /v1/streams
List streams with pagination and optional state filter.

## Description

This endpoint lists all streams, with support for pagination and optional filtering by stream state. Use this to view all your active, scheduled, or completed streams. See the Quickstart guide for usage context.

## Authentication

This endpoint requires an API Key.\
Include your API key in the `x-api-key` header:

```http theme={null}
x-api-key: YOUR_API_KEY
```

## Request

* **Method:** GET
* **Endpoint:** `/v1/streams`
* **Query Parameters:**
  * `page` (integer, optional, default: 1): Page number
  * `page_size` (integer, optional, default: 10): Number of items per page
  * `stream_state` (string, optional): Stream states are LIVE, STUCK and INIT

## Response

* **Status:** 200 OK
* **Content-Type:** `application/json`

```json theme={null}
"string"
```

## Example Usage (cURL)

```bash theme={null}
curl -X GET "https://streaming.lingopal-dev.com/v1/streams?page=1&page_size=10" \
  -H "x-api-key: YOUR_API_KEY"
```


# Launch Media Pipeline (RTMP Channel)
Source: https://lingopal.mintlify.app/api-reference/endpoint/rtmp-channel

POST /v1/rtmp_channel
Launch a media pipeline by creating an RTMP channel.

## Description

This endpoint is used to create a new RTMP channel. It returns the RTMP server URL and stream key, which you will use in your streaming software (such as OBS Studio) to broadcast your stream. After creating the channel, use the Launch Stream endpoint to start the RTMP stream. See the Quickstart guide for the full workflow.

## Authentication

This endpoint requires an API Key.\
Include your API key in the `X-Api-Key` header:

```http theme={null}
X-Api-Key: your x-api-key
```

## Request

* **Method:** POST
* **Endpoint:** `/v1/rtmp_channel`
* **Content-Type:** `application/json`

### Request Body

```json theme={null}
{
  "output_rtmp_url": "string",
  "output_stream_key": "string"
}
```

| Field               | Type   | Required | Description                |
| ------------------- | ------ | -------- | -------------------------- |
| output\_rtmp\_url   | string | Yes      | The RTMP output URL        |
| output\_stream\_key | string | Yes      | The RTMP output stream key |

### Request Body Parameters

| Field               | Type   | Required | Description                                 |
| ------------------- | ------ | -------- | ------------------------------------------- |
| output\_rtmp\_url   | string | Yes      | The RTMP output URL for the channel.        |
| output\_stream\_key | string | Yes      | The RTMP output stream key for the channel. |

## Response

* **Status:** 200 OK
* **Content-Type:** `application/json`

```json theme={null}
{
  // Response fields here (add example if you have one)
}
```

## Example Usage (cURL)

```bash theme={null}
curl -X POST "https://your-api-domain.com/v1/rtmp_channel" \
  -H "X-Api-Key: your x-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "output_rtmp_url": "rtmp://example.com/live",
    "output_stream_key": "your-stream-key"
  }'
```


# Schedule Stream
Source: https://lingopal.mintlify.app/api-reference/endpoint/scheduled-streams

POST /v1/scheduled_streams
Schedule a stream with the provided parameters.

## Description

This endpoint schedules a stream to start at a specific time with the provided parameters. Use this to automate stream launches for future dates and times. See the Quickstart guide for usage context.

## Authentication

This endpoint requires an API Key.\
Include your API key in the `x-api-key` header:

```http theme={null}
x-api-key: YOUR_API_KEY
```

## Request

* **Method:** POST
* **Endpoint:** `/v1/scheduled_streams`
* **Body:**

```json theme={null}
{
  "ingest_url": "string",
  "vocals_track": "0",
  "background_track": 0,
  "mix": "-9,-6",
  "enable_captions_708": false,
  "enable_captions_608": false,
  "dst_language": ["en"],
  "src_language": "en",
  "start_wowza": false,
  "use_contextual_translation": false,
  "lipsync": true,
  "channel_uuid": "string",
  "is_hls_stream": false,
  "scheduled_time": "2025-12-07T02:00:00Z",
  "stop_time": "2025-12-07T03:00:00Z",
  "timezone": "America/New_York"
}
```

> **Note:** All request body fields are the same as in the Start Stream endpoint, with the addition of `scheduled_time` and `timezone` for scheduling purposes.

### Request Body Parameters

| Field           | Type   | Required | Description                                                |
| --------------- | ------ | -------- | ---------------------------------------------------------- |
| scheduled\_time | string | Yes      | The scheduled start time for the stream (ISO 8601 format). |
| stop\_time      | string | No       | Optional scheduled stop time for the stream (ISO 8601).    |
| timezone        | string | Yes      | The timezone for the scheduled time (default: "UTC").      |

## Response

* **Status:** 200 OK
* **Content-Type:** `application/json`

```json theme={null}
"string"
```

## Example Usage (cURL)

```bash theme={null}
curl -X POST "https://streaming.lingopal-dev.com/v1/scheduled_streams" \
  -H "Content-Type: application/json" \
  -H "x-api-key: YOUR_API_KEY" \
  -d '{
    "ingest_url": "rtmp://example.com/live",
    "vocals_track": "0",
    "background_track": 0,
    "mix": "-9,-6",
    "enable_captions_708": false,
    "enable_captions_608": false,
    "dst_language": ["en"],
    "src_language": "en",
    "start_wowza": false,
    "use_contextual_translation": false,
    "lipsync": true,
    "channel_uuid": "your-channel-uuid",
    "is_hls_stream": false,
    "scheduled_time": "2025-12-07T02:00:00Z",
    "stop_time": "2025-12-07T03:00:00Z",
    "timezone": "America/New_York"
  }'
```


# Launch Stream
Source: https://lingopal.mintlify.app/api-reference/endpoint/start-stream

POST /v1/streams/start
Launch a stream using the provided parameters.

## Description

You can launch three types of streams with this endpoint: **SRT**, **RTMP**, and **HLS**. Each type has different requirements:

* **SRT:** Requires an ingest URL, source language, and destination language. Optional parameters include audio tracks, captions, voice cloning, and lip sync.
* **RTMP:** First, create an RTMP channel to get a channel\_id. Then, use this endpoint with an empty ingest\_url and the channel\_id in channel\_uuid. Voice cloning and lip sync are always enabled for RTMP.
* **HLS:** Requires an HLS stream URL as ingest\_url, source language, and destination language. Lip sync and voice cloning are enabled by default for HLS.

See the Quickstart guide for a step-by-step overview of each stream type.

## Authentication

This endpoint requires an API Key.\
Include your API key in the `x-api-key` header:

```http theme={null}
x-api-key: YOUR_API_KEY
```

## Request

* **Method:** POST
* **Endpoint:** `/v1/streams/start`
* **Content-Type:** `application/json`

### Request Body

```json theme={null}
{
  "ingest_url": "string", // Required for SRT and HLS streams. Leave empty for RTMP.
  "vocals_track": "string",
  "background_track": 0,
  "mix": "-9,-6",
  "enable_captions_708": false,
  "enable_captions_608": false,
  "dst_language": ["en"],
  "src_language": "en",
  "start_wowza": false,
  "use_contextual_translation": false,
  "LIPSYNC": true,
  "channel_uuid": "string", // Required for RTMP only. Use the channel_id returned from the Create RTMP Channel endpoint.
  "is_hls_stream": false
}
```

### Request Body Parameters

| Field                        | Type    | Required | Description                                                                                   |
| ---------------------------- | ------- | -------- | --------------------------------------------------------------------------------------------- |
| ingest\_url                  | string  | SRT/HLS  | The URL where the original stream is coming from. Required for SRT/HLS. Leave empty for RTMP. |
| vocals\_track                | string  | No       | Audio track number for vocals (default: 0).                                                   |
| background\_track            | integer | No       | Audio track number for background (default: 0).                                               |
| mix                          | string  | No       | Audio mix settings (default: "-9,-6").                                                        |
| enable\_captions\_708        | boolean | No       | Enable CEA-708 captions.                                                                      |
| enable\_captions\_608        | boolean | No       | Enable CEA-608 captions.                                                                      |
| dst\_language                | array   | Yes      | List of destination languages for translation (e.g., \["en"]).                                |
| src\_language                | string  | Yes      | The source language of the stream (e.g., "en").                                               |
| start\_wowza                 | boolean | No       | Start Wowza server (default: false).                                                          |
| use\_contextual\_translation | boolean | No       | Enable contextual translation (default: false).                                               |
| LIPSYNC                      | boolean | No       | Enable lip sync (default: true).                                                              |
| voice\_cloning               | boolean | No       | Enable voice cloning (default: true for RTMP/HLS).                                            |
| channel\_uuid                | string  | RTMP     | The channel\_id from RTMP channel creation (required for RTMP only).                          |
| is\_hls\_stream              | boolean | No       | Set to true for HLS streams (default: false).                                                 |

## Response

* **Status:** 200 OK
* **Content-Type:** `application/json`

```json theme={null}
"string"
```

## Example Usage (cURL)

```bash theme={null}
curl -X POST "https://streaming.lingopal-dev.com/v1/streams/start" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "ingest_url": "your injest url",
    "vocals_track": "0",
    "background_track": 0,
    "mix": "-9,-6",
    "enable_captions_708": false,
    "enable_captions_608": false,
    "dst_language": ["en"],
    "src_language": "en",
    "start_wowza": false,
    "use_contextual_translation": false,
    "LIPSYNC": true,
    "channel_uuid": "your-channel-uuid",
    "is_hls_stream": false
  }'
```


# Start Stream Via API
Source: https://lingopal.mintlify.app/api-reference/endpoint/start-stream-via-api

Learn how to start a stream using the Lingopal SOD API with Python examples and environment variable setup.

## Required Environment Variables

* **`LINGOPAL_API_KEY`**: Your API key for authentication
* **`LINGOPAL_INGEST_URL`**: The SRT ingest URL (e.g., `srt://your.server:7070`)

## Example

```bash theme={null}
export LINGOPAL_API_KEY="your-api-key"
export LINGOPAL_INGEST_URL="srt://your.srt.server:7070"
python examples/start_stream.py
```

## Python Implementation

```python theme={null}
import os
import requests

# Environment variables
API_KEY = os.getenv("LINGOPAL_API_KEY")
INGEST_URL = os.getenv("LINGOPAL_INGEST_URL")
API_URL = os.getenv("LINGOPAL_API_URL", "https://streaming.lingopal.ai/v1/streams/start")

# Check required variables
if not API_KEY:
    raise ValueError("❌ Please set the LINGOPAL_API_KEY environment variable.")
if not INGEST_URL:
    raise ValueError("❌ Please set the LINGOPAL_INGEST_URL environment variable.")

# Payload
payload = {
    "ingest_url": INGEST_URL,
    "vocals_track": "0",
    "background_track": 1,
    "mix": "-9,-6",
    "enable_captions_708": True,
    "enable_captions_608": False,
    "src_language": "en",
    "dst_language": ["es"],
    "use_paraphrasing_transcription": True,
    "start_wowza": True,
    "is_hls_stream": False,
    "use_contextual_translation": False,
    "lipsync": False
}

# Headers
headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-API-Key": API_KEY
}

# Make the API request
response = requests.post(API_URL, json=payload, headers=headers)
print(response.json())
```

## What This Does

This example demonstrates how to:

1. **Set up environment variables** for your API key and ingest URL
2. **Create a payload** with all the necessary stream parameters
3. **Make an authenticated API request** to start your stream
4. **Handle the response** from the API

## Parameters Explained

* **`ingest_url`**: Your SRT stream source URL
* **`src_language`**: Source language (e.g., "en" for English)
* **`dst_language`**: Target language(s) for translation (e.g., \["es"] for Spanish)
* **`enable_captions_708/608`**: Enable CEA-708 or CEA-608 captions
* **`vocals_track`**: Audio track for vocals (default: "0")
* **`background_track`**: Audio track for background audio (default: 1)
* **`mix`**: Audio mix settings (default: "-9,-6")
* **`lipsync`**: Enable lip synchronization
* **`use_contextual_translation`**: Enable contextual translation
* **`start_wowza`**: Start Wowza streaming server
* **`is_hls_stream`**: Set to true for HLS streams

## Next Steps

After starting your stream, you can:

* Monitor stream status using the stream ID returned
* Retrieve transcripts and captions
* Stop the stream when finished
* View analytics and usage data

For more information about the WebSocket protocol and message formats, see the [Introduction](/api-reference/endpoint/introduction) documentation.

## Getting Help

* Visit our [GitHub repository](https://github.com/lingopal-ai/lingopal-reference) for the latest code and issues


# Stop Stream By Uuid
Source: https://lingopal.mintlify.app/api-reference/endpoint/stop-stream

POST /v1/streams/{stream_id}/stop
Stop stream by stream_id.

## Description

This endpoint stops a running stream by its stream\_id. Use this to end a live stream when it is no longer needed. See the Quickstart guide for usage context.

## Authentication

This endpoint requires an API Key.\
Include your API key in the `x-api-key` header:

```http theme={null}
x-api-key: YOUR_API_KEY
```

## Request

* **Method:** POST
* **Endpoint:** `/v1/streams/{stream_id}/stop`
* **Path Parameter:**
  * `stream_id` (string, required): Stream ID

## Response

* **Status:** 200 OK
* **Content-Type:** `application/json`

```json theme={null}
"string"
```

## Example Usage (cURL)

```bash theme={null}
curl -X POST "https://streaming.lingopal-dev.com/v1/streams/your-stream-id/stop" \
  -H "x-api-key: YOUR_API_KEY"
```


# Stream Triggers
Source: https://lingopal.mintlify.app/api-reference/endpoint/stream-trigger

POST /v1/streams/{stream_id}/trigger
This API is used for volume in a running stream.

## Description

This endpoint is used to trigger volume changes in a running stream. Use this to adjust the mix or volume of a live stream in real time. See the Quickstart guide for usage context.

## Authentication

This endpoint requires an API Key.\
Include your API key in the `x-api-key` header:

```http theme={null}
x-api-key: YOUR_API_KEY
```

## Request

* **Method:** POST
* **Endpoint:** `/v1/streams/{stream_id}/trigger`
* **Path Parameter:**
  * `stream_id` (string, required): ID of the stream
* **Body:**

```json theme={null}
{
  "mix": "string" // string between -128 and 128
}
```

## Response

* **Status:** 200 OK
* **Content-Type:** `application/json`

```json theme={null}
"string"
```

## Example Usage (cURL)

```bash theme={null}
curl -X POST "https://streaming.lingopal-dev.com/v1/streams/your-stream-id/trigger" \
  -H "Content-Type: application/json" \
  -H "x-api-key: YOUR_API_KEY" \
  -d '{
    "mix": 50
  }'
```


# Stream Usage
Source: https://lingopal.mintlify.app/api-reference/endpoint/stream-usage

GET /v1/streams/usage
This api is used for listing the usage details of streams which a user ran.

## Description

This endpoint lists usage details for streams you have run. Use this to review analytics or track resource consumption for your streams. See the Quickstart guide for usage context.

## Authentication

This endpoint requires an API Key.\
Include your API key in the `x-api-key` header:

```http theme={null}
x-api-key: YOUR_API_KEY
```

## Request

* **Method:** GET
* **Endpoint:** `/v1/streams/usage`

## Response

* **Status:** 200 OK
* **Content-Type:** `application/json`

```json theme={null}
"string"
```

## Example Usage (cURL)

```bash theme={null}
curl -X GET "https://streaming.lingopal-dev.com/v1/streams/usage" \
  -H "x-api-key: YOUR_API_KEY"
```


# Update Scheduled Stream
Source: https://lingopal.mintlify.app/api-reference/endpoint/update-scheduled-stream

PUT /v1/scheduled_streams/{schedule_id}
Update a scheduled stream. Only pending streams can be updated.

## Description

Update a scheduled stream. Only streams in a pending state can be updated. Uses the same request schema as schedule creation.

## Authentication

This endpoint requires an API Key.\
Include your API key in the `x-api-key` header:

```http theme={null}
x-api-key: YOUR_API_KEY
```

## Request

* **Method:** PUT
* **Endpoint:** `/v1/scheduled_streams/{schedule_id}`
* **Path Parameter:**
  * `schedule_id` (string, required): ID of the scheduled stream
* **Body:**

```json theme={null}
{
  "ingest_url": "string",
  "vocals_track": "0",
  "background_track": 0,
  "mix": "-9,-6",
  "enable_captions_708": false,
  "enable_captions_608": false,
  "dst_language": ["en"],
  "src_language": "en",
  "start_wowza": false,
  "use_contextual_translation": false,
  "lipsync": true,
  "channel_uuid": "string",
  "is_hls_stream": false,
  "scheduled_time": "2025-12-07T02:00:00Z",
  "stop_time": "2025-12-07T03:00:00Z",
  "timezone": "America/New_York"
}
```

## Response

* **Status:** 200 OK
* **Content-Type:** `application/json`

```json theme={null}
"string"
```

## Example Usage (cURL)

```bash theme={null}
curl -X PUT "https://streaming.lingopal-dev.com/v1/scheduled_streams/your-schedule-id" \
  -H "Content-Type: application/json" \
  -H "x-api-key: YOUR_API_KEY" \
  -d '{
    "ingest_url": "rtmp://example.com/live",
    "vocals_track": "0",
    "background_track": 0,
    "mix": "-9,-6",
    "enable_captions_708": false,
    "enable_captions_608": false,
    "dst_language": ["en"],
    "src_language": "en",
    "start_wowza": false,
    "use_contextual_translation": false,
    "lipsync": true,
    "channel_uuid": "your-channel-uuid",
    "is_hls_stream": false,
    "scheduled_time": "2025-12-07T02:00:00Z",
    "timezone": "America/New_York"
  }'
```


# Update Transcript
Source: https://lingopal.mintlify.app/api-reference/endpoint/update-segment

PUT /v1/transcripts/{stream_id}/{segment_id}
Update the edited text of a transcript.

## Description

This endpoint updates the text content of a specific transcript segment for a stream. Use this to correct or edit transcript entries after a stream has ended. See the Quickstart guide for usage context.

## Authentication

This endpoint requires an API Key.\
Include your API key in the `x-api-key` header:

```http theme={null}
x-api-key: YOUR_API_KEY
```

## Request

* **Method:** PUT
* **Endpoint:** `/v1/transcripts/{stream_id}/{segment_id}`
* **Path Parameters:**
  * `stream_id` (string, required): Stream ID
  * `segment_id` (integer, required): Segment ID
* **Request Body:**
  * `content` (string, required): The updated transcript content

```json theme={null}
{
  "content": "string"
}
```

## Response

* **Status:** 200 OK
* **Content-Type:** `application/json`

```json theme={null}
{
  "stream_id": "string",
  "segment_id": 0,
  "timestamp": "string",
  "end_time": "string",
  "original_content": "string",
  "speaker": "string",
  "id": 0,
  "content": "string",
  "edited": true,
  "created_at": "2025-07-15T18:17:16.781Z",
  "updated_at": "2025-07-15T18:17:16.781Z"
}
```

## Example Usage (cURL)

```bash theme={null}
curl -X PUT "https://streaming.lingopal-dev.com/v1/transcripts/your-stream-id/1" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "content": "Updated transcript text."
  }'
```


# Update Translation
Source: https://lingopal.mintlify.app/api-reference/endpoint/update-translation

PUT /v1/translations/{stream_id}/{segment_id}/{language_id}
Update the content of a specific translation.

## Description

Update the content of a specific translation.

## Authentication

This endpoint requires an API Key.\
Include your API key in the `x-api-key` header:

```http theme={null}
x-api-key: YOUR_API_KEY
```

## Request

* **Method:** PUT
* **Endpoint:** `/v1/translations/{stream_id}/{segment_id}/{language_id}`
* **Path Parameters:**
  * `stream_id` (string, required): Stream ID
  * `segment_id` (integer, required): Segment ID
  * `language_id` (string, required): Language ID
* **Body:**

```json theme={null}
{
  "content": "string"
}
```

### Request Body Parameters

| Field   | Type   | Required | Description              |
| ------- | ------ | -------- | ------------------------ |
| content | string | Yes      | Updated translated text. |

## Response

* **Status:** 200 OK
* **Content-Type:** `application/json`

```json theme={null}
{
  "stream_id": "string",
  "language_id": "string",
  "segment_id": 0,
  "timestamp": "string",
  "end_time": "string",
  "original_content": "string",
  "speaker": "string",
  "id": 0,
  "content": "string",
  "edited": true,
  "created_at": "2025-12-05T20:41:00.215Z",
  "updated_at": "2025-12-05T20:41:00.215Z"
}
```

## Example Usage (cURL)

```bash theme={null}
curl -X PUT "https://streaming.lingopal-dev.com/v1/translations/your-stream-id/1/en" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"content":"updated content"}'
```


# Introduction
Source: https://lingopal.mintlify.app/api-reference/introduction

Welcome to the Lingopal SOD Endpoints documentation. Discover how to use our endpoints for streaming, transcripts, and more.

<Note>
  The Lingopal Stream on Demand empowers you to build, manage, and analyze live streaming experiences with advanced features like real-time translation, captions, and flexible stream management. Whether you are a broadcaster, developer, or platform integrator, this API provides the tools you need to deliver and control live content at scale.
</Note>

## What is the Lingopal SOD?

The Lingopal SOD is a comprehensive platform for live streaming and real-time media management. It enables you to:

* **Launch and Manage Streams:** Start, stop, and list live streams using SRT, RTMP, or HLS protocols. Control advanced options such as voice cloning, lip sync, and multi-language translation.
* **Schedule Streams:** Automate stream launches for future dates and times, making it easy to plan and coordinate live events.
* **Transcripts and Captions:** Retrieve, review, and update real-time transcripts and captions for your streams, supporting accessibility and multi-language workflows.
* **Stream Analytics:** Access detailed usage data and analytics for all your streams, helping you monitor performance and optimize resource usage.
* **Configuration Management:** Retrieve and audit stream configurations to ensure consistency and compliance across your streaming operations.

## Security and Flexibility

All API endpoints require authentication using an API key, ensuring your streams and data remain secure. The API is designed to be flexible, supporting a wide range of streaming workflows and integration scenarios.

## Getting Started

* Explore the endpoints in the sidebar to learn more about each feature.
* Use the Quickstart guide for step-by-step instructions on launching and managing streams.
* Try out the API directly from the documentation interface.
* Review request/response examples and required parameters for each endpoint.

If you have any questions or need support, please contact our team.


# Quickstart Guide
Source: https://lingopal.mintlify.app/api-reference/quickstart



This guide will help you get started with the Lingopal Stream on Demand API. It covers authentication and the most common API operations with example cURL commands.

## 1. Authentication

All endpoints require an API key. Include your API key in the `x-api-key` header:

```http theme={null}
x-api-key: YOUR_API_KEY
```

## 2. Select Your API Endpoint

You can use either of the following base URLs:

```
Staging URL: https://streaming.lingopal-dev.com    
Production URL: https://streaming.lingopal.ai
```

> **Note:** When viewing an endpoint in the documentation UI, you will also have the option to select the base URL from a dropdown.

***

## 3. Launch a Stream

You can launch three types of streams: **SRT**, **RTMP**, and **HLS**. Each type has different required parameters and options.

### SRT Stream

**What it does:** Starts a new SRT live stream with the provided parameters.

**Required parameters:**

* Ingest URL (the URL where the original stream is coming from)
* Source Language
* Destination Language

**Optional parameters:**

* Vocals Track (default: 0)
* Background Track (default: 0)
* Add Prompt (description of the stream)
* Enable CEA-608 Captions
* Enable CEA-708 Captions
* Enable Voice Cloning
* Enable Lip Sync

**Expected result:** Returns a stream identifier or confirmation that the SRT stream has started.

```bash theme={null}
curl -X POST "BASE_URL/v1/streams/start" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "ingest_url": "your-ingest-url",
    "src_language": "en",
    "dst_language": ["es"],
    "vocals_track": "0",
    "background_track": 0,
    "enable_captions_608": false,
    "enable_captions_708": false,
    "use_contextual_translation": false,
    "LIPSYNC": true,
    "channel_uuid": "your-channel-uuid",
    "is_hls_stream": false
  }'
```

***

### RTMP Stream

**What it does:** Starts a new RTMP live stream. RTMP streaming requires a two-step process.

#### Step 1: Create RTMP Channel

First, use the Create RTMP Channel endpoint to obtain the `channel_id` and `rtmp_url`.

```bash theme={null}
curl -X POST "BASE_URL/v1/rtmp_channel" \
  -H "X-Api-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "output_rtmp_url": "rtmp://your-rtmp-server/live",
    "output_stream_key": "your-stream-key"
  }'
```

**Expected result:** Returns a `channel_id` and `rtmp_url`.

#### Step 2: Launch the Stream

After configuring your streaming software, use the Launch Stream endpoint. Set `ingest_url` to an empty string and provide the `channel_id` you received from the previous step.

**Required parameters:**

* ingest\_url: (not required for RTMP, leave empty)
* channel\_uuid: (the channel\_id returned from Step 1)
* src\_language: Source Language
* dst\_language: Destination Language

**Special notes:**

* For RTMP streams, **Voice Cloning** and **Lip Sync** are always enabled (true).

**Expected result:** Returns a stream identifier or confirmation that the RTMP stream has started.

```bash theme={null}
curl -X POST "BASE_URL/v1/streams/start" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "ingest_url": "",
    "channel_uuid": "your-channel-id",
    "src_language": "en",
    "dst_language": ["es"],
    "LIPSYNC": true,
    "voice_cloning": true,
    "is_hls_stream": false
  }'
```

***

### HLS Stream

**What it does:** Starts a new HLS live stream using an HLS stream URL.

**Required parameters:**

* HLS Stream URL
* Source Language
* Destination Language

**Optional parameters:**

* Add Prompt

**Special notes:**

* For HLS streams, **Lip Sync** and **Voice Cloning** are enabled by default.

**Expected result:** Returns a stream identifier or confirmation that the HLS stream has started.

```bash theme={null}
curl -X POST "BASE_URL/v1/streams/start" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "ingest_url": "https://example.com/stream.m3u8",
    "src_language": "en",
    "dst_language": ["es"],
    "LIPSYNC": true,
    "voice_cloning": true,
    "is_hls_stream": true
  }'
```

***

## 4. List Streams

**What it does:** Retrieves a paginated list of all streams, optionally filtered by state.

**Expected result:** Returns a list of stream objects or identifiers, including their current state and metadata.

```bash theme={null}
curl -X GET "BASE_URL/v1/streams?page=1&page_size=10" \
  -H "x-api-key: YOUR_API_KEY"
```

***

## 5. Get Stream Info

**What it does:** Fetches detailed information about a specific stream using its stream ID.

**Expected result:** Returns metadata and status information for the specified stream.

```bash theme={null}
curl -X GET "BASE_URL/v1/streams/your-stream-id" \
  -H "x-api-key: YOUR_API_KEY"
```

***

## 6. Stop a Stream

**What it does:** Stops a running stream by its stream ID.

**Expected result:** Returns confirmation that the stream has been stopped.

```bash theme={null}
curl -X POST "BASE_URL/v1/streams/your-stream-id/stop" \
  -H "x-api-key: YOUR_API_KEY"
```

***

## 7. Schedule a Stream

**What it does:** Schedules a stream to start at a specific time with the provided parameters.

**Expected result:** Returns a confirmation or identifier for the scheduled stream.

```bash theme={null}
curl -X POST "BASE_URL/v1/scheduled_streams" \
  -H "Content-Type: application/json" \
  -H "x-api-key: YOUR_API_KEY" \
  -d '{
    "ingest_url": "rtmp://example.com/live",
    "vocals_track": "0",
    "background_track": 0,
    "mix": "-9,-6",
    "enable_captions_708": false,
    "enable_captions_608": false,
    "dst_language": ["en"],
    "src_language": "en",
    "start_wowza": false,
    "use_contextual_translation": false,
    "lipsync": true,
    "channel_uuid": "your-channel-uuid",
    "is_hls_stream": false,
    "scheduled_time": "2025-08-25 23:15:00",
    "timezone": "America/New_York"
  }'
```

***

## 8. Get Transcripts for a Stream

**What it does:** Retrieves paginated transcripts (captions) for a given stream.

**Expected result:** Returns a list of transcript segments, including timestamps and speaker information.

```bash theme={null}
curl -X GET "BASE_URL/v1/transcripts/your-stream-id?page=1&per_page=50&order=desc" \
  -H "x-api-key: YOUR_API_KEY"
```

***

## 9. Update a Transcript Segment

**What it does:** Updates the text content of a specific transcript segment for a stream.

**Expected result:** Returns the updated transcript segment object with the new content.

```bash theme={null}
curl -X PUT "BASE_URL/v1/transcripts/your-stream-id/segment-id" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "content": "Updated transcript text."
  }'
```

***

## 10. Use RTMP Channel Endpoints

### Create RTMP Channel

**What it does:** Creates a new RTMP channel for streaming.

**Expected result:** Returns details or confirmation of the created RTMP channel.

```bash theme={null}
curl -X POST "BASE_URL/v1/rtmp_channel" \
  -H "X-Api-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "output_rtmp_url": "rtmp://example.com/live",
    "output_stream_key": "your-stream-key"
  }'
```

### Get RTMP Channel Info

**What it does:** Retrieves information about a specific RTMP channel by its channel ID.

**Expected result:** Returns metadata and status for the specified RTMP channel.

```bash theme={null}
curl -X GET "BASE_URL/v1/rtmp_channel/your-channel-id" \
  -H "x-api-key: YOUR_API_KEY"
```

***

For more details and advanced usage, see the individual endpoint documentation in the sidebar.


# Overview
Source: https://lingopal.mintlify.app/index



# Welcome to Lingopal

<div>
  <h2>Comprehensive Video Processing and Live Streaming Solutions</h2>

  <p>
    From video-on-demand processing to live streaming, Lingopal provides powerful tools for content creation, translation, and global distribution.
  </p>
</div>

## Video on Demand (VOD)

<h3>🎬 Advanced Video Processing & Translation Platform</h3>

<p>
  Transform your video content with AI-powered transcription, translation, and subtitle generation.
</p>

### What Can You Do with Lingopal VOD?

<CardGroup>
  <Card title="Video Management" icon="video">
    Upload, manage, and process video files with support for multiple formats (MP4, AVI, MOV, etc.).
  </Card>

  <Card title="AI Transcription" icon="microphone">
    Generate high-accuracy transcripts and subtitles in multiple languages with advanced speech recognition.
  </Card>

  <Card title="Smart Translation" icon="language">
    Translate content with context-aware AI, supporting text, documents, and video content.
  </Card>

  <Card title="Custom Glossaries" icon="book">
    Create specialized terminology databases for accurate domain-specific translations.
  </Card>

  <Card title="Advanced Processing" icon="cogs">
    Split, regenerate, and enhance transcript segments for improved quality and readability.
  </Card>

  <Card title="Multi-Format Export" icon="download">
    Download processed content in various formats including SRT, VTT, Word, and more.
  </Card>
</CardGroup>

### Who Is VOD For?

<CardGroup>
  <Card title="Content Creators">
    <span>🎥</span>
    Create accessible, multilingual content for global audiences.
  </Card>

  <Card title="Educational Institutions">
    <span>🎓</span>
    Transcribe lectures and generate multilingual subtitles for international students.
  </Card>

  <Card title="Media Companies">
    <span>📺</span>
    Process and translate entertainment content for global distribution.
  </Card>

  <Card title="Businesses">
    <span>🏢</span>
    Create multilingual training videos and corporate communications.
  </Card>
</CardGroup>

### Why Choose Lingopal VOD?

<CardGroup>
  <Card title="AI-Powered Accuracy" icon="brain">
    Advanced machine learning for high-quality transcription and translation.
  </Card>

  <Card title="Multi-Language Support" icon="globe">
    Support for 20+ languages with context-aware translation.
  </Card>

  <Card title="Flexible Processing" icon="sliders-h">
    Customizable workflows for different content types and requirements.
  </Card>

  <Card title="Secure & Scalable" icon="shield-alt">
    Enterprise-grade security with scalable processing capabilities.
  </Card>
</CardGroup>

***

## Stream on Demand (SOD)

<h3>📡 Accessible, Interactive, and Multilingual Live Streaming</h3>

<p>
  Empower your broadcasts, events, and lessons with real-time translation, captions, and seamless global reach.
</p>

### What Can You Do with Lingopal SOD?

<CardGroup>
  <Card title="Live Streaming Made Easy" icon="video">
    Launch, manage, and monitor live streams using industry-standard protocols (SRT, RTMP, HLS).
  </Card>

  <Card title="Real-Time Translation & Captions" icon="language">
    Instantly translate and caption your streams into multiple languages, making your content accessible and inclusive.
  </Card>

  <Card title="Flexible Scheduling" icon="calendar">
    Plan and automate your live events with advanced scheduling tools.
  </Card>

  <Card title="Advanced Audio Features" icon="music">
    Enable voice cloning, lip sync, and audio track management for a professional broadcast experience.
  </Card>

  <Card title="Stream Analytics" icon="chart-line">
    Gain insights into your streams with detailed analytics and usage reports.
  </Card>

  <Card title="Seamless Integration" icon="plug">
    Connect with popular streaming software and platforms, or use our robust API for custom workflows.
  </Card>
</CardGroup>

### Who Is SOD For?

<CardGroup>
  <Card title="Broadcasters & Media Companies">
    <span>📡</span>
    Reach a global audience with multilingual, interactive streams.
  </Card>

  <Card title="Event Organizers">
    <span>🎤</span>
    Host virtual conferences, webinars, or performances with ease.
  </Card>
</CardGroup>

### Why Choose Lingopal SOD?

<CardGroup>
  <Card title="Global Reach" icon="globe">
    Break language barriers and expand your audience worldwide.
  </Card>

  <Card title="Accessibility" icon="universal-access">
    Make your content available to everyone with real-time captions and translations.
  </Card>

  <Card title="Reliability" icon="shield-alt">
    Built on proven streaming technologies for high-quality, low-latency delivery.
  </Card>

  <Card title="Flexibility" icon="sliders-h">
    Use our intuitive dashboard or powerful API to fit your workflow.
  </Card>
</CardGroup>

***

## Choose Your Solution

<div>
  <h3>🎯 Which Platform is Right for You?</h3>
</div>

<CardGroup>
  <Card title="🎬 Video on Demand (VOD)" icon="video">
    <p><strong>Perfect for:</strong> Pre-recorded content, educational videos, corporate training, content localization</p>
    <p><strong>Key Features:</strong> AI transcription, document translation, custom glossaries, multi-format export</p>
    <p><strong>Use Case:</strong> "I have existing videos that need transcription and translation"</p>
  </Card>

  <Card title="📡 Stream on Demand (SOD)" icon="broadcast-tower">
    <p><strong>Perfect for:</strong> Live events, real-time broadcasting, interactive streams, global audiences</p>
    <p><strong>Key Features:</strong> Live translation, real-time captions, scheduling, stream analytics</p>
    <p><strong>Use Case:</strong> "I need to stream live content with real-time translation"</p>
  </Card>
</CardGroup>

## Getting Started

<div>
  <h3>Ready to Get Started?</h3>

  <p>
    Choose your platform and begin your journey with Lingopal
  </p>
</div>

<CardGroup>
  <Card title="🚀 Start with VOD" icon="rocket">
    <p>Process your first video with AI-powered transcription and translation</p>
    <a href="/vod/quickstart">→ VOD Quickstart Guide</a>
  </Card>

  <Card title="📡 Start with SOD" icon="broadcast-tower">
    <p>Launch your first live stream with real-time translation and captions</p>
    <a href="/api-reference/quickstart">→ SOD Quickstart Guide</a>
  </Card>
</CardGroup>


# Download Document
Source: https://lingopal.mintlify.app/vod/document/download-document

get /v1/document/{document_id}/download

Issues a **302 Found** redirect to a time-limited presigned URL where the translated file can be downloaded. Your HTTP client should follow redirects or read the `Location` header.

## Description

The route resolves files under the `documents/{document_id}` prefix in object storage. If you omit `locale`, the service picks a default object (matching the original document name pattern). If you pass `locale`, it prefers keys whose names include that locale (for example `[en-us]` in the stored file name).

Failure cases return **404** with a short **plain-text** message (`Document not found.`, `Locale not found.`, etc.).


# Get All Documents
Source: https://lingopal.mintlify.app/vod/document/get-all-documents

get /v1/document

## Description

This endpoint wraps `get_all_documents` on the public API. Use the optional `is_organization` query flag to switch between listing documents for the signed-in user versus the user’s organization.


# Get Document By Id
Source: https://lingopal.mintlify.app/vod/document/get-document-by-id

get /v1/document/{document_id}

## Description

The handler loads the document. If the ID is not found, the response is **404** with a **plain-text** body.


# Upload Document
Source: https://lingopal.mintlify.app/vod/document/upload-document

post /v1/document

## Description

Uploads a document to the Translation Service.

* **Either** `file` **or** `source_url` must be provided (not both); otherwise the API returns **400**.
* **`languages`** is required: a comma-separated list of locales validated against **text-capable** languages (same validation as other text translation flows).
* **`context_for_translation`** is optional; empty string if omitted.
* **`name`** is optional; the filename stem is used when uploading a `file` without `name`.


# Add Glossary Item
Source: https://lingopal.mintlify.app/vod/glossary/add-glossary-item

put /v1/glossary/

## Description

This endpoint allows you to add a new glossary item for a specific language. The glossary item will be associated with the authenticated user and their organization. Resolve `language_id` using the [Get Languages](/vod/get-languages) endpoint (`GET /v2/languages/`) — each language includes a `language_id` field.


# Delete Glossary Items
Source: https://lingopal.mintlify.app/vod/glossary/delete-glossary-items

delete /v1/glossary/

## Description

This endpoint allows you to delete glossary items for a specific language. The items will be removed from the authenticated user's organization glossary. Resolve `language_id` using the [Get Languages](/vod/get-languages) endpoint (`GET /v2/languages/`) — each language includes a `language_id` field.


# Get Glossary Items
Source: https://lingopal.mintlify.app/vod/glossary/get-glossary-items

get /v1/glossary/

## Description

* Omit **`language_id`** to load glossary items across languages (per `get_glossary_items_from_db_async`).
* Pass **`language_id`** to restrict to one language. Values **\< 0** are normalized to “not set” by **`adjust_language_id`**.
* Map locales to numeric IDs with [Get Languages](/vod/get-languages) (`GET /v2/languages/`) using each object’s **`language_id`** field.
* In each returned item, **`language_id`** may be **`null`**. That means the entry is treated as a **noun** (not scoped to a specific language).


# Introduction
Source: https://lingopal.mintlify.app/vod/introduction

Video upload, transcription, subtitles, dubbing, and translation via the Lingopal VOD API.

# Lingopal VOD API

REST API for processing video: upload media, run transcription and translation, manage subtitles and transcripts, glossaries, documents, and downloads.

**Covers:** videos, subtitles, transcripts, uploads, glossary, translate, documents, and language metadata (`/v2/languages/`).

## Next steps

* [Quickstart](/vod/quickstart) — auth, list, upload, fetch one video
* Use the sidebar and OpenAPI pages for full request/response details per endpoint


# Get Filtered Languages
Source: https://lingopal.mintlify.app/vod/language/get-filtered-languages

get /v2/languages/{language_type}

## Description

Same response shape as [Get Languages](/vod/get-languages), but only locales that match the path filter are returned. Use this when you need **dubbing-only** or **text-only** lists without pulling the full catalog.


# Get Languages
Source: https://lingopal.mintlify.app/vod/language/get-languages

GET /v2/languages/
Returns the languages available to your project, including whether each locale supports dubbing, voice cloning, and text or document translation.

## Description

Use this endpoint before uploading media or calling translate APIs so you only request locales the platform can process.

**URL variants (same handler):**

* `GET /v2/languages` and `GET /v2/languages/` — unfiltered list; `request_type` is `all`.
* `GET /v2/languages/{language_type}` — filter by capability; see [Get Languages (filtered)](/vod/get-languages-by-type) for the interactive reference and `language_type` values `dubbing`, `text`, or `all`.

**Filters:**

| Path segment | Meaning                                                              |
| ------------ | -------------------------------------------------------------------- |
| `all`        | Every configured language (same as the bare `/v2/languages` routes). |
| `dubbing`    | Languages available for video dubbing.                               |
| `text`       | Languages available for document and text translation.               |

## Endpoint URL

```http theme={null}
GET https://api.lingopal.ai/v2/languages/
```

## Parameters

| Location | Name            | Type   | Required | Description                                                                                        |
| -------- | --------------- | ------ | -------- | -------------------------------------------------------------------------------------------------- |
| Path     | `language_type` | string | No       | Omit by calling `/v2/languages/` or use one of `dubbing`, `text`, `all` as the final path segment. |

## Response

### Success (200)

`Content-Type: application/json`

```json theme={null}
{
  "request_type": "all",
  "count": 2,
  "languages": [
    {
      "locale": "en-US",
      "language": "English",
      "dubbing_support": true,
      "voice_cloning_support": true,
      "text_support": true,
      "language_id": 1
    },
    {
      "locale": "es-US",
      "language": "Spanish",
      "dubbing_support": true,
      "voice_cloning_support": false,
      "text_support": true,
      "language_id": 2
    }
  ]
}
```

### Response fields

| Field                               | Type    | Description                                              |
| ----------------------------------- | ------- | -------------------------------------------------------- |
| `request_type`                      | string  | Echo of the applied filter: `dubbing`, `text`, or `all`. |
| `count`                             | integer | Number of entries in `languages`.                        |
| `languages`                         | array   | List of language records.                                |
| `languages[].locale`                | string  | Locale code for the language.                            |
| `languages[].language`              | string  | Display name of the language.                            |
| `languages[].dubbing_support`       | boolean | Whether video dubbing is supported for this locale.      |
| `languages[].voice_cloning_support` | boolean | Whether voice cloning is supported for this locale.      |
| `languages[].text_support`          | boolean | Whether text or document translation is supported.       |
| `languages[].language_id`           | integer | Internal identifier for the language.                    |

## Example requests

All languages:

```bash theme={null}
curl -sS -X GET "https://api.lingopal.ai/v2/languages/" \
  -H "Accept: application/json"
```

Dubbing-capable languages only:

```bash theme={null}
curl -sS -X GET "https://api.lingopal.ai/v2/languages/dubbing" \
  -H "Accept: application/json"
```

## Error responses

### 500 Internal Server Error

```json theme={null}
{
  "detail": "Internal Server Error"
}
```

## Next steps

* [Upload Video](/vod/upload-video) — upload media with target locales
* [Translate Text](/vod/translate-text) — translate text into selected languages


# Quickstart Guide
Source: https://lingopal.mintlify.app/vod/quickstart

Base URL, authentication, and a minimal set of video API calls.

# Quickstart

**Base URL:** `https://api.lingopal.ai`

**Auth:** every request needs your API key:

```http theme={null}
Authorization: Bearer YOUR_API_KEY
```

## List videos

**GET** `/v1/videos/`

```bash theme={null}
curl -sS "https://api.lingopal.ai/v1/videos/" \
  -H "Authorization: Bearer YOUR_API_KEY"
```

## Upload a video

**POST** `/v1/videos/` — multipart body; `name` and `languages` are required unless you use `skip_translate` (see [Upload video](/vod/videos/upload-video)).

```bash theme={null}
curl -sS -X POST "https://api.lingopal.ai/v1/videos/" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F "file=@video.mp4" \
  -F "name=My video" \
  -F "languages=en-US,es-US"
```

## Get one video

**GET** `/v1/videos/{video_id}/`

```bash theme={null}
curl -sS "https://api.lingopal.ai/v1/videos/vid_12345/" \
  -H "Authorization: Bearer YOUR_API_KEY"
```

For every other route (downloads, subtitles, transcripts, glossary, translate, documents), see the matching page under **VOD** in the docs.


# Download Files
Source: https://lingopal.mintlify.app/vod/subtitles/download-files

get /v1/subtitles/{video_id}/download/{file_type}

## Description

This endpoint allows you to download subtitle files for a specific media. You can download subtitle files in different formats (SRT or VTT) and for different languages.


# Download Subtitle
Source: https://lingopal.mintlify.app/vod/subtitles/download-subtitle

get /v2/download/{media_id}/subtitle

## Description

Builds subtitle text via **`create_subtitle_content`**. **`Content-Type`** is **`application/x-subrip`** or **`text/vtt`** with `Content-Disposition: attachment`.


# Generate Subtitles From Video
Source: https://lingopal.mintlify.app/vod/subtitles/generate-subtitles-from-video

post /v1/subtitles/

## Description

This endpoint allows you to upload a video file to generate subtitles in multiple languages. The system will process the video and create subtitle files for the specified languages.


# Get Subtitles By Id
Source: https://lingopal.mintlify.app/vod/subtitles/get-subtitles-by-id

get /v1/subtitles/{video_id}/

## Description

This endpoint retrieves detailed information about a specific video by its ID, including metadata, language processing status, and subtitle information.


# Get Subtitles List
Source: https://lingopal.mintlify.app/vod/subtitles/get-subtitles-list

get /v1/subtitles/

## Description

This endpoint retrieves a comprehensive list of all videos that have been uploaded by the user for subtitle processing. It returns detailed information about each video including metadata, language settings, and processing status.


# Translate text with context awareness
Source: https://lingopal.mintlify.app/vod/text-to-text-translation-with-context/translate-text-with-context-awareness

post /v1/translate/translate-text-with-context

## Description

Translate text with context awareness using advanced AI translation services that understand the context and meaning of the content.


# Download Subtitles
Source: https://lingopal.mintlify.app/vod/transcript/download-subtitles

get /v1/transcript/{media_id}/{locale}/download/subtitles

## Description

Exports the transcript for a given media ID and locale in SRT OR VTT format


# Download Transcript
Source: https://lingopal.mintlify.app/vod/transcript/download-transcript

get /v1/transcript/{media_id}/{locale}/download

## Description

Export transcript as Word docx or JSON attachment


# Download Transcript Get
Source: https://lingopal.mintlify.app/vod/transcript/download-transcript-get

get /v2/download/{media_id}/transcript

## Description

Downloads the transcript for a given media ID in various formats


# Download Transcript Post
Source: https://lingopal.mintlify.app/vod/transcript/download-transcript-post

post /v2/download/{media_id}/transcript

## Description

Downloads the transcript for a given media ID in various formats and customize output


# Get Transcript
Source: https://lingopal.mintlify.app/vod/transcript/get-transcript

get /v1/transcript/{media_id}/{locale}

## Description

List transcript segments for a media ID and locale


# Get Word Level Transcript
Source: https://lingopal.mintlify.app/vod/transcript/get-word-level-transcript

get /v1/transcript/{media_id}/words

## Description

Exports source word-level transcript JSON


# Regenerate Media Segment
Source: https://lingopal.mintlify.app/vod/transcript/regenerate-media-segment

patch /v1/transcript/{media_id}/regenerate_media_segment

## Description

Regenerates a specific media segment for a transcript. The audio is regenerated and the transcript is updated with the new content and timing.


# Translate Documents
Source: https://lingopal.mintlify.app/vod/translate/translate-documents

post /v1/translate/translate_document



# Translate Text
Source: https://lingopal.mintlify.app/vod/translate/translate-text

post /v1/translate/

## Description

Translate text content into multiple languages


# Upload Files
Source: https://lingopal.mintlify.app/vod/uploads/upload-files

get /v1/uploads/

## Description

Get upload URL for file uploads. The generated URL can be used for direct file uploads to storage.


# Download File
Source: https://lingopal.mintlify.app/vod/videos/download-file

get /v1/videos/{video_id}/download/{file_type}

Returns **HTTP 302** with a **`Location`** header pointing at a presigned URL . Follow redirects to download bytes. (Mintlify docs does NOT handle redirects)

## Description

* **`file_type`**: `mp4`, `mp3`, `wav`, `srt`, or `vtt`.
* **`language`**: query parameter, default `source` (target locale or `source` for the original).
* **`burn_subtitles_on_source`**: optional query boolean; when `true` and `file_type` is `mp4`, the handler may select the burned-subtitles-on-source object key.


# Get Video By Id
Source: https://lingopal.mintlify.app/vod/videos/get-video-by-id

get /v1/videos/{video_id}/

# Get Video By Id

Returns a single **`MediaTranslationResponse`** for media the user can access.


# Get Videos List
Source: https://lingopal.mintlify.app/vod/videos/get-videos-list

get /v1/videos/

## Description

Each item follows **`MediaTranslationResponse`**: a `message`, media `id` and `name`, `created_on`, `metadata` with **`duration`** only (seconds), and `languages` with string status **`Completed`** or **`Processing`** plus `language.locale` / `language.language`.


# Preview Subtitle File
Source: https://lingopal.mintlify.app/vod/videos/preview-subtitle-file

get /v1/videos/{video_id}/preview/{file_type}

## Description

Returns subtitle or caption file content with **`Content-Disposition: inline`** (`preview_subtitle_file`).


# Republish Media
Source: https://lingopal.mintlify.app/vod/videos/republish-media

post /v1/videos/{media_id}/{language}/republish

## Description

Republishes the media for the specified language.


# Upload Subtitle File
Source: https://lingopal.mintlify.app/vod/videos/upload-subtitle-file

put /v1/videos/{video_id}/preview/{file_type}

## Description

Multipart upload that writes subtitles (`srt`) or captions (`vtt`) to the expected S3 key for the media (`upload_subtitle_file`). The uploaded filename extension must match `file_type`.


# Upload Video
Source: https://lingopal.mintlify.app/vod/videos/upload-video

post /v1/videos/

## Description

Create media from a file or URL and start transcription / translation

Multipart form upload or **`source_url`**. Either **`file`** or **`source_url`** is required. **`languages`** is required unless **`skip_translate`** is set (422 otherwise). YouTube URLs are rejected.

| Field                                        | Notes                                                           |
| -------------------------------------------- | --------------------------------------------------------------- |
| `name`                                       | Required display name                                           |
| `languages`                                  | Comma-separated locales; must be allowed TTS/dubbing locales    |
| `remove_background_audio`                    | Removes the background audio in media                           |
| `number_of_speakers`                         | Controls the number of speakers detected in the media           |
| `burn_subtitles`, `burn_subtitles_on_source` | Booleans for burning subtitles on the media                     |
| `source_url`                                 | Direct URL, Vimeo, Google Drive, presigned S3; not YouTube      |
| `file`                                       | File upload                                                     |
| `is_source_srt`                              | Boolean indicating if the source is an SRT file                 |
| `prepend_ai_warning`                         | Adds an AI warning to the beginning of the media when published |
| `skip_translate`                             | Transcribe File without translating                             |
| `enhance`                                    | Optional boolean for multi-language enhancement                 |
| `context_for_translation`                    | Optional context for translation                                |
| `experimental_force_accent`, `clone_voice`   | Booleans for voice control                                      |
| `word_count_per_line`                        | Integer, default `7`, minimum **3**, maximum **15**             |