Name: Sora-2 – Text to Video Generation | $0.13/call | API.market
Brand: magicapi
SKU: api-magicapi-video-generation-with-synced-audio-openai-sora-2
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎥 Synced Audio Video Generation API (Sora-2)

## Overview
The 🎥 Synced Audio Video Generation API (Sora-2) enables developers to create high-quality videos with perfectly synced audio using state-of-the-art AI technology in seconds. Powered by OpenAI's flagship Sora-2 model, it lets you generate synchronized video content based on text prompts and optional image references.

## Features
- **Text-to-Video Generation**: Generate videos based on descriptive text prompts.
- **AI-driven Synchronization**: Ensure that audio and video are perfectly aligned.
- **Custom Duration Control**: Specify video durations of 4, 8, or 12 seconds.
- **Flexible Aspect Ratios**: Choose between portrait (720x1280) and landscape (1280x720) formats.
- **Optional Initial Frame**: Use an image as the first frame for smoother transitions and control.

## Use Cases
- **Marketing and Ads**: Create compelling video advertisements tailored to your brand messaging.
  - Example: "Generate an engaging advertisement showcasing your product with dynamic visuals and synchronized audio."
- **Content Creation**: Produce high-quality video content for social media or blogs on the fly.
  - Example: "Create short tutorial videos with synced explanatory audio to enhance user engagement."
- **Education**: Develop educational videos that combine visual aids with explanatory narration.
  - Example: "Generate short video lessons with descriptive audio for online courses."
- **Entertainment**: Rapidly produce visuals for music videos or short films.
  - Example: "Create a music video where the video dynamically adapts to the song lyrics and rhythm."
- **Training and Simulations**: Generate videos for employee training programs with synchronized narration.
  - Example: "Simulate a customer service scenario with visual and audio elements aligned to the training script."

## Visual Examples
### Example Input
Prompt: "Bob ross in his studio painting the input image on a canvas, recreating the same composition, colors, and details as the reference painting."
Aspect Ratio: Landscape

