Name: MMAudio V2 – Generate Audio for Video | $0.01/call | API.market
Brand: magicapi
SKU: api-magicapi-video-to-audio-synthesis-api
Availability: InStock
Rating: 5.00 (1 reviews)
Author: API Market

Shashank Agarwal

# 🔊 High-Quality Video-to-Audio Generator API (MMAudio V2)

## Overview
The High-Quality Video-to-Audio Generator API (MMAudio V2) automatically generates rich, synchronized audio for your videos using advanced AI techniques. By analyzing your video content, it creates an immersive, high-fidelity audio track that complements motion and timing for seamless integration into your production workflow.

## Features
- • Intelligent video analysis to accurately match sound effects or ambience with on-screen action  
- • Advanced text prompt support for guiding audio generation style and content  
- • Negative prompt support to eliminate undesired audio elements  
- • Configurable duration, number of inference steps, and seed randomness  
- • Optional experimental image-based audio generation  

## Use Cases
1. Film Post-Production: Quickly add atmospheric sound or background scoring to unedited video footage.  
2. Marketing & Advertising: Enhance silent promotional clips with on-brand audio, music, or effects.  
3. Gaming & VR: Generate dynamic sound effects that sync with streaming or immersive environments.  
4. Podcast Video Content: Import raw video content with minimal audio and automatically fill it with relevant sound.  
5. Prototyping & Storyboarding: Rapidly experiment with different audio tracks before finalizing a soundtrack.

## Examples

Below is an example of an input video where a horse is galloping. The API can generate a synchronized audio track to match the visual.

### Input Video
![A sample horse galloping video used for audio generation](https://huggingface.co/hkchengrex/MMAudio/resolve/main/examples/sora_galloping.mp4)

Here is an example output (video with embedded audio) demonstrating the result:

### Output Video
![Generated audio track applied to the video using MMAudio V2](https://replicate.delivery/xezq/Tckf6OZjDlQ2Q6Zq0RHSfu2S4CHbfSj2YoYtzjxsI3OlCb9oA/20250402_115808.mp4)

## Pricing
• 1 API unit equals 1 image processed (in this context, each generation request counts as one unit).  
• GET requests to check prediction status (GET /api/v1/magicapi/video-to-audio-synthesis-api/predictions/{id}) are free and do not count toward API unit usage.  
• Different pricing tiers are available based on usage volume.

## API Documentation

### Base URL
All API requests should be made to:  
```
https://prod.api.market/api/v1/magicapi/video-to-audio-synthesis-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 typical flow is:

1. Submit a prediction request to the POST /predictions endpoint.  
2. Receive a prediction ID in the response.  
3. Poll the GET /predictions/{id} endpoint with the prediction ID to check status.  
4. Continue polling until the prediction is complete.  

Processing time varies based on complexity. Your code should:
- Poll at 1-second intervals.
- Use a maximum overall timeout of 600 seconds (10 minutes).
- Continue while status is “starting” or “processing.”
- Handle “succeeded” (use the result) or “failed” (error handling).

### Endpoints

#### POST /api/v1/magicapi/video-to-audio-synthesis-api/predictions
Create a new audio generation prediction.

Example request body:
```json
{
  "version": "62871fb59889b2d7c13777f08deb3b36bdff88f7e1d53a50ad7694548a41b484",
  "input": {
    "seed": -1,
    "video": "https://huggingface.co/hkchengrex/MMAudio/resolve/main/examples/sora_galloping.mp4",
    "prompt": "galloping",
    "duration": 8,
    "num_steps": 25,
    "cfg_strength": 4.5,
    "negative_prompt": "music"
  }
}
```

Example cURL:
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/video-to-audio-synthesis-api/predictions" \
  -H "Content-Type: application/json" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "62871fb59889b2d7c13777f08deb3b36bdff88f7e1d53a50ad7694548a41b484",
    "input": {
      "seed": -1,
      "video": "https://huggingface.co/hkchengrex/MMAudio/resolve/main/examples/sora_galloping.mp4",
      "prompt": "galloping",
      "duration": 8,
      "num_steps": 25,
      "cfg_strength": 4.5,
      "negative_prompt": "music"
    }
  }'
```

A successful response will include a unique prediction ID and the initial status:
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "62871fb59889b2d7c13777f08deb3b36bdff88f7e1d53a50ad7694548a41b484",
  "status": "starting",
  "created_at": "2025-04-21T10:44:10.447Z"
}
```

#### GET /api/v1/magicapi/video-to-audio-synthesis-api/predictions/{id}
Retrieve the status and output of an existing prediction. Replace {id} with the prediction ID from the POST response.

Example cURL:
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/video-to-audio-synthesis-api/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY"
```

A successful response might look like:
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": "https://some.delivery.location/20250402_115808.mp4",
  "created_at": "2023-01-01T12:00:00.000Z",
  "started_at": "2023-01-01T12:00:05.000Z",
  "completed_at": "2023-01-01T12:01:00.000Z"
}
```

## Status Codes
- 200 OK: The request was successful.  
- 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: The requested resource or prediction does not exist.  
- 429 Too Many Requests: Rate limit exceeded.  
- 500 Internal Server Error: Issue on the server side.  
- 503 Service Unavailable: Service is temporarily unavailable.

## Rate Limits
The API may enforce rate limits depending on your subscription tier. If you exceed your allowed requests within a specific window, you’ll receive a 429 Too Many Requests response. In such cases:
- Back off and retry after the given Retry-After header delay.  
- Consider upgrading to a higher-tier plan for more requests per minute/hour.

## Error Handling
When an error occurs, the API will return a JSON object describing what happened. For instance:
```json
{
  "error": {
    "code": "invalid_parameter",
    "message": "The parameter 'video' is required",
    "status": 400
  }
}
```
Common errors include missing input parameters, unsupported file formats, or an invalid API key. In such cases:
- Check the message field for details.
- Correct the request parameters or authentication.
- Retry if the issue is transient (e.g., an intermittent server error).

## Implementation Guide

### Example Code

Below are code examples showing how to interact with the API, including creating a prediction and polling for its result.

#### JavaScript (Node.js) Example
```javascript
// JavaScript example with proper polling and timeout
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/video-to-audio-synthesis-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 between checks
  const startTime = Date.now();

  while (Date.now() - startTime < MAX_TIMEOUT) {
    // Check prediction status
    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");
}
```

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

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/video-to-audio-synthesis-api"

def create_and_wait_for_prediction(input_data):
    # Step 1: Create the prediction
    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 != 200 and response.status_code != 201:
        raise Exception(f"API error: {response.status_code} {response.text}")

    prediction = response.json()
    prediction_id = prediction["id"]

    # Step 2: Poll for results with timeout
    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
    start_time = time.time()

    while time.time() - start_time < MAX_TIMEOUT:
        headers = {"x-magicapi-key": API_KEY}
        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()
        status = prediction.get("status")

        if status == "succeeded":
            return prediction.get("output")
        if 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")
```

