Seedance 2.0 API: jak generować filmy AI programistycznie

Wygeneruj kinematograficzny film AI za pomocą jednego żądania HTTP. API Seedance 2.0 korzysta z tego samego potoku generowania co platforma webowa, udostępnionego jako przejrzysty interfejs REST z autoryzacją Bearer, webhookami i endpointami wsadowymi. Jeśli potrafisz wysłać żądanie POST, możesz zbudować własny potok generowania wideo.

Ten przewodnik omawia wszystko, czego potrzebujesz, aby zintegrować Seedance 2.0 z własnymi aplikacjami: autoryzację, endpointy, parametry, obsługę błędów oraz gotowe do produkcji przykłady kodu w Pythonie i JavaScript.

TL;DR - API w skrócie

• Bazowy URL: https://api.arteza.ai/v1
• Autoryzacja: token Bearer w nagłówku Authorization
• Generowanie: asynchroniczne - wyślij zadanie, monitoruj wynik przez polling lub webhook
• Limity żądań: 60 żądań na minutę, 5 równoczesnych generowań
• Modele: Seedance 2.0, 1.0 Pro, 1.0 Lite, Seedream v3/v4.5/v5 - wszystkie w jednym API
• Koszt kredytów: taki sam dynamiczny cennik za sekundę jak w interfejsie webowym (19-351 kredytów dla 2.0)

Co API naprawdę potrafi

Wszystko, co robi interfejs webowy, API też robi. Generowanie wideo z tekstu, generowanie wideo z obrazu, wybór modelu, kontrola czasu trwania, proporcje obrazu, przełączniki audio oraz dostęp do każdego modelu na platformie. Endpointy wsadowe do generowania wielu klipów jednocześnie. Powiadomienia webhook, dzięki którym nie musisz odpytywać serwera. Niestandardowe metadane, które są odsyłane z powrotem w wynikach do śledzenia testów A/B lub wariantów kampanii.

Obsługiwane modele

Wszystkie modele korzystają z tej samej powierzchni API, różnią się jedynie identyfikatorami.

Autoryzacja w 30 sekund

Wygeneruj klucz API z panelu w sekcji Ustawienia > Klucze API. Wyślij go jako token Bearer:

curl -H "Authorization: Bearer YOUR_API_KEY" \
     https://api.arteza.ai/v1/account/credits

Odpowiedź:

{
  "credits": 2750,
  "tier": "popular"
}

Zasady bezpieczeństwa, które mają znaczenie:

• Nigdy nie umieszczaj klucza API w kodzie po stronie klienta ani w publicznych repozytoriach
• Przechowuj go w zmiennych środowiskowych (SEEDANCE_API_KEY)
• Regularnie rotuj klucze z poziomu panelu
• Każdy klucz dziedziczy saldo kredytów konta nadrzędnego

Endpoint generowania wideo z tekstu

To endpoint, z którego będziesz korzystać najczęściej.

POST /v1/generate/text-to-video

{
  "model": "seedance-2.0",
  "prompt": "Aerial shot of a coastal city at sunset, golden light reflecting off glass skyscrapers, cinematic drone footage",
  "duration": 10,
  "aspect_ratio": "16:9",
  "audio": true
}

Dokumentacja parametrów

Odpowiedź po sukcesie

{
  "task_id": "task_abc123def456",
  "status": "queued",
  "model": "seedance-2.0",
  "credits_charged": 607,
  "estimated_time": 120,
  "created_at": "2026-04-10T14:30:00Z"
}

Generowanie odbywa się asynchronicznie. Natychmiast otrzymujesz task_id i możesz sprawdzać status przez polling (lub używać webhooków).

Endpoint generowania wideo z obrazu

Animuj obraz źródłowy za pomocą promptu ruchu.

POST /v1/generate/image-to-video
Content-Type: multipart/form-data

Nie chcesz przesyłać pliku? Podaj zamiast tego image_url:

{
  "model": "seedance-2.0",
  "image_url": "https://example.com/photo.jpg",
  "prompt": "The woman turns her head slowly and smiles, wind gently blowing her hair",
  "duration": 8,
  "aspect_ratio": "16:9"
}

