视频接口 (Video Generation)

视频接口提供强大的AI视频生成能力,支持从文本描述创建高质量视频内容。

接口地址


POST https://aiapi.services/vertex/v1/video/generations

鉴权方式

所有请求需要在HTTP头中包含您的API密钥:


Authorization: Bearer YOUR_API_KEY

支持的模型

Veo 3.0 系列

veo-3.0-generate-001 - Veo 3.0标准版,最新一代视频生成模型
veo-3.0-fast-generate-001 - Veo 3.0快速版,优化生成速度

Veo 2.0 系列

veo-2.0-generate-001 - Veo 2.0,成熟的视频生成技术

完整模型列表请查看可用模型。

请求参数

必需参数

参数	类型	说明
`prompt`	string	视频描述文本,详细描述视频场景和动作
`model`	string	要使用的模型ID,如 `veo-3.0-generate-001`

可选参数

参数	类型	默认值	说明
`size`	string	`720p`	视频分辨率: `480p`, `720p`, `1080p`
`duration`	number	5	视频时长(秒),范围: 2-10
`fps`	integer	24	帧率: 24, 30, 60
`n`	integer	1	要生成的视频数量(1-4)
`response_format`	string	`url`	返回格式: `url` 或 `b64_json`
`user`	string	-	终端用户的唯一标识符

代码示例

cURL


curl https://aiapi.services/vertex/v1/video/generations \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "veo-3.0-generate-001",
    "prompt": "一只可爱的小猫在花园里追逐蝴蝶,阳光明媚,4K画质",
    "size": "720p",
    "duration": 5,
    "n": 1
  }'

Python


import requests
import time
 
# 提交视频生成请求
response = requests.post(
    'https://aiapi.services/vertex/v1/video/generations',
    headers={
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
    },
    json={
        'model': 'veo-3.0-generate-001',
        'prompt': '一只可爱的小猫在花园里追逐蝴蝶,阳光明媚,4K画质',
        'size': '720p',
        'duration': 5,
        'n': 1
    }
)
 
data = response.json()
task_id = data['data'][0]['id']
 
# 轮询任务状态
while True:
    status_response = requests.get(
        f'https://aiapi.services/vertex/v1/video/generations/{task_id}',
        headers={'Authorization': 'Bearer YOUR_API_KEY'}
    )
 
    status_data = status_response.json()
    status = status_data['status']
 
    print(f'任务状态: {status}')
 
    if status == 'completed':
        video_url = status_data['url']
        print(f'视频生成完成: {video_url}')
        break
    elif status == 'failed':
        print(f'生成失败: {status_data.get("error")}')
        break
 
    time.sleep(5)  # 每5秒查询一次

JavaScript


const response = await fetch('https://aiapi.services/vertex/v1/video/generations', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    model: 'veo-3.0-generate-001',
    prompt: '一只可爱的小猫在花园里追逐蝴蝶,阳光明媚,4K画质',
    size: '720p',
    duration: 5,
    n: 1
  })
});
 
const data = await response.json();
const taskId = data.data[0].id;
 
// 轮询任务状态
while (true) {
  const statusResponse = await fetch(
    `https://aiapi.services/vertex/v1/video/generations/${taskId}`,
    { headers: { 'Authorization': 'Bearer YOUR_API_KEY' } }
  );
 
  const statusData = await statusResponse.json();
  console.log('任务状态:', statusData.status);
 
  if (statusData.status === 'completed') {
    console.log('视频生成完成:', statusData.url);
    break;
  } else if (statusData.status === 'failed') {
    console.error('生成失败:', statusData.error);
    break;
  }
 
  await new Promise(resolve => setTimeout(resolve, 5000));
}

Go


package main
 
import (
  "bytes"
  "encoding/json"
  "fmt"
  "io"
  "net/http"
  "time"
)
 
