Name: react-1 API: Lipsync with Emotion Control by Sync Labs
Brand: magicapi
SKU: api-magicapi-realistic-lipsync-ai-sync-react-1
Availability: InStock
Author: API Market

Shashank Agarwal

# 👄 Realistic Lipsync API with Emotions (Sync Labs react-1)

## Overview
react-1 is a lipsync model from Sync Labs with control over facial emotion. You send a video of a person and an audio track, and the model returns a video in which the person's mouth follows the new audio. You can also pick an emotion for the generation (`happy`, `sad`, `angry`, `disgusted`, `surprised` or `neutral`) and choose how much of the face the model edits: only the lips, the face, or the whole head.

Only `video` and `audio` are required. Each request returns the URL of one video.

## Features
- **Lipsync to new audio:** `video` is an input video file (.mp4) and `audio` is an input audio file (.wav in the schema). Both are passed as URLs.
- **Emotion:** `emotion` takes one single-word emotion: `happy`, `sad`, `angry`, `disgusted`, `surprised` or `neutral` (the default).
- **Edit region:** `model_mode` sets what the model edits: `lips`, `face` (the default) or `head`. With `head`, the model also generates natural talking head movements along with the emotion and lipsync.
- **Out-of-sync lengths:** `sync_mode` sets what happens when the audio and video durations differ: `loop` (the default), `bounce`, `cut_off`, `silence` or `remap`.
- **Expressiveness:** `temperature` from 0 to 1 (default 0.5) sets how expressive the lipsync can be.

## Use Cases
- **Dubbing and localization:** match a speaker's lips to a translated voice track, with an emotion that fits the line.
- **Dialogue fixes:** replace a line of dialogue after the shoot without reshooting.
- **AI avatars and presenters:** make a generated or recorded presenter speak a new script, and choose whether only the mouth or the whole head moves.
- **Personalized video messages:** reuse one recording with different audio for each recipient.

## Visual Examples
This is a real request sent through api.market and the file it returned.

Inputs used: `video` and `audio` as shown below, with `emotion` set to "happy". All other fields were left at their defaults (`model_mode` "face", `sync_mode` "loop", `temperature` 0.5).

