Name: PixVerse v6 Max Text-to-Video and Image-to-Video API
Brand: magicapi
SKU: api-magicapi-text-to-video-high-quality-pixverse-pixverse-v6-max
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎬 Text-to-Video and Image-to-Video API (PixVerse v6 Max)

## Overview
PixVerse v6 Max is a video generation model from PixVerse. Its developer describes it as its highest-quality video model, generating up to 15 seconds of 1080p video with synchronized audio from text or an image.

Send a text `prompt` to generate a video, or add an `image` to use it as the first frame. Choose the resolution with `quality` (360p to 1080p), the length with `duration` (5, 8, 10 or 15 seconds) and turn on generated audio with `generate_audio_switch`. Each request returns the URL of one MP4 video.

## Features
- **Text-to-video**: describe the scene, subjects and camera movement in `prompt` (up to 5000 characters for text-to-video).
- **Image-to-video**: pass an `image` to use as the first frame (prompt up to 2048 characters for image-to-video).
- **Resolutions**: `360p`, `540p`, `720p` (default) and `1080p` through `quality`.
- **Durations**: `5` (default), `8`, `10` or `15` seconds through `duration`.
- **Aspect ratios**: `16:9` (default), `9:16` or `1:1` for text-to-video. `aspect_ratio` is ignored when `image` is provided.
- **Generated audio**: `generate_audio_switch` adds AI-generated audio, including background music, sound effects and character dialogue.
- **Multi-shot sequences**: `generate_multi_clip_switch` generates multi-shot sequences with scene transitions.
- **Negative prompt and seed**: list elements to avoid with `negative_prompt`, and set `seed` to reproduce a result.

## Use Cases
1. **Social and marketing clips**: short vertical (`9:16`) or square (`1:1`) videos with sound for ads and posts.
2. **Animating still images**: turn a product photo or illustration into a moving shot with `image`.
3. **Storyboards and previews**: multi-shot sequences with `generate_multi_clip_switch` to test a scene before production.
4. **Lifestyle and ambient footage**: calm scenes with natural light and matching background audio, as in the example.

## Visual Examples
### Example Input
A text-to-video request: 5 seconds at `540p` in `16:9`, with generated audio and without multi-shot.

Prompt: "Warm morning sunlight streams through tall windows onto a wooden floor. A woman in off-white cotton loungewear holds a mug by the window while a light breeze moves the fabric. Slow push-in, soft natural light, calm mood."

```json
{
  "prompt": "Warm morning sunlight streams through tall windows onto a wooden floor. A woman in off-white cotton loungewear holds a mug by the window while a light breeze moves the fabric. Slow push-in, soft natural light, calm mood.",
  "quality": "540p",
  "duration": 5,
  "aspect_ratio": "16:9",
  "generate_audio_switch": true,
  "generate_multi_clip_switch": false
}
```

### Example Output
A 5-second 540p video with generated audio.

