Name: Omni Human – Create Talking Head Videos | $0.17/call | API.market
Brand: magicapi
SKU: api-magicapi-ai-media-to-animated-video-api
Availability: InStock
Rating: 5.00 (1 reviews)
Author: API Market

Shashank Agarwal

# 🎥 Omni Human Video Creator API - Pro Quality (Omni-Human)

## Overview
The Omni Human Video Creator API (Omni-Human) transforms your audio, video, or static images into high-quality realistic videos. Designed for content creators, marketing teams, education providers, and more, this AI-driven API quickly and efficiently generates professional-grade videos. Simply provide an input image (or video) and audio (up to 15 seconds for optimal quality), and the API will output a seamless realistic video with the “talking head” effect or other advanced realistic features.

## Features
- Rapid conversion of static images into realistic videos
- Supports audio (MP3, WAV, etc.), short videos, and multiple image formats
- Asynchronous processing with quick turnaround times
- High-fidelity results up to 15 seconds in length for best quality
- Simple, pay-as-you-go pricing model

## Use Cases
1. Marketing and Advertisements:
   - Create realistic spokespeople or promotional narratives from static product images.
   - Grab audience attention by producing short, dynamic video ads.

2. E-Learning and Training Platform:
   - Convert instructor headshots and short audio clips into engaging video lectures.
   - Reduce production costs while maintaining high-quality, consistent video content.

3. News and Media Outlets:
   - Generate quick, on-demand talking head segments to accompany breaking news.
   - Save time by automating repetitive voiceover and face video tasks.

4. Virtual Events and Webinars:
   - Create realistic guest speakers or announcements from simple images and audio snippets.
   - Keep virtual attendees engaged with fresh, innovative content.

5. Content Creators and Influencers:
   - Turn voiced-over scripts into fully realistic avatar videos to post on social media.
   - Quickly create persona-driven content without on-camera filming.

## Visual Examples

Below are some example inputs and resulting outputs. These demonstrate how the API can bring your images and audio to life:

