Seedance 2.0
开发者文档

BASE_URL="https://new.fluapi.com/v1"

TASK_ID=$(curl -sS -X POST "$BASE_URL/videos" \
  -H "Authorization: Bearer $FLUAPI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "seedance-2.0",
    "prompt": "清晨海面上的白色帆船，镜头平稳横移，电影感光影，轻微海浪声",
    "seconds": "5",
    "size": "864x496",
    "audio": true
  }' | jq -r '.id')

test -n "$TASK_ID" || { printf 'missing task id\n'; exit 1; }
DEADLINE=$(( $(date +%s) + 1500 ))

while true; do
  RESULT=$(curl -sS "$BASE_URL/videos/$TASK_ID" \
    -H "Authorization: Bearer $FLUAPI_API_KEY")
  STATUS=$(printf '%s' "$RESULT" | jq -r '.status')
  printf 'status=%s\n' "$STATUS"

  [ "$STATUS" = "completed" ] && break
  [ "$STATUS" = "failed" ] && printf '%s\n' "$RESULT" && exit 1
  [ "$(date +%s)" -ge "$DEADLINE" ] && exit 2
  sleep 8
done

curl -L "$BASE_URL/videos/$TASK_ID/content" \
  -H "Authorization: Bearer $FLUAPI_API_KEY" \
  --output seedance-result.mp4

import os
import time
import requests

BASE_URL = "https://new.fluapi.com/v1"
API_KEY = os.environ["FLUAPI_API_KEY"]
AUTH = {"Authorization": f"Bearer {API_KEY}"}

payload = {
    "model": "seedance-2.0",
    "prompt": "清晨海面上的白色帆船，镜头平稳横移，电影感光影，轻微海浪声",
    "seconds": "5",
    "size": "864x496",
    "audio": True,
}

created = requests.post(
    f"{BASE_URL}/videos",
    headers={**AUTH, "Content-Type": "application/json"},
    json=payload,
    timeout=60,
)
created.raise_for_status()
task_id = created.json()["id"]
deadline = time.monotonic() + 25 * 60

while True:
    response = requests.get(
        f"{BASE_URL}/videos/{task_id}",
        headers=AUTH,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    print(task["status"], task.get("progress"))

    if task["status"] == "completed":
        break
    if task["status"] == "failed":
        error = task.get("error") or {}
        raise RuntimeError(error.get("message") or error or task)
    if time.monotonic() >= deadline:
        raise TimeoutError(f"poll timeout; retain task_id={task_id}")
    time.sleep(8)

with requests.get(
    f"{BASE_URL}/videos/{task_id}/content",
    headers=AUTH,
    timeout=120,
    stream=True,
    allow_redirects=True,
) as video:
    video.raise_for_status()
    with open("seedance-result.mp4", "wb") as output:
        for chunk in video.iter_content(chunk_size=1024 * 1024):
            if chunk:
                output.write(chunk)

import { writeFile } from "node:fs/promises";

const baseUrl = "https://new.fluapi.com/v1";
const apiKey = process.env.FLUAPI_API_KEY;
const auth = { Authorization: `Bearer ${apiKey}` };

const createdResponse = await fetch(`${baseUrl}/videos`, {
  method: "POST",
  headers: { ...auth, "Content-Type": "application/json" },
  body: JSON.stringify({
    model: "seedance-2.0",
    prompt: "清晨海面上的白色帆船，镜头平稳横移，电影感光影，轻微海浪声",
    seconds: "5",
    size: "864x496",
    audio: true,
  }),
});

if (!createdResponse.ok) {
  throw new Error(await createdResponse.text());
}

const { id: taskId } = await createdResponse.json();
const deadline = Date.now() + 25 * 60 * 1000;
let task;

do {
  await new Promise((resolve) => setTimeout(resolve, 8000));
  const response = await fetch(`${baseUrl}/videos/${taskId}`, {
    headers: auth,
  });
  if (!response.ok) throw new Error(await response.text());
  task = await response.json();
  console.log(task.status, task.progress);

  if (task.status === "failed") {
    throw new Error(task.error?.message || JSON.stringify(task.error || task));
  }
  if (Date.now() >= deadline) {
    throw new Error(`Poll timeout; retain task_id=${taskId}`);
  }
} while (task.status !== "completed");

const videoResponse = await fetch(`${baseUrl}/videos/${taskId}/content`, {
  headers: auth,
  redirect: "follow",
});
if (!videoResponse.ok) throw new Error(await videoResponse.text());

await writeFile(
  "seedance-result.mp4",
  Buffer.from(await videoResponse.arrayBuffer()),
);