func main() {
  url := "https://aiapi.services/vertex/v1/video/generations"
 
  payload := map[string]interface{}{
    "model": "veo-3.0-generate-001",
    "prompt": "一只可爱的小猫在花园里追逐蝴蝶,阳光明媚,4K画质",
    "size": "720p",
    "duration": 5,
    "n": 1,
  }
 
  jsonData, _ := json.Marshal(payload)
  req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
  req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
  req.Header.Set("Content-Type", "application/json")
 
  client := &http.Client{}
  resp, _ := client.Do(req)
  defer resp.Body.Close()
 
  body, _ := io.ReadAll(resp.Body)
 
  var result map[string]interface{}
  json.Unmarshal(body, &result)
 
  taskID := result["data"].([]interface{})[0].(map[string]interface{})["id"].(string)
 
  // 轮询任务状态
  for {
    statusResp, _ := http.Get(fmt.Sprintf("%s/%s", url, taskID))
    statusBody, _ := io.ReadAll(statusResp.Body)
    statusResp.Body.Close()
 
    var statusResult map[string]interface{}
    json.Unmarshal(statusBody, &statusResult)
 
    status := statusResult["status"].(string)
    fmt.Printf("任务状态: %s\n", status)
 
    if status == "completed" {
      videoURL := statusResult["url"].(string)
      fmt.Printf("视频生成完成: %s\n", videoURL)
      break
    } else if status == "failed" {
      fmt.Println("生成失败")
      break
    }
 
    time.Sleep(5 * time.Second)
  }
}

Rust


use reqwest::header::{HeaderMap, HeaderValue, AUTHORIZATION, CONTENT_TYPE};
use serde_json::json;
use std::time::Duration;
use tokio::time::sleep;
 
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();
 
    let mut headers = HeaderMap::new();
    headers.insert(AUTHORIZATION, HeaderValue::from_static("Bearer YOUR_API_KEY"));
    headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
 
    let payload = json!({
        "model": "veo-3.0-generate-001",
        "prompt": "一只可爱的小猫在花园里追逐蝴蝶,阳光明媚,4K画质",
        "size": "720p",
        "duration": 5,
        "n": 1
    });
 
    // 提交视频生成请求
    let response = client
        .post("https://aiapi.services/vertex/v1/video/generations")
        .headers(headers.clone())
        .json(&payload)
        .send()
        .await?;
 
    let data: serde_json::Value = response.json().await?;
    let task_id = data["data"][0]["id"].as_str().unwrap();
 
    // 轮询任务状态
    loop {
        let status_response = client
            .get(format!("https://aiapi.services/vertex/v1/video/generations/{}", task_id))
            .header(AUTHORIZATION, "Bearer YOUR_API_KEY")
            .send()
            .await?;
 
        let status_data: serde_json::Value = status_response.json().await?;
        let status = status_data["status"].as_str().unwrap();
 
        println!("任务状态: {}", status);
 
        if status == "completed" {
            println!("视频生成完成: {}", status_data["url"]);
            break;
        } else if status == "failed" {
            println!("生成失败");
            break;
        }
 
        sleep(Duration::from_secs(5)).await;
    }
 
    Ok(())
}

PHP


<?php
 
// 提交视频生成请求
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://aiapi.services/vertex/v1/video/generations");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer YOUR_API_KEY",
    "Content-Type: application/json"
]);
 
$data = [
    "model" => "veo-3.0-generate-001",
    "prompt" => "一只可爱的小猫在花园里追逐蝴蝶,阳光明媚,4K画质",
    "size" => "720p",
    "duration" => 5,
    "n" => 1
];
 
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
$response = curl_exec($ch);
curl_close($ch);
 
$result = json_decode($response, true);
$taskId = $result['data'][0]['id'];
 
