Name: Autocaption – AI Video Subtitles | Free · $5/mo | API.market
Brand: magicapi
SKU: api-magicapi-automatic-video-captioning-api
Availability: InStock
Author: API Market

Shashank Agarwal

# 📝 Ultra-Fast Video Captioning API (fictions-ai/autocaption)

## Overview
The Ultra-Fast Video Captioning API lets you instantly generate accurate, high-quality captions for any video. Leveraging advanced AI, this API significantly enhances accessibility, viewer engagement, and searchability for your applications or content platforms. Whether you’re dealing with short clips, long-form content, or multilingual videos, this service provides precise and reliable subtitles at lightning speed.

![Example Input Video](https://replicate.delivery/pbxt/K5zuJ6HCdsffhegX0JZwDl10qm7fYAh5txe0FZc7XFccpdtm/kingnobelbig.mp4)

Above is an example input video. The API analyzes this video and generates a subtitled output:

![Example Output Video with Subtitles](https://replicate.delivery/pbxt/whrbS9OKgPIJNh2bhqKEV7WKo3mf26yjvx1AifpnY5n7H9ESA/output.mp4)

You can see how the output video includes automatically generated captions, making content more accessible and engaging.

## Features
- High-Speed AI Captioning: Process videos quickly for near-instant subtitle generation.  
- Multiple Customization Options: Control text color, font, position, highlight color, stroke width, and more.  
- Multilingual Support: Choose between left-to-right or right-to-left text, and optionally translate subtitles to English.  
- Batch or Single Video Processing: Efficiently handle one video at a time or integrate the API into a larger pipeline.  
- Automatic and Editable Transcripts: Generate a transcript JSON file to preview, edit, or re-use in future steps.

## Use Cases
1. Education & E-Learning: University lecturers or online course platforms can automatically caption lectures and tutorials, making videos accessible to students with hearing impairments.  
2. Social Media Content: Influencers and marketers can instantly caption social media clips, reels, and short videos to boost engagement and reach a wider audience.  
3. Corporate Training & Internal Comms: Organizations can improve accessibility and searchability of internal training videos, enabling employees to quickly locate relevant segments.  
4. News & Broadcasting: Media outlets and news channels can generate fast, accurate captions for real-time or recorded broadcasts.  
5. Marketing & Advertising: Agencies producing video ads can use the captions to broaden audience reach, cater to different languages, and ensure brand consistency with custom fonts and colors.

## Visual Examples

Below is an example of a single image URL sometimes used as input for test purposes or to illustrate the parameter usage:

![Example Input Image](https://example.com/image.jpg)

In practice, you’ll typically provide a video URL under “video_file_input,” but images can also appear in the example fields to demonstrate how the API expects media URLs.

You can also see a JSON file in the output that contains the transcript:

• Transcript JSON Output:  
  https://replicate.delivery/pbxt/zT7Pr1mfeMtPF00RBUeFenobyQrpTGQeWXL6nxsuzWjmfRPhE/transcript_out.json

This transcript file can be edited and used in a subsequent request to refine the subtitles without re-processing the entire video audio.

## Pricing
• 1 API unit equals 1 image (or video) processed.  
• GET requests to check prediction status (GET /api/v1/magicapi/automatic-video-captioning-api/predictions/{id}) are free and do not count toward API unit usage.  
• Different pricing tiers are available based on usage volume. Contact us to discuss high-volume packages.

## API Documentation

### Base URL
All requests are made to:
```
https://prod.api.market/api/v1/magicapi/automatic-video-captioning-api
```

### Authentication
Include your API key in the request header:
```
x-magicapi-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing
This API uses asynchronous processing for predictions. The flow is:  
1. Submit a prediction request with POST /predictions.  
2. Receive a prediction ID in the response.  
3. Poll GET /predictions/{id} with the ID to check status.  
4. Once the status is "succeeded," your output is ready.

Recommended polling interval: 1 second.  
Maximum timeout: 600 seconds (10 minutes).

### Endpoints

#### 1. Create a Prediction
• URL: POST /api/v1/magicapi/automatic-video-captioning-api/predictions  
• Description: Initiates a new captioning prediction for your video.

Example Request (cURL):
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/automatic-video-captioning-api/predictions" \
  -H "Content-Type: application/json" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY" \
  -d '{
    "input": {
      "video_file_input": "https://example.com/video.mp4",
      "color": "white",
      "fontsize": 7,
      "output_video": true
    }
  }'
```

Example Successful Response:
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "18a45ff0d95feb4449d192bbdc06b4a6df168fa33def76dfc51b78ae224b599b",
  "status": "starting",
  "created_at": "2025-04-24T13:12:40.786Z"
}
```
• The returned ID is used to poll the prediction status.

#### 2. Get Prediction Status and Results
• URL: GET /api/v1/magicapi/automatic-video-captioning-api/predictions/{id}  
• Description: Retrieves the status of your prediction and any available outputs.

Example Request (cURL):
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/automatic-video-captioning-api/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY"
```

Example Successful Response:
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": [
    "https://replicate.delivery/pbxt/whrbS9OKgPIJNh2bhqKEV7WKo3mf26yjvx1AifpnY5n7H9ESA/output.mp4",
    "https://replicate.delivery/pbxt/zT7Pr1mfeMtPF00RBUeFenobyQrpTGQeWXL6nxsuzWjmfRPhE/transcript_out.json"
  ],
  "created_at": "2023-01-01T12:00:00.000Z",
  "started_at": "2023-01-01T12:00:05.000Z",
  "completed_at": "2023-01-01T12:01:00.000Z"
}
```
• Once “status” is “succeeded,” you can download or view the final subtitled video and transcript.  
• If “status” is “failed,” an “error” field will explain the failure.

## Status Codes
- 200 OK: Request succeeded.  
- 201 Created: A new resource (prediction) was successfully created.  
- 400 Bad Request: Invalid input parameters or malformed request.  
- 401 Unauthorized: Missing or invalid API key.  
- 403 Forbidden: Valid API key but insufficient permissions.  
- 404 Not Found: Resource (prediction ID) not found.  
- 429 Too Many Requests: Rate limit exceeded.  
- 500 Internal Server Error: Server is experiencing issues.  
- 503 Service Unavailable: Service is temporarily down or overloaded.

## Rate Limits
Depending on your plan, you have a certain number of requests per minute/hour. If you exceed your plan’s limit, you will receive a 429 Too Many Requests error. To resolve this, either upgrade your plan or reduce your request frequency.

## Error Handling
When an error occurs, you will receive a JSON response indicating the error details:
```json
{
  "error": {
    "code": "invalid_parameter",
    "message": "The parameter 'video_file_input' is required",
    "status": 400
  }
}
```
• Carefully inspect the “message” field to resolve the issue.  
• If the error persists, check your request format or contact support.

## Implementation Guide

### Example Code

#### JavaScript (Node.js) Example
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/automatic-video-captioning-api";

async function createAndWaitForPrediction(inputData) {
  try {
    // Step 1: Create the prediction
    const response = await fetch(`${baseUrl}/predictions`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "x-magicapi-key": apiKey
      },
      body: JSON.stringify({ input: inputData })
    });

    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${response.statusText}`);
    }

    const prediction = await response.json();
    const predictionId = prediction.id;

    // Step 2: Poll for results with timeout
    return await pollForResults(predictionId);
  } catch (error) {
    console.error("Error:", error);
    throw error;
  }
}

