# macOS and Linux (zsh / bash)
export TOAPIS_API_KEY="sk-toapis-your-actual-api-key-here"

# Verify that the variable is set
echo $TOAPIS_API_KEY

$env:TOAPIS_API_KEY="sk-toapis-your-actual-api-key-here"

┌──────────────────┐               ┌──────────────────────┐               ┌──────────────────────────┐
│ Client Terminal  │               │ ToAPIs Cloud Gateway │               │ ByteDance GPU Farm       │
└────────┬─────────┘               └──────────┬───────────┘               └────────────┬─────────────┘
         │                                    │                                        │
         │ 1. POST /v1/videos/generations     │                                        │
         │    {"model":"doubao-seedance-2-0"} │                                        │
         ├───────────────────────────────────►│ 2. Distribute Job to Cluster Queue     │
         │                                    ├───────────────────────────────────────►│
         │ 3. HTTP 202 Accepted               │                                        │
         │    {"task_id": "task_seedance_..."}│                                        │
         │◄───────────────────────────────────┤                                        │
         │                                    │                                        │
         │ 4. Sleep 3 seconds                 │                                        │
         │                                    │                                        │
         │ 5. GET /v1/tasks/video-status      │ 6. Query GPU Worker Status             │
         │    ?task_id=task_seedance_...      ├───────────────────────────────────────►│
         ├───────────────────────────────────►│                                        │
         │ 7. HTTP 200 (PROCESSING, 45%)      │◄───────────────────────────────────────┤
         │◄───────────────────────────────────┤                                        │
         │                                    │                                        │
         │ 8. Sleep 3 seconds                 │                                        │
         │                                    │                                        │
         │ 9. GET /v1/tasks/video-status      │ 10. Worker Completed (Uploaded CDN)    │
         ├───────────────────────────────────►├───────────────────────────────────────►│
         │ 11. HTTP 200 (SUCCESS, video_url)  │◄───────────────────────────────────────┤
         │◄───────────────────────────────────┤                                        │

curl -s -X POST "https://api.toapis.com/v1/videos/generations"   -H "Authorization: Bearer $TOAPIS_API_KEY"   -H "Content-Type: application/json"   -d '{
    "model": "doubao-seedance-2-0",
    "prompt": "Cinematic tracking shot of an astronaut walking across a bioluminescent alien beach, neon purple waves crashing, hyper-realistic, 4k 24fps fluid motion",
    "aspect_ratio": "16:9",
    "duration": 5,
    "seed": 42
  }'

{
  "code": 0,
  "message": "Task queued successfully",
  "data": {
    "task_id": "task_seedance_20261022_9f8a3b1c",
    "status": "PROCESSING",
    "model": "doubao-seedance-2-0",
    "created_at": 1729587600
  }
}

curl -s -X GET "https://api.toapis.com/v1/tasks/video-status?task_id=task_seedance_20261022_9f8a3b1c"   -H "Authorization: Bearer $TOAPIS_API_KEY"

"""
Seedance 2.0 API Asynchronous Video Generation & Polling Client
Requires: pip install requests
"""

import os
import sys
import time
import requests

TOAPIS_API_KEY = os.getenv("TOAPIS_API_KEY")
if not TOAPIS_API_KEY:
    print("[ERROR] TOAPIS_API_KEY environment variable is not set.")
    print("Run: export TOAPIS_API_KEY='sk-toapis-your-key'")
    sys.exit(1)

BASE_URL = "https://api.toapis.com/v1"
HEADERS = {
    "Authorization": f"Bearer {TOAPIS_API_KEY}",
    "Content-Type": "application/json"
}