// 轮询任务状态
while (true) {
    $statusCh = curl_init();
    curl_setopt($statusCh, CURLOPT_URL, "https://aiapi.services/vertex/v1/video/generations/{$taskId}");
    curl_setopt($statusCh, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($statusCh, CURLOPT_HTTPHEADER, [
        "Authorization: Bearer YOUR_API_KEY"
    ]);
 
    $statusResponse = curl_exec($statusCh);
    curl_close($statusCh);
 
    $statusData = json_decode($statusResponse, true);
    $status = $statusData['status'];
 
    echo "任务状态: {$status}\n";
 
    if ($status === 'completed') {
        echo "视频生成完成: {$statusData['url']}\n";
        break;
    } elseif ($status === 'failed') {
        echo "生成失败\n";
        break;
    }
 
    sleep(5);
}
?>

Ruby


require 'net/http'
require 'json'
 
# 提交视频生成请求
uri = URI('https://aiapi.services/vertex/v1/video/generations')
request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['Content-Type'] = 'application/json'
 
request.body = {
  model: 'veo-3.0-generate-001',
  prompt: '一只可爱的小猫在花园里追逐蝴蝶,阳光明媚,4K画质',
  size: '720p',
  duration: 5,
  n: 1
}.to_json
 
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end
 
data = JSON.parse(response.body)
task_id = data['data'][0]['id']
 
# 轮询任务状态
loop do
  status_uri = URI("https://aiapi.services/vertex/v1/video/generations/#{task_id}")
  status_request = Net::HTTP::Get.new(status_uri)
  status_request['Authorization'] = 'Bearer YOUR_API_KEY'
 
  status_response = Net::HTTP.start(status_uri.hostname, status_uri.port, use_ssl: true) do |http|
    http.request(status_request)
  end
 
  status_data = JSON.parse(status_response.body)
  status = status_data['status']
 
  puts "任务状态: #{status}"
 
  if status == 'completed'
    puts "视频生成完成: #{status_data['url']}"
    break
  elsif status == 'failed'
    puts "生成失败"
    break
  end
 
  sleep 5
end

响应格式

提交响应


{
  "id": "video_gen_abc123",
  "object": "video.generation",
  "created": 1702548600,
  "model": "veo-3.0-generate-001",
  "data": [
    {
      "id": "task_xyz789",
      "status": "processing",
      "url": null,
      "revised_prompt": "一只优雅可爱的橘猫在阳光明媚的花园中欢快地追逐彩色蝴蝶,高清4K画质,自然光照,流畅运动..."
    }
  ]
}

状态查询响应


{
  "id": "task_xyz789",
  "status": "completed",
  "progress": 100,
  "url": "https://storage.googleapis.com/ai-videos/xyz789.mp4",
  "revised_prompt": "...",
  "metadata": {
    "duration": 5.2,
    "size": "720p",
    "fps": 24,
    "format": "mp4"
  },
  "created_at": 1702548600,
  "completed_at": 1702548720
}

状态类型

状态	说明
`processing`	正在生成中
`completed`	生成完成
`failed`	生成失败
`queued`	等待队列中

应用场景

1. 短视频内容生成

快速创建社交媒体短视频:


import requests
import time
 
def generate_short_video(prompt, duration=5, size='720p'):
    """生成短视频内容"""
 
    # 提交生成任务
    response = requests.post(
        'https://aiapi.services/vertex/v1/video/generations',
        headers={
            'Authorization': 'Bearer YOUR_API_KEY',
            'Content-Type': 'application/json'
        },
        json={
            'model': 'veo-3.0-generate-001',
            'prompt': prompt,
            'size': size,
            'duration': duration,
            'fps': 30
        }
    )
 
    data = response.json()
    task_id = data['data'][0]['id']
 
    # 等待生成完成
    max_wait_time = 300  # 5分钟超时
    start_time = time.time()
 
    while time.time() - start_time < max_wait_time:
        status_response = requests.get(
            f'https://aiapi.services/vertex/v1/video/generations/{task_id}',
            headers={'Authorization': 'Bearer YOUR_API_KEY'}
        )
 
        status_data = status_response.json()
 
        if status_data['status'] == 'completed':
            return {
                'url': status_data['url'],
                'duration': status_data['metadata']['duration'],
                'revised_prompt': status_data['revised_prompt']
            }
        elif status_data['status'] == 'failed':
            raise Exception(f'生成失败: {status_data.get("error")}')
 
        print(f'进度: {status_data.get("progress", 0)}%')
        time.sleep(10)
 
    raise TimeoutError('视频生成超时')
 
# 使用示例
video = generate_short_video(
    prompt='城市夜景延时摄影,霓虹灯闪烁,车流穿梭,电影级画质',
    duration=8,
    size='1080p'
)
 
print(f'视频URL: {video["url"]}')
print(f'实际时长: {video["duration"]}秒')

2. 产品演示视频

生成产品展示视频:


async function generateProductDemo(productName, features, style = 'professional') {
  const prompt = `
    Product showcase: ${productName}
    Key features: ${features.join(', ')}
    Style: ${style} commercial video
    Camera: Smooth 360-degree rotation
    Lighting: Studio lighting with soft shadows
    Background: Clean minimalist environment
    Quality: 4K cinematic
  `;
 
  const response = await fetch('https://aiapi.services/vertex/v1/video/generations', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      model: 'veo-3.0-generate-001',
      prompt: prompt,
      size: '1080p',
      duration: 10,
      fps: 60
    })
  });
 
  const data = await response.json();
  const taskId = data.data[0].id;
 
  // 轮询状态
  return await pollVideoStatus(taskId);
}
 
