Name: Veo 3.1 – AI Video Generation | $0.25/call | API.market
Brand: magicapi
SKU: api-magicapi-high-fidelity-video-api-google-veo-31
Availability: InStock
Author: API Market

Shashank Agarwal

# 📹 High-Fidelity Video API with Context-Aware Audio (Veo 3.1)

## Overview
The High-Fidelity Video API with Context-Aware Audio (Veo 3.1) is the latest AI-powered video generation tool offered by API.market. With this API, users can create high-quality video content enhanced with context-aware audio. This upgraded version of Veo 3 includes new capabilities like higher-fidelity videos, reference image support, and last frame transition, all designed to deliver superior video production.

## Features
- **High-fidelity video generation**: Produces videos with exceptional quality.
- **Context-aware audio**: Incorporates audio that matches the video's context.
- **Reference image support**: Allows you to provide up to 3 reference images for subject-consistent video generation.
- **Last frame support**: Creates smooth transitions by using a specified ending frame.
- **Customizable parameters**: Adjust video duration, resolution, aspect ratio, and more.
- **Simple integration**: Easy to integrate into your applications with clear API endpoints.

## Use Cases
1. **Marketing and Advertising**
   - Create promotional videos with high clarity and compelling audio that aligns with the visual content.
   - Use reference images to maintain brand consistency across video campaigns.
   - Generate product demos or advertisements with specified prompts for targeted campaigns.
   
2. **Media and Entertainment**
   - Generate clips for movies, TV shows, or web content that require visual consistency and high-quality production values.
   - Animate scenes from a script with context-aware audio for more immersive content.
   
3. **Education and Training**
   - Create educational videos with custom prompts to deliver instructional content.
   - Use reference images to produce consistent training modules.
   
4. **Social Media Content Creation**
   - Generate short-form videos for social media platforms with high-quality video and audio.
   - Leverage context-aware audio to enhance engagement rates.

5. **Corporate Communications**
   - Produce high-quality internal communication videos.
   - Use specific reference images to maintain corporate branding and consistency in visual content.

## Visual Examples