### Example Input
![Input portrait image of a talking subject](https://replicate.delivery/pbxt/NSVCZtHBKfQIQnoDEhoehnlyvDxrbZIyN4bUlpB4YiKCzl5e/image.png)

Audio file:  
(For reference, this is an audio clip used as input)  
https://replicate.delivery/pbxt/NSVCaWKzBxsoYSGGDvXNbyYAANdTI1LtQPGpHxyKTCxtaMo3/ElevenLabs_2025-08-01T09_30_34_Laura_pre_sp100_s50_sb75_v3.mp3

### Example Output
![realistic video showing the subject speaking](https://replicate.delivery/xezq/7NnugYQBvr4FKVVdy8wX9bXxKBNLfpsUPNx5hJNGjXEX6RjKA/tmpqj06mwp7.mp4)

These examples illustrate how the API takes a face or character image plus an audio clip and produces a realistic realistic video.

## Pricing
- Pay As You Go (PAYG): You only pay for what you use.
- 1 API unit = $0.17 = 1 video
- GET requests to check prediction status (GET /api/v1/magicapi/ai-media-to-realistic-video-api/predictions/{id}) are free and do not consume any units.  
- No monthly subscription fees or usage limits. You are billed solely based on your number of calls.

## API Documentation

### Base URL
All requests to this API should be made to:  
```
https://prod.api.market/api/v1/magicapi/ai-media-to-realistic-video-api
```

### Authentication
Include your API key in the request header:
```
x-api-market-key: YOUR_API_MARKET_KEY
```
Make sure you keep your API key secure and never expose it publicly.

### Asynchronous Processing
This API processes requests asynchronously. The usual flow is:

1. Submit a prediction request via the POST endpoint.
2. Receive a job ID in the response (prediction ID).
3. Poll the GET endpoint with the ID to check status.
4. Continue polling until the status changes to “succeeded” or “failed.”

Typical wait times can range from a few seconds up to a few minutes, depending on complexity. Implement the following best practices:

- Poll at 1-second intervals.
- Limit total wait time to 600 seconds (10 minutes).
- When status is “succeeded,” retrieve your results from the response.
- If “failed,” handle the error in your application.

### Endpoints

#### 1) Create a Prediction
POST /api/v1/magicapi/ai-media-to-realistic-video-api/predictions

Use this endpoint to start a new prediction (realistic video creation).

• Method: POST  
• Endpoint: /predictions  
• Required request body:

```json
{
  "version": "10001bfedccf0315f8c0ffac688929669d75077cc96c323f8b33a8438d5793b1",
  "input": {
    "image": "https://example.com/image.jpg",
    "audio": "https://example.com/audio.mp3"
  }
}
```

(Note: The “version” is the model version ID.)

Example (cURL):
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/ai-media-to-realistic-video-api/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "10001bfedccf0315f8c0ffac688929669d75077cc96c323f8b33a8438d5793b1",
    "input": {
      "image": "https://replicate.delivery/pbxt/NSVCZtHBKfQIQnoDEhoehnlyvDxrbZIyN4bUlpB4YiKCzl5e/image.png",
      "audio": "https://replicate.delivery/pbxt/NSVCaWKzBxsoYSGGDvXNbyYAANdTI1LtQPGpHxyKTCxtaMo3/ElevenLabs_2025-08-01T09_30_34_Laura_pre_sp100_s50_sb75_v3.mp3"
    }
  }'
```

A typical successful response might look like:
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "10001bfedccf0315f8c0ffac688929669d75077cc96c323f8b33a8438d5793b1",
  "status": "starting",
  "created_at": "2025-08-17T17:19:36.859Z"
}
```

#### 2) Get Prediction Status
GET /api/v1/magicapi/ai-media-to-realistic-video-api/predictions/{id}

Fetch the current status of a prediction and retrieve its output when complete.

• Method: GET  
• Endpoint: /predictions/{id} (replace {id} with the received prediction ID)  
• Example (cURL):
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/ai-media-to-realistic-video-api/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Example response when “succeeded”:
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": "https://replicate.delivery/xezq/7NnugYQBvr4FKVVdy8wX9bXxKBNLfpsUPNx5hJNGjXEX6RjKA/tmpqj06mwp7.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"
}
```

Check this endpoint repeatedly until the status becomes “succeeded” or “failed.”

## Status Codes
- 200 OK - Request successful (usually for GET).
- 201 Created - Resource created successfully (usually for POST).
- 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 (invalid prediction ID).
- 429 Too Many Requests - Rate limit exceeded.
- 500 Internal Server Error - Server-side error occurred.
- 503 Service Unavailable - Temporary service unavailability.

Each error contains a JSON response with additional detail. Adjust your application’s logic accordingly when these responses are encountered.

## Rate Limits
Like most APIs, there may be rate limits in place to prevent abuse and ensure stability. If you exceed the allowed number of requests in a given time period, you will receive a 429 (Too Many Requests) response. Implement exponential backoff or wait before retrying.

## Error Handling
If an error occurs, the API returns a JSON object describing the issue:

```json
{
  "error": {
    "code": "invalid_parameter",
    "message": "The parameter 'image' is required",
    "status": 400
  }
}
```

Common errors to watch for:
- Missing required parameters
- Invalid media URLs
- Failed predictions (e.g., the system couldn’t properly process the audio)

Implement retry logic for transient network issues. If the status is “failed,” the request cannot be recovered, so address the root cause before retrying.

## Implementation Guide

Below is sample code demonstrating best practices for polling, timeouts, and error handling.

### JavaScript Example

```javascript
// JavaScript example with proper polling and timeout
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/ai-media-to-realistic-video-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-api-market-key": apiKey
      },
      body: JSON.stringify({
        version: "10001bfedccf0315f8c0ffac688929669d75077cc96c323f8b33a8438d5793b1",
        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) {
    // Check prediction status
    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
# Python example with proper polling and timeout
import requests
import time

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/ai-media-to-realistic-video-api"

def create_and_wait_for_prediction(input_data):
    # Step 1: Create the prediction
    headers = {
        "Content-Type": "application/json",
        "x-api-market-key": API_KEY
    }
    payload = {
        "version": "10001bfedccf0315f8c0ffac688929669d75077cc96c323f8b33a8438d5793b1",
        "input": input_data
    }

    response = requests.post(f"{BASE_URL}/predictions", headers=headers, json=payload)
    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"]

    # Step 2: Poll for results
    return poll_for_results(prediction_id)

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

    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()
        status = prediction["status"]

        if status == "succeeded":
            return prediction["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")
```

### cURL Example

```bash
# Step 1: Create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/ai-media-to-realistic-video-api/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "10001bfedccf0315f8c0ffac688929669d75077cc96c323f8b33a8438d5793b1",
    "input": {
      "image": "https://example.com/image.jpg",
      "audio": "https://example.com/audio.mp3"
    }
  }'

# You will receive a response containing a JSON object with an ID:
# {
#   "id": "abcd1234",
#   "status": "starting",
#   ...
# }

# Step 2: Check prediction status
curl -X GET "https://prod.api.market/api/v1/magicapi/ai-media-to-realistic-video-api/predictions/abcd1234" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"

# Keep polling until "status": "succeeded".
```

## Performance Optimization
- Keep audio clips under 15 seconds to maintain high-quality results.
- Use efficient polling intervals (1 second is usually sufficient).
- Minimize unnecessary requests (e.g., do not poll multiple times per second).
- If you plan on bulk processing, consider batching your requests where possible.

## FAQ
1. How long does it take to process a request?  
   Typically under a minute, but can vary depending on server load and complexity.

2. Can I upload longer audio files?  
   Yes, but expect diminished video quality after 15 seconds and longer processing times. Splitting longer audio into 15-second clips is recommended.

3. What image formats are supported?  
   Common formats (PNG, JPG) are supported. Ensure the image depicts a single subject for best results.

4. Is there a limit to video resolution or size?  
   For optimal performance, use images around standard portrait resolution. Extremely high-resolution images can slow processing.

5. How do I contact support?  
   You can use the chat in the bottom right corner of the page or email hello[at]api.market.

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

Turn a photo and audio into a realistic talking head video. Supports audio up to 15 seconds for high-quality results. Try it free on API.market.

Omni Human – Create Talking Head Videos | $0.17/call | API.market

🎥 Animated Video Creator API - Pro Quality (Omni-Human)

PAYG

MagicAPI

the omni human video creator api is super handy—turns images or audio into smooth, realistic videos fast. great for ads, teaching, or creators who want pro-looking content without hassle.