async function pollVideoStatus(taskId, maxAttempts = 60) {
  for (let i = 0; i < maxAttempts; i++) {
    const response = await fetch(
      `https://aiapi.services/vertex/v1/video/generations/${taskId}`,
      { headers: { 'Authorization': 'Bearer YOUR_API_KEY' } }
    );
 
    const data = await response.json();
 
    if (data.status === 'completed') {
      return data;
    } else if (data.status === 'failed') {
      throw new Error(`视频生成失败: ${data.error}`);
    }
 
    console.log(`进度: ${data.progress || 0}%`);
    await new Promise(resolve => setTimeout(resolve, 5000));
  }
 
  throw new Error('视频生成超时');
}
 
// 使用示例
const productVideo = await generateProductDemo(
  '智能手表X1',
  ['心率监测', 'GPS定位', '防水设计', '超长续航'],
  'modern'
);
 
console.log('产品演示视频:', productVideo.url);

3. 教育动画视频

创建教学动画内容:


def create_educational_video(topic, key_points, duration=30):
    """生成教育动画视频"""
 
    prompt = f"""
    Educational animation about: {topic}
 
    Key learning points:
    {chr(10).join(f'- {point}' for point in key_points)}
 
    Style: Clear educational animation
    Visuals: Simple diagrams and illustrations
    Pace: Slow and easy to follow
    Text: Large readable captions
    Colors: Bright and engaging
    """
 
    response = requests.post(
        'https://aiapi.services/vertex/v1/video/generations',
        headers={
            'Authorization': 'Bearer YOUR_API_KEY',
            'Content-Type': 'application/json'
        },
        json={
            'model': 'veo-3.0-generate-001',
            'prompt': prompt,
            'size': '1080p',
            'duration': duration,
            'fps': 30
        }
    )
 
    return response.json()
 
# 使用示例
educational_content = create_educational_video(
    topic='光合作用过程',
    key_points=[
        '植物吸收阳光能量',
        '叶绿素将光能转化为化学能',
        '二氧化碳和水合成葡萄糖',
        '释放氧气作为副产品'
    ],
    duration=20
)

提示词优化技巧

1. 详细场景描述

提供清晰的场景和动作描述:


# ❌ 模糊提示
prompt = "一个人在跑步"
 