function delay(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

async function pollForResults(predictionId) {
  const MAX_TIMEOUT = 600000; // 600 seconds (10 minutes)
  const POLL_INTERVAL = 1000; // 1 second

  const startTime = Date.now();
  while (Date.now() - startTime < MAX_TIMEOUT) {
    const response = await fetch(`${baseUrl}/predictions/${predictionId}`, {
      headers: {
        "x-magicapi-key": apiKey
      }
    });

    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${response.statusText}`);
    }

    const prediction = await response.json();

    if (prediction.status === "succeeded") {
      return prediction.output;
    }
    if (prediction.status === "failed") {
      throw new Error(`Prediction failed: ${prediction.error || "Unknown error"}`);
    }

    await delay(POLL_INTERVAL);
  }
  throw new Error("Prediction timed out after 10 minutes");
}

// Usage example:
// createAndWaitForPrediction({
//   video_file_input: "https://example.com/video.mp4"
// })
//   .then(output => console.log("Output:", output))
//   .catch(err => console.error(err));
```

#### Python Example
```python
import requests
import time

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/automatic-video-captioning-api"

def create_and_wait_for_prediction(input_data):
    headers = {
        "Content-Type": "application/json",
        "x-magicapi-key": API_KEY
    }
    
    response = requests.post(f"{BASE_URL}/predictions", headers=headers, json={"input": input_data})
    
    if response.status_code not in [200, 201]:
        raise Exception(f"API error: {response.status_code} {response.text}")
    
    prediction = response.json()
    prediction_id = prediction["id"]
    
    return poll_for_results(prediction_id)

def poll_for_results(prediction_id):
    MAX_TIMEOUT = 600  # 600 seconds (10 minutes)
    POLL_INTERVAL = 1  # 1 second

    headers = {"x-magicapi-key": API_KEY}
    start_time = time.time()

    while time.time() - start_time < MAX_TIMEOUT:
        response = requests.get(f"{BASE_URL}/predictions/{prediction_id}", headers=headers)
        
        if response.status_code != 200:
            raise Exception(f"API error: {response.status_code} {response.text}")
        
        prediction = response.json()
        
        if prediction["status"] == "succeeded":
            return prediction["output"]
        if prediction["status"] == "failed":
            error_msg = prediction.get("error", "Unknown error")
            raise Exception(f"Prediction failed: {error_msg}")
        
        time.sleep(POLL_INTERVAL)
    
    raise Exception("Prediction timed out after 10 minutes")

# Example usage:
# output = create_and_wait_for_prediction({
#     "video_file_input": "https://example.com/video.mp4"
# })
# print("Output:", output)
```

#### cURL Example

```bash
# 1. Create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/automatic-video-captioning-api/predictions" \
  -H "Content-Type: application/json" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY" \
  -d '{
    "input": {
      "video_file_input": "https://example.com/video.mp4",
      "color": "white"
    }
  }'

# Assume you receive something like:
# {"id": "abcd1234", "status": "starting"}

# 2. Check prediction status (replace "abcd1234" with the actual ID)
curl -X GET "https://prod.api.market/api/v1/magicapi/automatic-video-captioning-api/predictions/abcd1234" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY"

# Repeat the GET request until "status" is "succeeded"
```

### Performance Optimization
- Reduce the size of your video when possible to speed up processing.  
- Combine multiple adjustments (font color, highlight color, stroke) in one request rather than multiple smaller requests.  
- Only request transcripts if needed, to minimize overhead.

## FAQ
1. Q: How long does each captioning job take?  
   A: Typically, it depends on video length and complexity, but most process in under a few minutes.  
2. Q: Can I provide my own transcript?  
   A: Yes. Use the "transcript_file_input" parameter. The API will use your transcript instead of generating one from scratch.  
3. Q: Do I pay extra for transcript output?  
   A: The transcript JSON output is included in the same API unit.  
4. Q: Can I choose different languages?  
   A: Yes. The API includes options for right-to-left text and optional translation to English.  
5. Q: Is there a maximum video length limit?  
   A: Limits may vary based on your plan. Large files may take longer to process.

## Contact Us
If you have any questions or need assistance, you can reach out to us through the embedded chat on the bottom right corner of the page or send an email to hello[at]api.market.

Automatically generate and burn subtitles into videos using AI speech recognition. Supports multiple languages. Start free on API.market.

Autocaption – AI Video Subtitles | Free · $5/mo | API.market

📝 Ultra-Fast Video Captioning API (fictions-ai/autocaption)

FREE

MagicAPI

PAYG

START

ULTRA

ELITE

MEGA

GIGA

BULK

Instantly generate accurate captions for any video with high-speed AI—enhance accessibility, engagement, and searchability in your apps.