#### Bash (cURL) Example
```bash
# Step 1: Create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/video-to-audio-synthesis-api/predictions" \
  -H "Content-Type: application/json" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY" \
  -d '{
    "input": {
      "video": "https://huggingface.co/hkchengrex/MMAudio/resolve/main/examples/sora_galloping.mp4",
      "prompt": "galloping"
    }
  }'

# The response will contain a prediction ID, e.g.:
# {"id": "abcd1234", "status": "starting"}

# Step 2: Check prediction status using the provided ID
curl -X GET "https://prod.api.market/api/v1/magicapi/video-to-audio-synthesis-api/predictions/abcd1234" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY"

# Poll this endpoint until "status" is "succeeded" or "failed".
```

### Performance Optimization
- Provide concise prompts to reduce processing time.  
- Keep video duration to the necessary minimum.  
- Use efficient polling to avoid excessive requests (1-second intervals are sufficient).  
- Cache repeated requests if your use case allows it.

## FAQ
1. How long does a typical prediction take?  
   - It varies, but most requests complete within a few seconds to a couple of minutes.  
2. Can I generate multiple audio tracks simultaneously?  
   - Yes, you can submit multiple predictions, but keep rate limits in mind.  
3. Does the API support audio for long-format videos?  
   - Long videos can be processed, though it may increase processing time and usage costs.  
4. Can I use negative prompts to completely remove certain sounds?  
   - Negative prompts help guide the AI by indicating which audio characteristics to avoid, though results may vary.  

## 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 synchronized, context-aware audio for any video. Guide sound with text prompts. From $0.01/call. Try it free on API.market.