# ✅ 详细提示
prompt = """
一位年轻女性在海滨公园慢跑,
清晨阳光柔和,海风轻拂,
镜头跟随运动,平稳流畅,
运动服装色彩鲜明,背景海景壮丽,
电影级画质,4K分辨率
"""

2. 指定镜头运动

明确摄像机运动方式:


const cameraMovements = {
  static: '静态镜头,固定视角',
  pan: '左右平移镜头',
  tilt: '上下倾斜镜头',
  dolly: '前后推拉镜头',
  orbit: '360度环绕镜头',
  aerial: '鸟瞰俯拍镜头',
  tracking: '跟踪拍摄镜头'
};
 
const prompt = `
${scene_description}
Camera: ${cameraMovements.orbit}
Movement: Slow and smooth
`;

3. 控制时间节奏

指定动作速度和节奏:


pace_keywords = {
    'slow_motion': '慢动作,0.5倍速',
    'real_time': '正常实时速度',
    'time_lapse': '延时摄影,快速变化',
    'smooth': '流畅连贯的动作',
    'dynamic': '动感十足,快速切换'
}
 
prompt = f"""
{content_description}
Pacing: {pace_keywords['smooth']}
Transitions: Gentle and natural
"""

4. 质量和风格关键词


quality_keywords = [
    'cinematic quality',      # 电影级画质
    '4K ultra HD',           # 4K超高清
    'professional lighting',  # 专业光照
    'vibrant colors',        # 鲜艳色彩
    'sharp focus',          # 清晰对焦
    'natural motion',       # 自然运动
    'smooth animation'      # 流畅动画
]
 
style_keywords = {
    'realistic': '真实摄影风格',
    'animated': '动画风格',
    'documentary': '纪录片风格',
    'commercial': '商业广告风格',
    'artistic': '艺术创作风格'
}

最佳实践

1. 异步任务管理

高效管理多个视频生成任务:


import asyncio
import aiohttp
 
class VideoGenerationManager:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = 'https://aiapi.services/v1'
        self.headers = {
            'Authorization': f'Bearer {api_key}',
            'Content-Type': 'application/json'
        }
 
    async def submit_task(self, session, prompt, **kwargs):
        """提交视频生成任务"""
        async with session.post(
            f'{self.base_url}/video/generations',
            headers=self.headers,
            json={'prompt': prompt, 'model': 'veo-3.0-generate-001', **kwargs}
        ) as response:
            data = await response.json()
            return data['data'][0]['id']
 
    async def poll_task(self, session, task_id, poll_interval=5):
        """轮询任务状态"""
        while True:
            async with session.get(
                f'{self.base_url}/video/generations/{task_id}',
                headers=self.headers
            ) as response:
                data = await response.json()
 
                if data['status'] == 'completed':
                    return data
                elif data['status'] == 'failed':
                    raise Exception(f'任务失败: {data.get("error")}')
 
                await asyncio.sleep(poll_interval)
 
    async def batch_generate(self, prompts_with_params):
        """批量生成视频"""
        async with aiohttp.ClientSession() as session:
            # 提交所有任务
            task_ids = await asyncio.gather(*[
                self.submit_task(session, **params)
                for params in prompts_with_params
            ])
 
            # 并发等待所有任务完成
            results = await asyncio.gather(*[
                self.poll_task(session, task_id)
                for task_id in task_ids
            ])
 
            return results
 
# 使用示例
manager = VideoGenerationManager('YOUR_API_KEY')
 
video_tasks = [
    {'prompt': '春天樱花盛开', 'duration': 5, 'size': '720p'},
    {'prompt': '夏日海滩日落', 'duration': 5, 'size': '720p'},
    {'prompt': '秋季枫叶飘落', 'duration': 5, 'size': '720p'}
]
 
results = asyncio.run(manager.batch_generate(video_tasks))
 
