Video API (Video Generation)

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": "A cute cat playing with a ball in a sunny garden",
    "size": "720p",
    "duration": 5,
    "n": 1
  }'

import requests
import time
 
# Submit video generation request
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': 'A cute cat playing with a ball in a sunny garden',
        'size': '720p',
        'duration': 5,
        'n': 1
    }
)
 
data = response.json()
task_id = data['data'][0]['id']
 
# Poll task status
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'Task status: {status}')
 
    if status == 'completed':
        print(f'Video generated: {status_data["url"]}')
        break
    elif status == 'failed':
        print(f'Generation failed: {status_data.get("error")}')
        break
 
    time.sleep(5)

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: 'A cute cat playing with a ball in a sunny garden',
    size: '720p',
    duration: 5,
    n: 1
  })
});
 
const data = await response.json();
const taskId = data.data[0].id;
 
// Poll task status
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('Task status:', statusData.status);
 
  if (statusData.status === 'completed') {
    console.log('Video generated:', statusData.url);
    break;
  } else if (statusData.status === 'failed') {
    console.error('Generation failed:', statusData.error);
    break;
  }
 
  await new Promise(resolve => setTimeout(resolve, 5000));
}

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": "A cute cat playing with a ball in a sunny garden",
    "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)
 
  // Poll task status
  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("Task status: %s\n", status)
 
    if status == "completed" {
      videoURL := statusResult["url"].(string)
      fmt.Printf("Video generated: %s\n", videoURL)
      break
    } else if status == "failed" {
      fmt.Println("Generation failed")
      break
    }
 
    time.Sleep(5 * time.Second)
  }
}

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": "A cute cat playing with a ball in a sunny garden",
        "size": "720p",
        "duration": 5,
        "n": 1
    });
 
    // Submit video generation request
    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();
 
    // Poll task status
    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!("Task status: {}", status);
 
        if status == "completed" {
            println!("Video generated: {}", status_data["url"]);
            break;
        } else if status == "failed" {
            println!("Generation failed");
            break;
        }
 
        sleep(Duration::from_secs(5)).await;
    }
 
    Ok(())
}

<?php
 
// Submit video generation request
$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" => "A cute cat playing with a ball in a sunny garden",
    "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'];
 
// Poll task status
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 "Task status: {$status}\n";
 
    if ($status === 'completed') {
        echo "Video generated: {$statusData['url']}\n";
        break;
    } elseif ($status === 'failed') {
        echo "Generation failed\n";
        break;
    }
 
    sleep(5);
}
?>

require 'net/http'
require 'json'
 
# Submit video generation request
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: 'A cute cat playing with a ball in a sunny garden',
  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']
 
# Poll task status
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 "Task status: #{status}"
 
  if status == 'completed'
    puts "Video generated: #{status_data['url']}"
    break
  elsif status == 'failed'
    puts "Generation failed"
    break
  end
 
  sleep 5
end