[Watch the example output](https://blog.api.market/wp-content/uploads/2026/10/pixverse-v6-max-output-zwqmmsvn-api-market.mp4)

## Input Parameters
| Field | Type | Required | Default | Allowed values | Description |
| --- | --- | --- | --- | --- | --- |
| `prompt` | string | Yes |  |  | Text prompt for video generation. Supports detailed, multi-shot prompts up to 5000 characters for text-to-video, 2048 for image-to-video. |
| `image` | string (URL) | No | none |  | Image to use for the first frame of the video. If provided, the video is generated from this image. |
| `quality` | string | No | `720p` | `360p`, `540p`, `720p`, `1080p` | Resolution of the video. Higher resolutions cost more (see Pricing). |
| `aspect_ratio` | string | No | `16:9` | `16:9`, `9:16`, `1:1` | Aspect ratio of the video. Only used for text-to-video. Ignored when image is provided. |
| `duration` | integer | No | `5` | `5`, `8`, `10`, `15` | Duration of the video in seconds. Billing is per second. |
| `negative_prompt` | string | No | `""` |  | Negative prompt to avoid certain elements in the video |
| `seed` | integer | No | none |  | Random seed. Set for reproducible generation |
| `generate_audio_switch` | boolean | No | `false` |  | Enable AI-generated audio including background music, sound effects, and character dialogue |
| `generate_multi_clip_switch` | boolean | No | `false` |  | Enable multi-shot generation for cinematic sequences with scene transitions |

## Pricing
- **Pay As You Go (PAYG) pricing**: you only pay for what you use.
- **Price**: $0.075 per API unit.
- **1 API unit = 1 second of output video, rounded up per request.** A request is billed on the requested `duration`.
- **Resolution and audio set the price per second** (unit price x factor):

| `quality` | Without audio | With audio (`generate_audio_switch` `true`) |
| --- | --- | --- |
| `360p` | $0.075 per second (x1) | $0.1125 per second (x1.5) |
| `540p` | $0.1125 per second (x1.5) | $0.137475 per second (x1.833) |
| `720p` | $0.137475 per second (x1.833) | $0.1875 per second (x2.5) |
| `1080p` | $0.275025 per second (x3.667) | $0.350025 per second (x4.667) |

- When `quality` and `generate_audio_switch` are left out, `720p` without audio applies: $0.137475 per second, so a default 5-second request costs $0.687375.
- `image`, `aspect_ratio`, `generate_multi_clip_switch`, `negative_prompt` and `seed` do not change the price.
- **Example cost**: the example asked for 5 seconds at `540p` with audio: 5 x $0.137475 = $0.687375.
- **Failed or cancelled predictions are not billed.**
- **GET requests to check prediction status** are free and don't count toward API unit usage.
- **No monthly subscription fee.**

## API Documentation

### Base URL
All API requests go to: `https://prod.api.market/api/v1/magicapi/text-to-video-high-quality-pixverse-pixverse-v6-max`

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

### Asynchronous Processing
**IMPORTANT**: This API is asynchronous. The flow is:
1. Send a POST request to `/predictions`. A successful request returns **201 Created** with a prediction `id` and a `status` of `starting` or `processing`.
2. Poll GET `/predictions/{id}` with that ID.
3. Keep polling while `status` is `starting` or `processing`.
4. Stop when `status` is `succeeded` (read `output`), `failed` or `canceled` (read `error`).

The example took 67 seconds from creation to completion; longer and higher-resolution videos take longer. A polling interval of 2 seconds and an overall timeout of 900 seconds (15 minutes) work well.

### Endpoints

#### Create a Prediction
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/text-to-video-high-quality-pixverse-pixverse-v6-max/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "pixverse/pixverse-v6-max",
    "input": {
      "prompt": "Warm morning sunlight streams through tall windows onto a wooden floor. A woman in off-white cotton loungewear holds a mug by the window while a light breeze moves the fabric. Slow push-in, soft natural light, calm mood.",
      "quality": "540p",
      "duration": 5,
      "aspect_ratio": "16:9",
      "generate_audio_switch": true,
      "generate_multi_clip_switch": false
    }
  }'