for i, result in enumerate(results):
    print(f'视频 {i+1}: {result["url"]}')

2. 进度回调通知

实现进度更新回调:


class VideoGenerator {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseURL = 'https://aiapi.services/v1';
  }
 
  async generateWithProgress(prompt, options = {}, onProgress = () => {}) {
    // 提交任务
    const response = await fetch(`${this.baseURL}/video/generations`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        model: 'veo-3.0-generate-001',
        prompt,
        ...options
      })
    });
 
    const data = await response.json();
    const taskId = data.data[0].id;
 
    // 轮询并触发进度回调
    return await this.pollWithCallback(taskId, onProgress);
  }
 
  async pollWithCallback(taskId, onProgress) {
    while (true) {
      const response = await fetch(
        `${this.baseURL}/video/generations/${taskId}`,
        { headers: { 'Authorization': `Bearer ${this.apiKey}` } }
      );
 
      const data = await response.json();
 
      // 触发进度回调
      onProgress({
        status: data.status,
        progress: data.progress || 0,
        message: this.getStatusMessage(data.status, data.progress)
      });
 
      if (data.status === 'completed') {
        return data;
      } else if (data.status === 'failed') {
        throw new Error(data.error || '视频生成失败');
      }
 
      await new Promise(resolve => setTimeout(resolve, 3000));
    }
  }
 
  getStatusMessage(status, progress) {
    const messages = {
      'queued': '任务已排队等待...',
      'processing': `正在生成视频... ${progress}%`,
      'completed': '视频生成完成!',
      'failed': '视频生成失败'
    };
    return messages[status] || '未知状态';
  }
}
 
// 使用示例
const generator = new VideoGenerator('YOUR_API_KEY');
 
const video = await generator.generateWithProgress(
  '城市夜景延时摄影',
  { duration: 10, size: '1080p' },
  (progress) => {
    console.log(`${progress.message} (${progress.progress}%)`);
    updateProgressBar(progress.progress);
  }
);
 
console.log('视频URL:', video.url);

错误处理

常见错误码

状态码	说明	解决方案
400	提示词违反政策或参数错误	修改提示词,检查参数
401	未授权	检查API密钥
413	请求参数过大	缩短提示词
429	请求过于频繁	降低请求频率
500	服务器错误	稍后重试
503	服务不可用	等待服务恢复

错误处理示例


import requests
import time
from requests.exceptions import RequestException
 
def generate_video_with_retry(prompt, max_retries=3, **kwargs):
    """带重试机制的视频生成"""
 
    for attempt in range(max_retries):
        try:
            response = requests.post(
                'https://aiapi.services/vertex/v1/video/generations',
                headers={
                    'Authorization': 'Bearer YOUR_API_KEY',
                    'Content-Type': 'application/json'
                },
                json={
                    'model': 'veo-3.0-generate-001',
                    'prompt': prompt,
                    **kwargs
                },
                timeout=30
            )
 
            if response.status_code == 429:
                wait_time = (2 ** attempt) * 10
                print(f'请求过于频繁,等待 {wait_time} 秒...')
                time.sleep(wait_time)
                continue
 
            response.raise_for_status()
            return response.json()
 
        except RequestException as e:
            if attempt == max_retries - 1:
                raise
            print(f'尝试 {attempt + 1}/{max_retries} 失败: {str(e)}')
            time.sleep(2 ** attempt)
 
    raise Exception(f'视频生成失败,已重试 {max_retries} 次')

性能对比

模型	质量	生成速度	成本	特点
veo-3.0-generate-001	★★★★☆	★★★☆	★★★★	平衡质量和成本
veo-3.0-generate-002	★★★★★	★★☆☆	★★★☆	最高质量
imagen-video-001	★★★☆	★★★★	★★★★★	快速生成短视频

💡 生成时间: 视频生成通常需要1-3分钟,具体取决于视频时长和分辨率。建议实现进度回调以改善用户体验。