Name: Veo 3.1 Fast – Generate Video & Audio | $0.12/call | API.market
Brand: magicapi
SKU: api-magicapi-high-fidelity-video-context-aware-audio-api-google-veo-31-fast
Availability: InStock
Author: API Market

Shashank Agarwal

# 📹 Ultra-Fast Video & Context-Aware Audio API (Veo 3.1 Fast)

## Overview
Welcome to the Ultra-Fast Video & Context-Aware Audio API, powered by the Veo 3.1 Fast model. This API allows you to create high-fidelity videos enriched with context-aware audio in a matter of seconds. Leveraging the new and improved version of Veo 3 Fast, the API supports higher-fidelity video generation, context-aware audio creation, and last frame support for seamless transitions.

## Features
- **High-Fidelity Video Generation:** Create crisp, high-definition videos tailored to your input prompts and images.
- **Context-Aware Audio:** Generate audio tracks that align perfectly with the visual content for an immersive experience.
- **Flexible Input Support:** Utilize images and text prompts to guide the video generation process.
- **Last Frame Support:** Seamlessly transition videos with optional ending images.
- **Resolution Options:** Choose from various resolutions including 720p and 1080p.
- **Aspect Ratio Customization:** Support for standard 16:9 and 9:16 aspect ratios.

## Use Cases
- **Marketing & Advertising:** 
  - Create engaging, high-quality video ads that stand out with dynamic visuals and compelling audio.
- **Entertainment:** 
  - Generate unique video and audio content for films, music videos, or live performances.
- **E-Learning & Training:** 
  - Produce educational videos with rich media elements to enhance learning experiences.
- **Social Media Content:** 
  - Rapidly generate creative and attention-grabbing content for various social media platforms.
- **Digital Art & Design:** 
  - Enable artists and designers to visualize and create stunning video artworks with custom audio tracks.

## Visual Examples

### Input Image
![Geometric shapes input](https://blog.api.market/wp-content/uploads/2026/02/Gemini_Generated_Image_8991f78991f78991.png)

### Output Video
![Geometric shapes output](https://blog.api.market/wp-content/uploads/2026/02/veo3.1-fast-output.mp4)

### Ending Image for Transition
![Ending image for transition](https://blog.api.market/wp-content/uploads/2026/02/veo3.1-fast-api-market.png)

## API Documentation

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

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

#### Create a Prediction
```json
POST /api/v1/magicapi/high-fidelity-video-context-aware-audio-api-google-veo-31-fast/predictions
```
Create a prediction with the Veo 3.1 Fast model.
##### Required Parameters:
```json
{
  "version": "af87cbb0ee4dfffefb483e206251676fe21107fdec31aeb1f8855b55acea4fda",
  "input": {
    "image": "https://example.com/input-image.jpg",
    "prompt": "Overlapping geometric shapes, pulsing to upbeat electronic music with SFX of shifting patterns",
    "duration": 8,
    "last_frame": "https://example.com/ending-image.jpg",
    "resolution": "720p",
    "aspect_ratio": "16:9",
    "generate_audio": true
  }
}
```

#### Poll Prediction Status
```json
GET /api/v1/magicapi/high-fidelity-video-context-aware-audio-api-google-veo-31-fast/predictions/{id}
```
Retrieve the status and results of a prediction.
##### Required Parameters:
- **id**: The prediction ID returned by the creation endpoint
##### Example Response:
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": "https://blog.api.market/wp-content/uploads/2026/02/veo3.1-fast-output.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"
}
```

### Curl Examples
```bash
# Create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/high-fidelity-video-context-aware-audio-api-google-veo-31-fast/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "af87cbb0ee4dfffefb483e206251676fe21107fdec31aeb1f8855b55acea4fda",
    "input": {
      "image": "https://example.com/image.jpg",
      "prompt": "Overlapping geometric shapes, pulsing to upbeat electronic music with SFX of shifting patterns",
      "duration": 8,
      "resolution": "720p",
      "aspect_ratio": "16:9",
      "generate_audio": true
    }
  }'

# Poll prediction status
curl -X GET "https://prod.api.market/api/v1/magicapi/high-fidelity-video-context-aware-audio-api-google-veo-31-fast/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

### 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
Include information about any rate limits and how to handle them.

### Error Handling
#### Common Errors:
- **Invalid Parameter:**
  ```json
  {
    "error": {
      "code": "invalid_parameter",
      "message": "The parameter 'image' is required",
      "status": 400
    }
  }
  ```
- **Unauthorized:**
  ```json
  {
    "error": {
      "code": "unauthorized",
      "message": "Invalid API key",
      "status": 401
    }
  }
  ```

### Implementation Guide

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

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({ version: "af87cbb0ee4dfffefb483e206251676fe21107fdec31aeb1f8855b55acea4fda", 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;
  const POLL_INTERVAL = 1000;
  
  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");
}
```

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

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

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": "af87cbb0ee4dfffefb483e206251676fe21107fdec31aeb1f8855b55acea4fda", "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
    POLL_INTERVAL = 1
    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")
```

### Performance Optimization
- Use 720p resolution for faster processing times if high definition is not critical.
- Reduce video duration for quicker results.
- Avoid unnecessary API calls to minimize costs.

## FAQ
**Q: How long does it take to create a video?**
A: Typically, it takes a few minutes, but it depends on the complexity of the request.

**Q: Can I use the API for real-time applications?**
A: Due to the asynchronous nature of the API, real-time applications might experience slight delays.

**Q: Is there a limit on the number of videos I can generate?**
A: No, there are no limits. The API operates on a Pay As You Go model.

**Q: What aspect ratios are supported?**
A: The API supports 16:9 and 9:16 aspect ratios.

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

Create high-fidelity videos with context-aware audio from text or image prompts. Supports resolutions up to 4K. From $0.12/call. Try it free on API.market.