Sprawdzanie statusu generowania

Odpytuj endpoint zadania, aby sprawdzić postęp.

GET /v1/tasks/{task_id}

Odpowiedź w trakcie przetwarzania

{
  "task_id": "task_abc123def456",
  "status": "processing",
  "progress": 65,
  "model": "seedance-2.0",
  "created_at": "2026-04-10T14:30:00Z",
  "estimated_completion": "2026-04-10T14:31:30Z"
}

Odpowiedź po ukończeniu

{
  "task_id": "task_abc123def456",
  "status": "completed",
  "model": "seedance-2.0",
  "result": {
    "video_url": "https://cdn.arteza.ai/outputs/task_abc123def456.mp4",
    "duration": 10,
    "resolution": "1280x720",
    "has_audio": true,
    "file_size": 8542310
  },
  "credits_charged": 607,
  "created_at": "2026-04-10T14:30:00Z",
  "completed_at": "2026-04-10T14:31:28Z"
}

Wartości statusu

Adresy URL wideo wygasają po 24 godzinach. Pobierz je i przechowaj na własnej infrastrukturze możliwie szybko.

Chcesz programowo generować takie wyniki? Dzielą Cię od pierwszego wywołania API dosłownie 30 sekund. Pobierz bezpłatny klucz API →

Gotowy do produkcji przykład w Pythonie

Kompletny skrypt, który wysyła zadanie generowania, odpytuje serwer do momentu ukończenia i pobiera wynik.

import os
import time
import requests

API_KEY = os.environ["SEEDANCE_API_KEY"]
BASE_URL = "https://api.arteza.ai/v1"
HEADERS = {"Authorization": f"Bearer {API_KEY}"}


def generate_video(prompt, duration=8, aspect_ratio="16:9"):
    """Wyślij zadanie text-to-video. Zwraca task_id."""
    response = requests.post(
        f"{BASE_URL}/generate/text-to-video",
        headers=HEADERS,
        json={
            "model": "seedance-2.0",
            "prompt": prompt,
            "duration": duration,
            "aspect_ratio": aspect_ratio,
            "audio": True,
        },
    )
    response.raise_for_status()
    return response.json()["task_id"]


def wait_for_completion(task_id, poll_interval=5, timeout=300):
    """Odpytuj serwer do zakończenia zadania. Zwraca słownik wyników."""
    elapsed = 0
    while elapsed < timeout:
        response = requests.get(f"{BASE_URL}/tasks/{task_id}", headers=HEADERS)
        response.raise_for_status()
        data = response.json()

        if data["status"] == "completed":
            return data["result"]
        if data["status"] == "failed":
            raise RuntimeError(f"Generation failed: {data.get('error')}")

        time.sleep(poll_interval)
        elapsed += poll_interval

    raise TimeoutError(f"Task {task_id} did not complete within {timeout}s")


def download_video(video_url, output_path):
    """Pobierz wideo strumieniowo na dysk."""
    response = requests.get(video_url, stream=True)
    response.raise_for_status()
    with open(output_path, "wb") as f:
        for chunk in response.iter_content(chunk_size=8192):
            f.write(chunk)


if __name__ == "__main__":
    task_id = generate_video(
        prompt="A cat sitting on a windowsill watching rain fall outside, cozy indoor lighting, shallow depth of field",
        duration=10,
    )
    print(f"Task submitted: {task_id}")

    result = wait_for_completion(task_id)
    print(f"Video ready: {result['video_url']}")

    download_video(result["video_url"], "output.mp4")
    print("Downloaded to output.mp4")

Przykład w JavaScript (Node.js)

Ten sam przepływ pracy w nowoczesnym Node.js z natywnym fetch.

const API_KEY = process.env.SEEDANCE_API_KEY;
const BASE_URL = "https://api.arteza.ai/v1";