**Input video (`video`):** [Watch the input video](https://blog.api.market/wp-content/uploads/2026/10/p-video-avatar-output-api-market.mp4)

**Input audio (`audio`):** [Listen to the input audio](https://blog.api.market/wp-content/uploads/2026/10/realtime-tts-1.5-max-output-api-market.mp3)

**Output video:** [Watch the example video](https://blog.api.market/wp-content/uploads/2026/10/react-1-output-api-market.mp4)

The input audio was an MP3 file, even though the schema describes `audio` as .wav, and the request succeeded. The returned video was 5.459 seconds long.

## Pricing
- **Pay As You Go (PAYG) pricing:** you only pay for what you use.
- **Price:** $0.21 per API unit.
- **1 API unit** = 1 second of output video, rounded up to the next whole second. There are no variants or tiers: every second costs the same.
- **Worked example:** a 5 second output video is 5 units = $1.05. The example above returned 5.459 seconds of video, which rounds up to 6 units = $1.26.
- **Failed or cancelled predictions** are not billed.
- **GET requests** to check prediction status (GET /api/v1/magicapi/realistic-lipsync-ai-sync-react-1/predictions/{id}) are free and don't count toward API unit usage.
- **No monthly subscription fee.**

## API Documentation

### Base URL
`https://prod.api.market/api/v1/magicapi/realistic-lipsync-ai-sync-react-1`

### Authentication
Send your api.market API key in the `x-api-market-key` header on every request:
```
x-api-market-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing
**IMPORTANT:** This API is asynchronous.
1. POST `/predictions` with the model `version` and your `input`.
2. The API returns **201 Created** with a prediction `id` and a `status` of `starting` or `processing`. 201 means the request was accepted; it is not an error.
3. Poll GET `/predictions/{id}` until `status` is `succeeded`, `failed` or `canceled`.
4. When `status` is `succeeded`, `output` holds the URL of the generated video.
5. When `status` is `failed`, the `error` field explains why.

The example request above took about 4 minutes to finish, so allow a generous timeout when polling.

### Endpoints

#### Create a Prediction
`POST /predictions`

```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/realistic-lipsync-ai-sync-react-1/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "c44d8de5ebd918b788e8c0f09a550b60c095d1c6873c2c1abfe3fd8ba3c77fd8",
    "input": {
      "video": "https://blog.api.market/wp-content/uploads/2026/10/p-video-avatar-output-api-market.mp4",
      "audio": "https://blog.api.market/wp-content/uploads/2026/10/realtime-tts-1.5-max-output-api-market.mp3",
      "emotion": "happy"
    }
  }'
```

Response (201 Created):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "c44d8de5ebd918b788e8c0f09a550b60c095d1c6873c2c1abfe3fd8ba3c77fd8",
  "status": "starting",
  "created_at": "2026-10-13T11:10:00.306Z"
}
```

#### Check Prediction Status
`GET /predictions/{id}`

```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/realistic-lipsync-ai-sync-react-1/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Response (200 OK) once the prediction has finished:
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "input": {
    "video": "https://blog.api.market/wp-content/uploads/2026/10/p-video-avatar-output-api-market.mp4",
    "audio": "https://blog.api.market/wp-content/uploads/2026/10/realtime-tts-1.5-max-output-api-market.mp3",
    "emotion": "happy"
  },
  "output": "https://blog.api.market/wp-content/uploads/2026/10/react-1-output-api-market.mp4",
  "error": null,
  "created_at": "2026-10-13T11:10:00.306Z",
  "started_at": "2026-10-13T11:10:01.306Z",
  "completed_at": "2026-10-13T11:13:42.806Z"
}
```

### Input Parameters
| Parameter | Type | Required | Default | Allowed values | Description |
|---|---|---|---|---|---|
| `video` | string (URL) | Yes | none |  | Input video file (.mp4) |
| `audio` | string (URL) | Yes | none |  | Input audio file (.wav) |
| `emotion` | string | No | "neutral" | `happy`, `sad`, `angry`, `disgusted`, `surprised`, `neutral` | Emotion prompt for the generation (single word emotions only) |
| `model_mode` | string | No | "face" | `lips`, `face`, `head` | Edit region for the model (lips/face/head). When head is selected, the model generates natural talking head movements along with emotions and lipsync |
| `sync_mode` | string | No | "loop" | `loop`, `bounce`, `cut_off`, `silence`, `remap` | Lipsync mode when audio and video durations are out of sync |
| `temperature` | number | No | 0.5 | 0 to 1 | How expressive lipsync can be (0-1) |

### Output
`output` is a single URL (string) pointing to the generated MP4 video.

## Status Codes
- **200 OK:** prediction status returned.
- **201 Created:** prediction accepted. Poll GET `/predictions/{id}` for the result.
- **400 Bad Request:** invalid or missing input fields.
- **401 Unauthorized:** missing or invalid API key.
- **404 Not Found:** unknown prediction ID.
- **429 Too Many Requests:** too many requests in a short time. Wait and retry.
- **500 Internal Server Error:** server-side error. Retry after a short wait.

## Rate Limits

All plans allow 10 requests per second. Requests above that return `429 Too Many Requests`; back off before retrying and honour any `Retry-After` header. Polling a prediction with GET is free but still counts toward the per-second limit, so poll every 1 to 5 seconds rather than in a tight loop.

## Error Handling
- **Request errors (4xx):** check the response body, fix the input fields and send the request again.
- **Failed predictions:** when GET returns `status: "failed"`, read the `error` field. Failed predictions are not billed.
- **Rate limits (429) and server errors (5xx):** retry with exponential backoff.

## Implementation Guide

### JavaScript
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/realistic-lipsync-ai-sync-react-1";

async function createPrediction(input) {
  const response = await fetch(`${baseUrl}/predictions`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-api-market-key": apiKey
    },
    body: JSON.stringify({ version: "c44d8de5ebd918b788e8c0f09a550b60c095d1c6873c2c1abfe3fd8ba3c77fd8", input })
  });
  if (response.status !== 201 && response.status !== 200) {
    throw new Error(`API error: ${response.status} ${await response.text()}`);
  }
  return response.json();
}