```

Response (201 Created):
```json
{
  "id": "zwqmmsvn5drmy0d1f4wtcpfsrm",
  "version": "pixverse/pixverse-v6-max",
  "status": "starting",
  "created_at": "2026-10-26T17:19:31.271Z"
}
```

#### Check Prediction Status
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/text-to-video-high-quality-pixverse-pixverse-v6-max/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Response when the prediction has finished (200 OK):
```json
{
  "id": "zwqmmsvn5drmy0d1f4wtcpfsrm",
  "status": "succeeded",
  "output": "https://blog.api.market/wp-content/uploads/2026/10/pixverse-v6-max-output-zwqmmsvn-api-market.mp4",
  "error": null,
  "created_at": "2026-10-26T17:19:31.271Z",
  "started_at": "2026-10-26T17:19:31.294Z",
  "completed_at": "2026-10-26T17:20:38.335Z"
}
```

`output` is a single URL string pointing to the generated MP4 video.

### Status Codes
- **201 Created**: prediction created (POST `/predictions`). This is the normal success response.
- **200 OK**: prediction details returned (GET `/predictions/{id}`).
- **400 Bad Request**: invalid input, for example a missing `prompt`, or a `quality` or `duration` that is not in the list.
- **401 Unauthorized**: missing or invalid API key.
- **404 Not Found**: no prediction with that ID.
- **429 Too Many Requests**: rate limit exceeded.
- **500 Internal Server Error** or **503 Service Unavailable**: temporary server problem; retry later.

## Rate Limits
All plans allow 10 requests per second. Requests above that return `429 Too Many Requests`; back off before retrying. 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
- Check the HTTP status code of every request and read the response body for the error message.
- A prediction can also end with `status` set to `failed`; the `error` field then explains why. Failed predictions are not billed.
- Retry 429, 500 and 503 responses with exponential backoff. Fix the input before retrying a 400.

## Implementation Guide
### Example Code

#### JavaScript
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/text-to-video-high-quality-pixverse-pixverse-v6-max";

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

  if (response.status !== 201) {
    throw new Error(`API error: ${response.status} ${await response.text()}`);
  }

  const prediction = await response.json();
  return pollForResults(prediction.id);
}

const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function pollForResults(predictionId) {
  const maxTimeout = 900000;
  const pollInterval = 2000;
  const startTime = Date.now();

  while (Date.now() - startTime < maxTimeout) {
    const response = await fetch(`${baseUrl}/predictions/${predictionId}`, {
      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 delay(pollInterval);
  }

  throw new Error("Prediction timed out after 15 minutes");
}

createAndWaitForPrediction({
  "prompt": "Warm morning sunlight streams through tall windows onto a wooden floor. A woman in off-white cotton loungewear holds a mug by the window while a light breeze moves the fabric. Slow push-in, soft natural light, calm mood.",
  "quality": "540p",
  "duration": 5,
  "aspect_ratio": "16:9",
  "generate_audio_switch": true,
  "generate_multi_clip_switch": false
}).then((output) => console.log(output));
```

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

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/text-to-video-high-quality-pixverse-pixverse-v6-max"


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": "pixverse/pixverse-v6-max", "input": input_data},
    )

    if response.status_code != 201:
        raise Exception(f"API error: {response.status_code} {response.text}")

    return poll_for_results(response.json()["id"])


def poll_for_results(prediction_id):
    max_timeout = 900
    poll_interval = 2
    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"] in ("failed", "canceled"):
            raise Exception(f"Prediction {prediction['status']}: {prediction.get('error') or 'Unknown error'}")

        time.sleep(poll_interval)

    raise Exception("Prediction timed out after 15 minutes")


print(create_and_wait_for_prediction({
    "prompt": "Warm morning sunlight streams through tall windows onto a wooden floor. A woman in off-white cotton loungewear holds a mug by the window while a light breeze moves the fabric. Slow push-in, soft natural light, calm mood.",
    "quality": "540p",
    "duration": 5,
    "aspect_ratio": "16:9",
    "generate_audio_switch": True,
    "generate_multi_clip_switch": False
}))
```

## FAQ
- **How do I animate an existing image?**
  - Pass its URL as `image`. It becomes the first frame of the video. `aspect_ratio` is ignored in this mode, and the prompt can be up to 2048 characters.
- **What does a request cost?**
  - The requested `duration` in seconds times the per-second price for your `quality` and audio setting. A default request (5 seconds, `720p`, no audio) costs $0.687375; a 15-second `1080p` video with audio costs 15 x $0.350025 = $5.250375.
- **Does turning on audio cost more?**
  - Yes. With `generate_audio_switch` set to `true` the per-second price is higher at every resolution; see the table under Pricing.
- **Can I make a video with several shots?**
  - Yes. Set `generate_multi_clip_switch` to `true` for a multi-shot sequence with scene transitions, and describe the shots in `prompt`.
- **Is the 201 response from POST an error?**
  - No. 201 Created means the prediction was accepted. Use the returned `id` to poll GET `/predictions/{id}` until `status` is `succeeded`, `failed` or `canceled`.
- **What if my prediction fails?**
  - Failed predictions are not billed. Read the `error` field, adjust the input and try again.

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


Create 5 to 15 second videos from text or a first-frame image with PixVerse v6 Max, 360p to 1080p, optional audio. From $0.075 per second.