def generate_video(prompt: str, duration: int = 5, aspect_ratio: str = "16:9") -> str:
    """Submit asynchronous video generation task and return task_id."""
    url = f"{BASE_URL}/videos/generations"
    payload = {
        "model": "doubao-seedance-2-0",
        "prompt": prompt,
        "aspect_ratio": aspect_ratio,
        "duration": duration,
        "seed": 1024
    }

    print(f"[*] Submitting video generation task to {url}...")
    response = requests.post(url, headers=HEADERS, json=payload, timeout=30)
    
    if response.status_code not in (200, 201, 202):
        print(f"[!] Failed to enqueue task. Status: {response.status_code}")
        print(f"[!] Response: {response.text}")
        response.raise_for_status()

    resp_data = response.json()
    task_id = resp_data.get("data", {}).get("task_id")
    if not task_id:
        raise ValueError(f"No task_id returned in response: {resp_data}")

    print(f"[✔] Task enqueued successfully! Task ID: {task_id}")
    return task_id

def poll_task_status(task_id: str, poll_interval: int = 3, timeout: int = 180) -> dict:
    """
    Poll the task status until SUCCESS or FAILED.
    Recommended interval: 3 seconds. Default timeout: 180 seconds.
    """
    query_url = f"{BASE_URL}/tasks/video-status"
    start_time = time.time()
    params = {"task_id": task_id}

    print(f"[*] Beginning polling for task {task_id} (interval={poll_interval}s, max_wait={timeout}s)...")

    while True:
        elapsed = int(time.time() - start_time)
        if elapsed > timeout:
            raise TimeoutError(f"Task {task_id} exceeded maximum timeout of {timeout} seconds.")

        try:
            resp = requests.get(query_url, headers=HEADERS, params=params, timeout=15)
            resp.raise_for_status()
            data = resp.json().get("data", {})
        except requests.exceptions.RequestException as e:
            print(f"[WARN] Network glitch during status query ({e}). Retrying in {poll_interval}s...")
            time.sleep(poll_interval)
            continue

        status = data.get("status", "UNKNOWN").upper()
        progress = data.get("progress", 0)

        if status in ("SUCCESS", "COMPLETED", "SUCCEEDED"):
            print(f"
[✔] Video rendered successfully in {elapsed}s!")
            return data
        elif status in ("FAILED", "ERROR"):
            error_msg = data.get("error_message", "Unknown inference error occurred.")
            raise RuntimeError(f"Video generation failed: {error_msg}")
        elif status in ("PROCESSING", "RUNNING", "QUEUED"):
            sys.stdout.write(f"
[-] Status: {status} | Progress: {progress}% | Elapsed: {elapsed}s")
            sys.stdout.flush()
        else:
            print(f"
[?] Unexpected status returned: {status}")

        time.sleep(poll_interval)

if __name__ == "__main__":
    test_prompt = (
        "High-octane rally car drifting through snowy Scandinavian pine forest, "
        "intense tire spray, volumetric cinematic sunset lighting, 4k 60fps"
    )

    try:
        t_id = generate_video(prompt=test_prompt, duration=5, aspect_ratio="16:9")
        result = poll_task_status(t_id)

        video_url = result.get("video_url") or result.get("output", {}).get("video_url")
        print("
" + "=" * 60)
        print("🎬 Final Seedance 2.0 Render Delivered:")
        print(f"🔗 Video URL:     {video_url}")
        print(f"⏱ Duration:      {result.get('duration', 5)} seconds")
        print(f"📐 Resolution:    {result.get('resolution', '1280x720')}")
        print("=" * 60)
    except Exception as exc:
        print(f"
[FATAL] Execution halted: {exc}")
        sys.exit(1)

python3 test_seedance_video.py

[*] Submitting video generation task to https://api.toapis.com/v1/videos/generations...
[✔] Task enqueued successfully! Task ID: task_seedance_20261022_9f8a3b1c
[*] Beginning polling for task task_seedance_20261022_9f8a3b1c (interval=3s, max_wait=180s)...
[-] Status: PROCESSING | Progress: 68% | Elapsed: 21s
[✔] Video rendered successfully in 27s!

============================================================
🎬 Final Seedance 2.0 Render Delivered:
🔗 Video URL:     https://cdn.toapis.com/outputs/seedance_20261022_9f8a3b1c.mp4
⏱ Duration:      5 seconds
📐 Resolution:    1280x720
============================================================

{
  "code": 0,
  "message": "Task completed successfully",
  "data": {
    "task_id": "task_seedance_20261022_9f8a3b1c",
    "status": "SUCCESS",
    "model": "doubao-seedance-2-0",
    "video_url": "https://cdn.toapis.com/outputs/seedance_20261022_9f8a3b1c.mp4",
    "duration": 5,
    "resolution": "1280x720",
    "cost": 0.14,
    "metrics": {
      "queue_time_ms": 1420,
      "inference_time_ms": 25800,
      "total_time_ms": 27220
    }
  }
}

import process from "node:process";

const API_KEY = process.env.TOAPIS_API_KEY;
if (!API_KEY) {
  console.error("Missing TOAPIS_API_KEY in environment variables.");
  process.exit(1);
}

const BASE_URL = "https://api.toapis.com/v1";

interface TaskResponse {
  task_id: string;
  status: "QUEUED" | "PROCESSING" | "SUCCESS" | "FAILED";
  video_url?: string;
  error_message?: string;
  duration?: number;
}

async function runSeedanceGeneration() {
  // 1. Submit Video Generation Job
  console.log("[*] Dispatching Seedance 2.0 generation task...");
  const dispatchRes = await fetch(`${BASE_URL}/videos/generations`, {
    method: "POST",
    headers: {
      Authorization: `Bearer ${API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      model: "doubao-seedance-2-0",
      prompt: "Drone footage of coastal Amalfi cliffs at twilight, turquoise water, warm villa lights, 4k 30fps",
      aspect_ratio: "16:9",
      duration: 5,
    }),
  });

  if (!dispatchRes.ok) {
    const errText = await dispatchRes.text();
    throw new Error(`Dispatch failed (${dispatchRes.status}): ${errText}`);
  }

  const dispatchData = await dispatchRes.json();
  const taskId = dispatchData.data?.task_id;
  console.log(`[✔] Task created: ${taskId}`);

  // 2. Poll Task Status
  const startTime = Date.now();
  const maxWaitMs = 180_000;

  while (Date.now() - startTime < maxWaitMs) {
    await new Promise((resolve) => setTimeout(resolve, 3000));

    const pollRes = await fetch(`${BASE_URL}/tasks/video-status?task_id=${taskId}`, {
      headers: { Authorization: `Bearer ${API_KEY}` },
    });

    if (!pollRes.ok) {
      console.warn(`[!] Polling retry due to HTTP ${pollRes.status}`);
      continue;
    }

    const payload = await pollRes.json();
    const task: TaskResponse = payload.data;

    console.log(`[-] Polling status: ${task.status} (${Math.round((Date.now() - startTime) / 1000)}s)`);

    if (task.status === "SUCCESS") {
      console.log(`
🎉 Generation Complete!`);
      console.log(`🔗 Video Stream: ${task.video_url}`);
      return task.video_url;
    }

    if (task.status === "FAILED") {
      throw new Error(`Video rendering failed: ${task.error_message || "Unknown error"}`);
    }
  }

  throw new Error("Task timed out after 180 seconds.");
}

runSeedanceGeneration().catch((err) => {
  console.error("[FATAL]", err.message);
  process.exit(1);
});

import os
import requests

API_KEY = os.getenv("TOAPIS_API_KEY")

response = requests.get(
    "https://api.toapis.com/v1/account/token-balance",
    headers={"Authorization": f"Bearer {API_KEY}"},
    timeout=10
)
response.raise_for_status()

account_data = response.json().get("data", {})
balance = account_data.get("balance", 0.0)
currency = account_data.get("currency", "USD")
status = account_data.get("status", "ACTIVE")

print(f"[*] Account Status:      {status}")
print(f"[*] Available Balance:   ${balance:.4f} {currency}")
print(f"[*] Concurrency Limit:   {account_data.get('max_concurrency', 5)} active tasks")

{
  "code": 0,
  "message": "Success",
  "data": {
    "account_id": "acc_dev_882910a",
    "status": "ACTIVE",
    "currency": "USD",
    "balance": 1.5000,
    "frozen_balance": 0.0000,
    "max_concurrency": 5,
    "tier": "DEVELOPER_TRIAL"
  }
}

┌───────────────────────────────────────────────────────────────────────────────────────┐
│                           PRODUCTION DEFENSE MATRIX                                   │
├─────────────────────┬───────────────────────────────┬─────────────────────────────────┤
│ Failure Mode        │ Root Cause                    │ Architectural Mitigation        │
├─────────────────────┼───────────────────────────────┼─────────────────────────────────┤
│ HTTP 429 Error      │ Exceeded Account Concurrency  │ Exponential Backoff with Jitter │
│ HTTP 504 Timeout    │ Synchronous Connection Block  │ Asynchronous Polling Lifecycle  │
│ Upstream Queue Jam  │ Regional Cluster Peak Surge   │ Multi-Model Dynamic Fallback    │
│ Malformed Payloads  │ Unsupported Aspect Ratio      │ Client-side JSON Schema Guard   │
└─────────────────────┴───────────────────────────────┴─────────────────────────────────┘

import time
import random
import requests

def dispatch_with_backoff(payload: dict, max_retries: int = 5) -> dict:
    url = "https://api.toapis.com/v1/videos/generations"
    headers = {
        "Authorization": f"Bearer {os.getenv('TOAPIS_API_KEY')}",
        "Content-Type": "application/json"
    }

    base_delay = 2.0  # initial sleep in seconds
    max_delay = 30.0

    for attempt in range(1, max_retries + 1):
        try:
            response = requests.post(url, headers=headers, json=payload, timeout=30)
            
            if response.status_code == 200 or response.status_code == 202:
                return response.json()
            
            if response.status_code == 429:
                # Calculate exponential delay with randomized jitter
                jitter = random.uniform(-0.5, 0.5)
                delay = min(max_delay, (base_delay * (2 ** (attempt - 1)))) + jitter
                delay = max(1.0, delay)
                print(f"[!] Hit 429 Rate Limit. Attempt {attempt}/{max_retries}. Backing off for {delay:.2f}s...")
                time.sleep(delay)
                continue

            response.raise_for_status()

        except requests.exceptions.RequestException as e:
            print(f"[WARN] Connection error on attempt {attempt}: {e}")
            time.sleep(base_delay)

    raise RuntimeError(f"Task dispatch failed after {max_retries} retries due to persistent rate limiting.")

FALLBACK_CASCADE = [
    "doubao-seedance-2-0",       # Primary Production Model
    "doubao-seedance-2-0-mini",  # High-throughput Fast Fallback
    "kling-3-omni"               # Cross-Vendor High-Availability Fallback
]

def dispatch_resilient_generation(prompt: str, aspect_ratio: str = "16:9") -> dict:
    headers = {
        "Authorization": f"Bearer {os.getenv('TOAPIS_API_KEY')}",
        "Content-Type": "application/json"
    }

    for model_name in FALLBACK_CASCADE:
        print(f"[*] Attempting dispatch with engine: {model_name}...")
        payload = {
            "model": model_name,
            "prompt": prompt,
            "aspect_ratio": aspect_ratio,
            "duration": 5
        }

        try:
            res = requests.post(
                "https://api.toapis.com/v1/videos/generations",
                headers=headers,
                json=payload,
                timeout=25
            )
            
            if res.status_code in (200, 201, 202):
                data = res.json()
                print(f"[✔] Successfully enqueued on engine {model_name} (Task ID: {data['data']['task_id']})")
                return data
            
            print(f"[!] Engine {model_name} responded with status {res.status_code}. Falling back to next candidate...")
        except requests.exceptions.RequestException as err:
            print(f"[!] Network failure targeting {model_name}: {err}. Shifting to fallback...")

    raise SystemError("Critical failure: All video generation engines in cascade exhausted.")