### Example with a Single Reference Image
#### Input Image
![Reference image for video generation](https://blog.api.market/wp-content/uploads/2025/12/veo-3.1-image-api-market.webp)

#### Prompt
`"the woman is giving an interview for a podcast, wearing a pink top with the logo, it also neatly says 'Veo 3.1', she is in a midcentury modern studio with pink lighting, she talks about using Veo 3.1 with reference images to put things into videos you're making, the logo is also in a framed picture against black behind her"`

#### Output Video
![Generated video based on reference image and prompt](https://blog.api.market/wp-content/uploads/2025/12/veo-3.1-video-api-market.mp4)


## Pricing
- **Pay As You Go (PAYG) pricing**: Only pay for what you use.
- **1 API unit equals 1 video processed**.
- **GET requests to check prediction status** (`GET /api/v1/magicapi/high-fidelity-video-api-google-veo-31/predictions/{id}`) are free and do not count toward API unit usage.
- **No monthly subscription fees or usage limits**: Simple per-call pricing.

## API Documentation

### Base URL
All API requests should be made to: `https://prod.api.market/api/v1/magicapi/high-fidelity-video-api-google-veo-31`

### Authentication
Authentication is handled via API key. Include your key in the request header:
```bash
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.

The processing time varies depending on the complexity of the request. Your code should implement:
- A polling interval of 1 second between status checks.
- A maximum timeout of 600 seconds (10 minutes).
- Status checking logic that continues while status is "starting" or "processing".
- Result handling when status becomes "succeeded".
- Error handling when status becomes "failed" or timeout is reached.

### Endpoints

#### POST /api/v1/magicapi/high-fidelity-video-api-google-veo-31/predictions

Create a prediction using the `google/veo-3.1` model on API.market.

**Request Body:**
```json
{
  "version": "ed5b1767b711dd15d954b162af1e890d27882680f463a85e94f02d604012b972",
  "input": {
    "prompt": "the woman is giving an interview for a podcast, wearing a pink top with the logo, it also neatly says 'Veo 3.1', she is in a midcentury modern studio with pink lighting, she talks about using Veo 3.1 with reference images to put things into videos you're making, the logo is also in a framed picture against black behind her",
    "duration": 8,
    "resolution": "1080p",
    "aspect_ratio": "16:9",
    "generate_audio": true,
    "reference_images": [
      "https://blog.api.market/wp-content/uploads/2025/12/veo-3.1-image-api-market.webp",
      "https://blog.api.market/wp-content/uploads/2025/05/API.market-Square-Logo.png"
    ]
  }
}
```

#### Example Curl Command:
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/high-fidelity-video-api-google-veo-31/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "input": {
      "prompt": "the woman is giving an interview for a podcast, wearing a pink top with the logo...",
      "duration": 8,
      "resolution": "1080p",
      "aspect_ratio": "16:9",
      "generate_audio": true,
      "reference_images": [
        "https://blog.api.market/wp-content/uploads/2025/12/veo-3.1-image-api-market.webp",
        "https://blog.api.market/wp-content/uploads/2025/05/API.market-Square-Logo.png"
      ]
    }
  }'
```

**Responses:**

- **201 Created:** Prediction created successfully
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "ed5b1767b711dd15d954b162af1e890d27882680f463a85e94f02d604012b972",
  "status": "starting",
  "created_at": "2025-12-09T06:34:15.151Z"
}
```

- **400 Bad Request:** Validation error
- **401 Unauthorized:** Invalid API token

#### GET /api/v1/magicapi/high-fidelity-video-api-google-veo-31/predictions/{id}

Get the status and result of a `google/veo-3.1` prediction from API.market.

**Request:**
```http
GET /api/v1/magicapi/high-fidelity-video-api-google-veo-31/predictions/{id}
```

**Response:**
- **200 OK:**
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": "https://blog.api.market/wp-content/uploads/2025/12/veo-3.1-api-market.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"
}
```

- **401 Unauthorized**: Invalid API token
- **404 Not Found**: Prediction not found

### 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
- Implement rate limiting if repeated requests exceed a threshold. Use exponential backoff to handle rate limits gracefully.

### Error Handling
Interpret error responses and handle common errors:
- **400**: Check input parameters for issues.
- **401**: Ensure the API key is correct.
- **404**: Verify if the prediction ID is correct.

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

## Implementation Guide

### Example Code

#### JavaScript
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/high-fidelity-video-api-google-veo-31";

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({ 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
```python
import requests
import time

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/high-fidelity-video-api-google-veo-31"

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={"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
```bash
# Create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/high-fidelity-video-api-google-veo-31/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "input": {
      "prompt":"the woman is giving an interview for a podcast...",
      "duration": 8,
      "resolution": "1080p",
      "aspect_ratio": "16:9",
      "generate_audio": true,
      "reference_images": [
        "https://blog.api.market/wp-content/uploads/2025/12/veo-3.1-image-api-market.webp",
        "https://blog.api.market/wp-content/uploads/2025/05/API.market-Square-Logo.png"
      ]
    }
  }'
# Replace ID with the actual ID returned above
curl -X GET "https://prod.api.market/api/v1/magicapi/high-fidelity-video-api-google-veo-31/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

### Performance Optimization
- Ensure to poll at the recommended intervals and avoid excessive API calls.
- Use efficient error handling and retries to manage transient issues.
- Optimize input data to reduce processing load where possible.

## FAQ
### What types of video content can this API generate?
Our API excels at generating high-quality videos across various use cases like marketing, education, social media, etc.

### How is context-aware audio generated?
The audio is matched to the visual content based on the provided text prompt and reference images, ensuring cohesive and contextually relevant audio.

### Can I provide reference images?
Yes, up to 3 reference images can be provided for subject-consistent generation.

### How long does it take to generate a video?
Times vary depending on the complexity but generally range up to several minutes. Implementing timeouts and polling helps manage this.

## 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 high-fidelity video from text with AI and context-aware audio. Use reference images for subject consistency. Try it free on API.market.