"PixVerse AI API Pricing & Integration Guide: Video Generation for Marketing Teams 2026"

import requests
import time

PIXVERSE_API_KEY = "your-pixverse-api-key"
BASE_URL = "https://api.pixverse.ai/v2"

headers = {
    "Authorization": f"Bearer {PIXVERSE_API_KEY}",
    "Content-Type": "application/json"
}

def generate_video(prompt: str, duration: int = 4, 
                   resolution: str = "720", style: str = "realistic"):
    """Generate a video from text prompt"""
    response = requests.post(
        f"{BASE_URL}/video/text/generate",
        headers=headers,
        json={
            "prompt": prompt,
            "duration": duration,
            "resolution": resolution,
            "style": style,  # realistic, anime, 3d_animation, cinematic
            "aspect_ratio": "16:9",
            "negative_prompt": "blurry, low quality, watermark"
        }
    )
    response.raise_for_status()
    return response.json()

# Generate a marketing video
result = generate_video(
    prompt="A modern smartphone floating and rotating against a gradient "
           "blue background, soft shadows, product showcase style",
    duration=4,
    resolution="1080",
    style="realistic"
)
task_id = result["data"]["task_id"]

def animate_image(image_url: str, prompt: str, duration: int = 4):
    """Animate a static image"""
    response = requests.post(
        f"{BASE_URL}/video/img/generate",
        headers=headers,
        json={
            "image_url": image_url,
            "prompt": prompt,
            "duration": duration,
            "motion_strength": "medium"  # low, medium, high
        }
    )
    response.raise_for_status()
    return response.json()

# Animate a product photo
result = animate_image(
    image_url="https://example.com/product.jpg",
    prompt="Subtle zoom in with floating particles, premium feel",
    duration=4
)

def wait_for_result(task_id: str, timeout: int = 300):
    """Poll until video is ready"""
    start = time.time()
    
    while time.time() - start < timeout:
        response = requests.get(
            f"{BASE_URL}/video/result/{task_id}",
            headers=headers
        )
        data = response.json()
        
        status = data["data"]["status"]
        
        if status == "successful":
            return {
                "video_url": data["data"]["video_url"],
                "duration": data["data"]["duration"],
                "resolution": data["data"]["resolution"]
            }
        elif status == "failed":
            raise Exception(f"Failed: {data['data'].get('error_msg', 'Unknown')}")
        
        time.sleep(3)
    
    raise TimeoutError("Generation timed out")

# Get the result
video = wait_for_result(task_id)
print(f"Video ready: {video['video_url']}")

import asyncio
import aiohttp

async def batch_generate_videos(prompts: list, max_concurrent: int = 5):
    """Generate multiple videos concurrently"""
    semaphore = asyncio.Semaphore(max_concurrent)
    results = []
    
    async def generate_one(prompt, index):
        async with semaphore:
            # Create generation
            async with aiohttp.ClientSession() as session:
                async with session.post(
                    f"{BASE_URL}/video/text/generate",
                    headers=headers,
                    json={
                        "prompt": prompt,
                        "duration": 4,
                        "resolution": "720",
                        "style": "realistic"
                    }
                ) as resp:
                    data = await resp.json()
                    task_id = data["data"]["task_id"]
                
                # Poll for result
                while True:
                    async with session.get(
                        f"{BASE_URL}/video/result/{task_id}",
                        headers=headers
                    ) as resp:
                        data = await resp.json()
                        if data["data"]["status"] == "successful":
                            return {
                                "index": index,
                                "prompt": prompt,
                                "video_url": data["data"]["video_url"]
                            }
                        elif data["data"]["status"] == "failed":
                            return {"index": index, "error": "Failed"}
                    
                    await asyncio.sleep(3)
    
    tasks = [generate_one(p, i) for i, p in enumerate(prompts)]
    return await asyncio.gather(*tasks)

# Generate 20 ad variations
ad_prompts = [
    f"Product showcase: {product} on a clean white surface, "
    f"soft studio lighting, slow rotation, premium feel"
    for product in [
        "wireless earbuds", "smart watch", "laptop", "tablet",
        "phone case", "portable charger", "bluetooth speaker",
        "webcam", "mechanical keyboard", "gaming mouse",
        "USB-C hub", "monitor light bar", "desk mat",
        "cable organizer", "phone stand", "ring light",
        "microphone", "headphone stand", "mouse pad",
        "screen protector"
    ]
]

results = asyncio.run(batch_generate_videos(ad_prompts))
print(f"Generated {len([r for r in results if 'video_url' in r])} videos")

import openai

client = openai.OpenAI(
    api_key="sk-cr-your-key",
    base_url="https://crazyrouter.com/v1"
)

# Same interface for any video model
response = client.chat.completions.create(
    model="pixverse",
    messages=[{
        "role": "user",
        "content": "Generate video: Coffee being poured into a glass cup "
                   "with ice, slow motion, warm lighting"
    }]
)

# cURL
curl https://crazyrouter.com/v1/videos/generations \
  -H "Authorization: Bearer sk-cr-your-key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "pixverse",
    "prompt": "Aerial view of a modern office building at sunset",
    "resolution": "720p",
    "duration": 4
  }'

class MarketingVideoPipeline:
    """Cost-optimized video generation for marketing teams"""
    
    def __init__(self, crazyrouter_key: str):
        self.client = openai.OpenAI(
            api_key=crazyrouter_key,
            base_url="https://crazyrouter.com/v1"
        )
    
    def generate(self, prompt: str, tier: str = "standard"):
        """
        Tiers:
        - draft: PixVerse 720p ($0.03) — internal review
        - standard: PixVerse 1080p ($0.04) — social media
        - premium: Seedance/Kling ($0.25) — campaigns
        - hero: Veo 3 ($0.60) — brand videos
        """
        model_map = {
            "draft": "pixverse",
            "standard": "pixverse",
            "premium": "seedance-2.0",
            "hero": "veo-3"
        }
        
        return self.client.chat.completions.create(
            model=model_map[tier],
            messages=[{"role": "user", "content": f"Generate video: {prompt}"}]
        )

# Usage
pipeline = MarketingVideoPipeline("sk-cr-your-key")

# Generate 50 social media clips at $0.04 each = $2.00 total
for product in products:
    pipeline.generate(f"{product} product showcase", tier="standard")

# Generate 3 hero brand videos at $0.60 each = $1.80 total
for scene in hero_scenes:
    pipeline.generate(scene, tier="hero")