async function generateVideo(prompt, duration = 8, aspectRatio = "16:9") {
  const response = await fetch(`${BASE_URL}/generate/text-to-video`, {
    method: "POST",
    headers: {
      Authorization: `Bearer ${API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      model: "seedance-2.0",
      prompt,
      duration,
      aspect_ratio: aspectRatio,
      audio: true,
    }),
  });

  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${await response.text()}`);
  }
  const data = await response.json();
  return data.task_id;
}

async function waitForCompletion(taskId, pollMs = 5000, timeoutMs = 300000) {
  const start = Date.now();

  while (Date.now() - start < timeoutMs) {
    const response = await fetch(`${BASE_URL}/tasks/${taskId}`, {
      headers: { Authorization: `Bearer ${API_KEY}` },
    });
    const data = await response.json();

    if (data.status === "completed") return data.result;
    if (data.status === "failed") {
      throw new Error(`Generation failed: ${data.error}`);
    }

    await new Promise((resolve) => setTimeout(resolve, pollMs));
  }

  throw new Error(`Task ${taskId} timed out`);
}

// Użycie
const taskId = await generateVideo(
  "Timelapse of a flower blooming, macro lens, soft natural lighting",
  12
);
console.log(`Task submitted: ${taskId}`);

const result = await waitForCompletion(taskId);
console.log(`Video ready: ${result.video_url}`);

Generowanie wideo z obrazu w Pythonie

Gdy musisz przesłać obraz źródłowy, użyj multipart/form-data:

def generate_from_image(image_path, prompt, model="seedance-2.0", duration=8):
    """Generuj wideo z lokalnego pliku graficznego."""
    with open(image_path, "rb") as img_file:
        response = requests.post(
            f"{BASE_URL}/generate/image-to-video",
            headers={"Authorization": f"Bearer {API_KEY}"},
            files={"image": img_file},
            data={
                "model": model,
                "prompt": prompt,
                "duration": duration,
                "aspect_ratio": "16:9",
                "audio": "true",
            },
        )
    response.raise_for_status()
    return response.json()["task_id"]

Obsługa błędów, która nie zawodzi

API używa standardowych kodów statusu HTTP ze strukturalnymi treściami błędów.

Struktura odpowiedzi błędu

{
  "error": {
    "code": "insufficient_credits",
    "message": "Your account has 8 credits but this generation requires 24 credits.",
    "required_credits": 24,
    "available_credits": 8
  }
}

Zalecany wzorzec

try:
    task_id = generate_video(prompt)
except requests.exceptions.HTTPError as e:
    status = e.response.status_code
    if status == 402:
        error = e.response.json()["error"]
        print(f"Need {error['required_credits']} credits, have {error['available_credits']}")
        # Przekieruj użytkownika do /pricing
    elif status == 429:
        retry_after = int(e.response.headers.get("Retry-After", 60))
        print(f"Rate limited. Retry after {retry_after}s.")
    else:
        raise

Limity żądań i dobre praktyki produkcyjne

Limity

Pięć praktyk, które mają znaczenie w produkcji

1. Na dużą skalę używaj webhooków zamiast pollingu. Polling marnuje wywołania API. Webhooki odpalają się dokładnie raz.
2. Implementuj wykładnicze opóźnienie przy odpowiedziach 429. Nie wznawiaj próby natychmiast.
3. Pobieraj adresy URL wideo jak najszybciej. Wygasają po 24 godzinach. Przechowuj je na własnym CDN.
4. Waliduj dane wejściowe po stronie klienta. Wyłapuj problemy z długością promptu i rozmiarem pliku przed wywołaniem API.
5. Sprawdzaj saldo kredytów przed zadaniami wsadowymi. Błąd 402 w połowie operacji wsadowej jest irytujący. Najpierw odpytaj /account/credits.

Integracja webhooków

Dodaj webhook_url do żądania generowania, a Arteza wyśle do niego POST, gdy zadanie się zakończy.

{
  "model": "seedance-2.0",
  "prompt": "...",
  "webhook_url": "https://yourapp.com/api/seedance/webhook"
}

Payload webhooka

{
  "event": "task.completed",
  "task_id": "task_abc123def456",
  "status": "completed",
  "result": {
    "video_url": "https://cdn.arteza.ai/outputs/task_abc123def456.mp4",
    "duration": 10,
    "resolution": "1280x720",
    "has_audio": true
  },
  "metadata": {
    "campaign_id": "summer-2026",
    "variant": "A"
  },
  "timestamp": "2026-04-10T14:31:28Z"
}

Żądania webhooka zawierają nagłówek X-Seedance-Signature - sygnaturę HMAC-SHA256 treści podpisaną Twoim sekretnym kluczem webhooka. Zawsze weryfikuj sygnaturę przed przetworzeniem zdarzeń.

Generowanie wsadowe

Gdy potrzebujesz wielu klipów, wyślij je jako partię i odbierz jeden webhook po zakończeniu wszystkich.

POST /v1/generate/batch

{
  "tasks": [
    {
      "type": "text-to-video",
      "model": "seedance-2.0",
      "prompt": "Scene 1 description...",
      "duration": 8
    },
    {
      "type": "text-to-video",
      "model": "seedance-2.0",
      "prompt": "Scene 2 description...",
      "duration": 10
    },
    {
      "type": "image-to-video",
      "model": "seedance-1.0-pro",
      "image_url": "https://example.com/product.jpg",
      "prompt": "Slow rotation revealing product details",
      "duration": 6
    }
  ],
  "webhook_url": "https://yourapp.com/api/seedance/batch-complete"
}

Zadania w partii są przetwarzane równocześnie, do Twojego limitu współbieżności.

Cztery przypadki użycia warte wdrożenia

1. Filmy produktów e-commerce na dużą skalę

Zautomatyzuj animacje produktów dla całego katalogu. Przeiteruj po bazie danych produktów, wywołaj image-to-video dla każdej pozycji i zapisz wynikowe URL-e obok rekordu produktu.

products = get_products_from_database()

for product in products:
    task_id = generate_from_image(
        image_path=product["hero_image"],
        prompt=f"Slow 360 rotation of {product['name']}, studio lighting, white background",
        model="seedance-1.0-pro",
        duration=6,
    )
    save_task_mapping(product["id"], task_id)

Połącz to z przewodnik po wideo e-commerce, aby uzyskać wskazówki dotyczące przepływu pracy.

2. Zautomatyzowane pipeline'y mediów społecznościowych

Przekazuj popularne tematy do generatorów promptów, generuj codzienne pionowe wideo i kieruj je do kolejki przeglądania:

for topic in get_trending_topics():
    prompt = build_prompt(topic)
    task_id = generate_video(prompt, duration=6, aspect_ratio="9:16")
    queue_for_review(task_id, topic)

3. Testy A/B w marketingu

Generuj wiele wariantów kreatywnych ze śledzeniem metadanych:

variants = [
    "Product hero shot with warm lighting, luxury feel",
    "Product hero shot with bright lighting, energetic feel",
    "Product hero shot with moody lighting, premium feel",
]

for i, variant in enumerate(variants):
    generate_video(
        prompt=variant,
        duration=6,
        metadata={"variant": chr(65 + i), "campaign": "spring-launch"},
    )

Pole metadata jest odsyłane z powrotem w payloadzie ukończenia, dzięki czemu możesz automatycznie kierować wyniki do odpowiedniego segmentu kampanii.

4. Aplikacje interaktywne

Wbuduj generowanie wideo bezpośrednio we własną aplikację. Użytkownik wpisuje prompt, Twój backend wywołuje API, webhook dostarcza gotowy klip. Cały cykl trwa około 90 sekund.

Podsumowanie

API Arteza jest proste w integracji i gotowe do użytku produkcyjnego. Prosta autoryzacja, czysta semantyka REST, webhooki do pracy asynchronicznej i endpointy wsadowe do skalowania. Jeśli korzystałeś ze Stripe lub innego nowoczesnego API REST, poczujesz się jak w domu w ciągu dziesięciu minut.

Informacje o cenach i optymalizacji kredytów znajdziesz w przewodnik po cenach. Szerszy przegląd produktu znajdziesz w kompletny przewodnik po Seedance 2.0.

Gotowy, żeby zacząć budować? Załóż bezpłatne konto →

Czytaj dalej: Kompletny przewodnik po Seedance 2.0 • Przewodnik po cenach • Seedance 2.0 vs Seedance 1.0 • Seedance 2.0 vs Runway Gen-4