async function waitForPrediction(id, timeoutMs = 1200000, intervalMs = 5000) {
  const start = Date.now();
  while (Date.now() - start < timeoutMs) {
    const response = await fetch(`${baseUrl}/predictions/${id}`, {
      headers: { "x-api-market-key": apiKey }
    });
    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${await response.text()}`);
    }
    const prediction = await response.json();
    if (prediction.status === "succeeded") return prediction.output;
    if (prediction.status === "failed" || prediction.status === "canceled") {
      throw new Error(`Prediction ${prediction.status}: ${prediction.error || "unknown error"}`);
    }
    await new Promise((resolve) => setTimeout(resolve, intervalMs));
  }
  throw new Error("Timed out waiting for the prediction");
}

const prediction = await createPrediction({
  "video": "https://blog.api.market/wp-content/uploads/2026/10/p-video-avatar-output-api-market.mp4",
  "audio": "https://blog.api.market/wp-content/uploads/2026/10/realtime-tts-1.5-max-output-api-market.mp3",
  "emotion": "happy"
});
const output = await waitForPrediction(prediction.id);
console.log(output);
```

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

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/realistic-lipsync-ai-sync-react-1"

def create_prediction(input_data):
    response = requests.post(
        f"{BASE_URL}/predictions",
        headers={"Content-Type": "application/json", "x-api-market-key": API_KEY},
        json={"version": "c44d8de5ebd918b788e8c0f09a550b60c095d1c6873c2c1abfe3fd8ba3c77fd8", "input": input_data},
    )
    if response.status_code not in (200, 201):
        raise Exception(f"API error: {response.status_code} {response.text}")
    return response.json()

def wait_for_prediction(prediction_id, timeout=1200, interval=5):
    start = time.time()
    while time.time() - start < timeout:
        response = requests.get(
            f"{BASE_URL}/predictions/{prediction_id}",
            headers={"x-api-market-key": API_KEY},
        )
        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"] in ("failed", "canceled"):
            raise Exception(f"Prediction {prediction['status']}: {prediction.get('error') or 'unknown error'}")
        time.sleep(interval)
    raise Exception("Timed out waiting for the prediction")

prediction = create_prediction({
  "video": "https://blog.api.market/wp-content/uploads/2026/10/p-video-avatar-output-api-market.mp4",
  "audio": "https://blog.api.market/wp-content/uploads/2026/10/realtime-tts-1.5-max-output-api-market.mp3",
  "emotion": "happy"
})
print(wait_for_prediction(prediction["id"]))
```

### cURL
```bash
# Step 1: create the prediction (returns 201 Created with an id)
curl -X POST "https://prod.api.market/api/v1/magicapi/realistic-lipsync-ai-sync-react-1/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "c44d8de5ebd918b788e8c0f09a550b60c095d1c6873c2c1abfe3fd8ba3c77fd8",
    "input": {
      "video": "https://blog.api.market/wp-content/uploads/2026/10/p-video-avatar-output-api-market.mp4",
      "audio": "https://blog.api.market/wp-content/uploads/2026/10/realtime-tts-1.5-max-output-api-market.mp3",
      "emotion": "happy"
    }
  }'

# Step 2: poll with the returned id until status is succeeded, failed or canceled
curl -X GET "https://prod.api.market/api/v1/magicapi/realistic-lipsync-ai-sync-react-1/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

## FAQ
**Q: Which emotions can I choose?**  
A: `emotion` accepts one of `happy`, `sad`, `angry`, `disgusted`, `surprised` or `neutral`. The default is `neutral`. Only single-word emotions from this list are accepted.

**Q: What is the difference between the `model_mode` options?**  
A: `model_mode` sets the edit region. `lips` edits only the lips, `face` (the default) edits the face, and `head` also generates natural talking head movements along with the emotion and lipsync.

**Q: What happens if my audio and video are different lengths?**  
A: `sync_mode` decides it. The options are `loop` (the default), `bounce`, `cut_off`, `silence` and `remap`. You are billed for the seconds of video the model returns. In the example above, an 8 second input video with 5.4 seconds of audio returned a 5.459 second video.

**Q: Which file formats should I send?**  
A: The schema describes `video` as an .mp4 file and `audio` as a .wav file. Both are passed as URLs. The example on this page used an MP3 audio file and succeeded.

**Q: Is POST returning 201 an error?**  
A: No. 201 Created means the prediction was accepted. Use the returned `id` to poll GET `/predictions/{id}` until `status` is `succeeded`, `failed` or `canceled`.

## 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@magicapi.com.


Lipsync a video to new audio with Sync Labs react-1. Choose an emotion such as happy, sad or surprised and edit the lips, face or head. $0.21 per second.