**Input Reference Image**:
![Bob Ross studio painting](https://blog.api.market/wp-content/uploads/2026/02/painting-api-market.jpg)

### Example Output
**Generated Video**:
![Generated Video](https://blog.api.market/wp-content/uploads/2026/02/bob-painting-api-market.mp4)

## Pricing
- **Pay As You Go (PAYG)**: You only pay for what you use.
- **1 API Unit**: Equals to per second of output video
- **Free GET Requests**: Checking prediction status (GET /api/v1/magicapi/video-generation-with-synced-audio-openai-sora-2/predictions/{id}) is free and does not count toward API unit usage.
- **No Monthly Fees or Limits**: Simple per-call pricing with no hidden costs or usage limits.

## API Documentation

### Base URL
All API requests should be made to: 
```
https://prod.api.market/api/v1/magicapi/video-generation-with-synced-audio-openai-sora-2
```

### Authentication
Include your API key in the request header:
```plaintext
x-api-market-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing
**IMPORTANT**: This API uses asynchronous processing for predictions. The typical flow is:
1. Submit a prediction request to the POST endpoint.
2. Receive a prediction ID in the response.
3. Poll the GET endpoint with the prediction ID to check status.
4. Continue polling until the prediction is complete.

### Endpoints

#### Create a Prediction
```plaintext
POST /api/v1/magicapi/video-generation-with-synced-audio-openai-sora-2/predictions
```

**Request Parameters**:
- version: "763a9321f615f4867b1d7a2d53666200da21f71da358b12c9b25e0127edae014"
- input: {
  - prompt: (string) [required] - Text description of the video.
  - seconds: (integer) [optional] - Duration of the video (default 4).
  - aspect_ratio: (string) [optional] - "portrait" or "landscape" (default "portrait").
  - openai_api_key: (string) [optional] - Your OpenAI API key.
  - input_reference: (uri) [optional] - An image to use as the first frame of the video.

```json
{
  "version": "763a9321f615f4867b1d7a2d53666200da21f71da358b12c9b25e0127edae014",
  "input": {
    "prompt": "Generate a video of a cat playing piano",
    "seconds": 8,
    "aspect_ratio": "landscape",
    "input_reference": "https://example.com/cat.png"
  }
}
```

**Response Example**:
```json
{
  "id": "prediction_id",
  "version": "763a9321f615f4867b1d7a2d53666200da21f71da358b12c9b25e0127edae014",
  "status": "starting",
  "created_at": "2026-02-02T05:28:54.788Z"
}
```

**Curl Example**:
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/video-generation-with-synced-audio-openai-sora-2/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "763a9321f615f4867b1d7a2d53666200da21f71da358b12c9b25e0127edae014",
    "input": {
      "prompt": "Generate a video of a cat playing piano",
      "seconds": 8,
      "aspect_ratio": "landscape"
    }
  }'
```

#### Get Prediction Status
```plaintext
GET /api/v1/magicapi/video-generation-with-synced-audio-openai-sora-2/predictions/{id}
```

**Request Parameter**:
- id (string) [required] - The prediction ID.

**Response Example**:
```json
{
  "id": "prediction_id",
  "status": "succeeded",
  "output": "https://example.com/prediction_output.mp4",
  "created_at": "2026-02-02T05:28:54.788Z",
  "started_at": "2026-02-02T05:28:59.788Z",
  "completed_at": "2026-02-02T05:29:59.788Z"
}
```

**Curl Example**:
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/video-generation-with-synced-audio-openai-sora-2/predictions/prediction_id" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

## Status Codes
- **200 OK**: Request successful.
- **201 Created**: Resource 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 not found.
- **429 Too Many Requests**: Rate limit exceeded.
- **500 Internal Server Error**: Server-side error.
- **503 Service Unavailable**: Service temporarily unavailable.

## Rate Limits
- Ensure handling of rate limit responses.
- Respect rate limits to avoid being throttled.

## Error Handling
- **400 Bad Request**: Validate your input parameters.
- **401 Unauthorized**: Ensure your API key is correct.
- **500 Internal Server Error**: Retry with exponential backoff.

**Error Example**:
```json
{
  "error": {
    "code": "invalid_parameter",
    "message": "The parameter 'prompt' is required",
    "status": 400
  }
}
```

## Implementation Guide

### JavaScript Example
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/video-generation-with-synced-audio-openai-sora-2";

async function createAndWaitForPrediction(inputData) {
  try {
    const response = await fetch(`${baseUrl}/predictions`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "x-api-market-key": apiKey
      },
      body: JSON.stringify({ version: "763a9321f615f4867b1d7a2d53666200da21f71da358b12c9b25e0127edae014", input: inputData })
    });

    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${response.statusText}`);
    }
    const prediction = await response.json();
    const predictionId = prediction.id;
    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 between checks

  const startTime = Date.now();

  while (Date.now() - startTime < MAX_TIMEOUT) {
    const response = await fetch(`${baseUrl}/predictions/${predictionId}`, {
      headers: {
        "x-api-market-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");
}
```

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

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/video-generation-with-synced-audio-openai-sora-2"

def create_and_wait_for_prediction(input_data):
    headers = {
        "Content-Type": "application/json",
        "x-api-market-key": API_KEY
    }
    response = requests.post(
        f"{BASE_URL}/predictions",
        headers=headers,
        json={"version": "763a9321f615f4867b1d7a2d53666200da21f71da358b12c9b25e0127edae014", "input": input_data}
    )
    if response.status_code != 200:
        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 between checks

    headers = {"x-api-market-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")
```

### cURL Example
```bash
# Create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/video-generation-with-synced-audio-openai-sora-2/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "763a9321f615f4867b1d7a2d53666200da21f71da358b12c9b25e0127edae014",
    "input": {
      "prompt": "Generate a video of a cat playing piano",
      "seconds": 8,
      "aspect_ratio": "landscape"
    }
  }'

# Check prediction status
curl -X GET "https://prod.api.market/api/v1/magicapi/video-generation-with-synced-audio-openai-sora-2/predictions/prediction_id" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

## Performance Optimization
- Optimize video duration and aspect ratio based on your needs to minimize processing time and costs.
- Avoid unnecessary retries by implementing proper polling with delays.
- Use concise and accurate prompts to get the best results efficiently.

## FAQ
**1. How do I obtain my API key?**
You can obtain your API key by signing up on API.market and navigating to the API keys section in your account settings.

**2. What video formats are supported?**
The API generates videos in standard formats that can be played on most devices and platforms.

**3. Can I update a prediction after it has started?**
No, predictions cannot be modified once they are initiated. You will need to create a new prediction.

**4. How long does it take to process a video?**
Processing time depends on the complexity of your input. Simple requests may take a few seconds, while more complex ones could take longer.

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

Generate videos with perfectly synced audio from text prompts. 4, 8, or 12 second durations. From $0.13/call. Try it free on API.market.