Seedance 2.0 API: Hur du genererar AI-videor programmatiskt

Generera en filmisk AI-video med en HTTP-förfrågan. Seedance 2.0 API använder samma generationspipeline som webbplattformen, exponerad som ett rent REST-gränssnitt med Bearer-autentisering, webhooks och batch-slutpunkter. Om du kan göra en POST-förfrågan kan du bygga en videogeneringspipeline.

Den här guiden täcker allt du behöver för att integrera Seedance 2.0 i dina egna applikationer: autentisering, slutpunkter, parametrar, felhantering och produktionsklar kodexempel i Python och JavaScript.

TL;DR - API i korthet

• Bas-URL: https://api.arteza.ai/v1
• Autentisering: Bearer-token i Authorization-headern
• Generering: Asynkron - skicka in en uppgift, avsöka eller använd webhook för färdigställande
• Hastighetsbegränsningar: 60 förfrågningar/minut, 5 samtidiga generationer
• Modeller: Seedance 2.0, 1.0 Pro, 1.0 Lite, Seedream v3/v4.5/v5 alla i ett API
• Kreditkostnad: Samma dynamiska per-sekundprissättning som webgränssnittet (~243-910 credits för 2.0)

Vad API:t faktiskt kan göra

Allt webgränssnittet gör kan API:t också göra. Text-till-video, bild-till-video, modellval, varaktighetskontroll, bildförhållande, ljudväxlingar och åtkomst till varje modell på plattformen. Batch-slutpunkter för att generera många klipp på en gång. Webhook-meddelanden så du inte behöver avsöka. Anpassade metadata som echoas tillbaka i resultat för spårning av A/B-tester eller kampanjvarianter.

Modeller som stöds

Alla modeller använder samma API-yta, bara med olika identifierare.

Autentisering på 30 sekunder

Generera en API-nyckel från kontrollpanelen under Settings > API Keys. Skicka den som en Bearer-token:

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

Svar:

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

Säkerhetsregler som spelar roll:

• Skicka aldrig din API-nyckel i klientkod eller offentliga arkiv
• Lagra den i miljövariabler (SEEDANCE_API_KEY)
• Rotera nycklar regelbundet från kontrollpanelen
• Varje nyckel ärver kreditbalansen från sitt överordnade konto

Slutpunkten för text-till-video

Det här är slutpunkten du kommer att använda mest.

POST /v1/generate/text-to-video

{
  "model": "seedance-2.0",
  "prompt": "Luftvy över en kuststad vid solnedgång, gyllene ljus som reflekteras på glaskraschanyer, filmisk dronfilmning",
  "duration": 10,
  "aspect_ratio": "16:9",
  "audio": true
}

Parameterreferens

Framgångsrikt svar

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

Genereringen är asynkron. Du får en task_id omedelbar och avsöker för färdigställande (eller använder webhooks).

Slutpunkten för bild-till-video

Animera en källbild med en rörelseförfrågan.

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

Föredrar du att inte ladda upp en fil? Skicka en image_url istället:

{
  "model": "seedance-2.0",
  "image_url": "https://example.com/photo.jpg",
  "prompt": "Kvinnan vänder långsamt på huvudet och ler, vind som försiktigt blåser hennes hår",
  "duration": 8,
  "aspect_ratio": "16:9"
}

Kontrollera genereringsstatus

Avsök uppgiftslutpunkten för att kontrollera framsteg.

GET /v1/tasks/{task_id}

Pågår-svar

{
  "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"
}

Färdigställt svar

{
  "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"
}

Statusvärden

Video-URL:er förfaller på 24 timmar. Ladda ned och lagra dem på din egen infrastruktur omedelbar.

Vill du generera resultat som detta programmässigt? Du är 30 sekunder ifrån ditt första API-anrop. Få din API-nyckel gratis →

Produktionsklar Python-exempel

Här är ett komplett skript som skickar in en generering, avsöker för färdigställande och laddar ner resultatet.

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"):
    """Skicka in en text-till-video-uppgift. Returnerar 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):
    """Avsök tills uppgiften är färdig. Returnerar resultatdict."""
    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"Generering misslyckades: {data.get('error')}")

        time.sleep(poll_interval)
        elapsed += poll_interval

    raise TimeoutError(f"Uppgift {task_id} slutfördes inte inom {timeout}s")


def download_video(video_url, output_path):
    """Strömma videon till disk."""
    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="En katt sitter på en fönsterbräda och tittar på regnet som faller utanför, mysig inomhusbelysning, grund skärpedjup",
        duration=10,
    )
    print(f"Uppgift skickad: {task_id}")

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

    download_video(result["video_url"], "output.mp4")
    print("Nedladdat till output.mp4")

JavaScript (Node.js) exempel

Samma arbetsflöde i modernt Node.js med inbyggd 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(`Generering misslyckades: ${data.error}`);
    }

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

  throw new Error(`Uppgift ${taskId} tidsgräns överskred`);
}

// Användning
const taskId = await generateVideo(
  "Tidsintervall av en blomma som blomstrar, makrolins, mjuk naturlig belysning",
  12
);
console.log(`Uppgift skickad: ${taskId}`);

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

Bild-till-video i Python

När du behöver ladda upp en källbild, använd multipart/form-data:

def generate_from_image(image_path, prompt, model="seedance-2.0", duration=8):
    """Generera video från en lokal bildfil."""
    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"]

Felhantering som inte kollapsar

API:t använder standard-HTTP-statuskoder med strukturerade felkroppar.

Felsvarform

{
  "error": {
    "code": "insufficient_credits",
    "message": "Ditt konto har 150 credits men denna generering kräver 607 credits.",
    "required_credits": 607,
    "available_credits": 150
  }
}

Rekommenderat mönster

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"Behöver {error['required_credits']} credits, har {error['available_credits']}")
        # Omdirigera användaren till /pricing
    elif status == 429:
        retry_after = int(e.response.headers.get("Retry-After", 60))
        print(f"Hastighetsbegränsad. Försök igen efter {retry_after}s.")
    else:
        raise

Hastighetsbegränsningar och produktionsbästa metoder

Gränserna

Fem metoder som spelar roll i produktion

1. Använd webhooks, inte avsökning, i stor skala. Avsökning slösar API-anrop. Webhooks utlöses exakt en gång.
2. Implementera exponentiell backoff på 429-svar. Försök inte igen omedelbar.
3. Ladda ned video-URL:er omedelbar. De förfaller på 24 timmar. Lagra dem på din egen CDN.
4. Validera inmatningar klientside. Fånga promptlängd och filstorleksproblem innan du slår API:t.
5. Kontrollera kreditbalans före batch-jobb. En 402 mitt i batch är irriterande. Fråga /account/credits först.

Webhook-integration

Inkludera webhook_url i din genereringsbegäran och Arteza kommer att POST:a till den när uppgiften färdigställs.

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

Webhook-nyttolast

{
  "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"
}

Webhook-förfrågningar innehåller en X-Seedance-Signature-header, en HMAC-SHA256-signatur av kroppen signerad med din webhook-hemlighet. Verifiera alltid signaturen innan du bearbetar händelser.

Batch-generering

När du behöver flera klipp skickar du dem som en batch och får en webhook när allt är färdigt.

POST /v1/generate/batch

{
  "tasks": [
    {
      "type": "text-to-video",
      "model": "seedance-2.0",
      "prompt": "Scen 1-beskrivning...",
      "duration": 8
    },
    {
      "type": "text-to-video",
      "model": "seedance-2.0",
      "prompt": "Scen 2-beskrivning...",
      "duration": 10
    },
    {
      "type": "image-to-video",
      "model": "seedance-1.0-pro",
      "image_url": "https://example.com/product.jpg",
      "prompt": "Långsam rotation som avslöjar produktdetaljer",
      "duration": 6
    }
  ],
  "webhook_url": "https://yourapp.com/api/seedance/batch-complete"
}

Uppgifter i en batch bearbetas samtidigt upp till din samtidighetsgräns.

Fyra användarfall väl värda att bygga

1. E-handelsproduktvideos i stor skala

Automatisera produktanimering för din hela katalog. Loopa över din produktdatabas, ställ en bild-till-video-anrop per objekt, lagra de resulterande URL:erna tillsammans med produktposten.

products = get_products_from_database()

for product in products:
    task_id = generate_from_image(
        image_path=product["hero_image"],
        prompt=f"Långsam 360-graders rotation av {product['name']}, studioljus, vit bakgrund",
        model="seedance-1.0-pro",
        duration=6,
    )
    save_task_mapping(product["id"], task_id)

Kombinera detta med e-handelsvideoguide för arbetsflödetips.

2. Automatiserade mediepipelines för sociala medier

Mata trendande ämnen in i promptgeneratorer, generera daglig lodrät video, skicka till en granskningskö:

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. A/B-testning av marknadsföring

Generera flera kreativa varianter med metadataspårning:

variants = [
    "Produkthjälteskott med varm belysning, lyxkänsla",
    "Produkthjälteskott med ljus belysning, energisk känsla",
    "Produkthjälteskott med mörk belysning, premiumkänsla",
]

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

metadata-fältet echoas tillbaka i färdigställelsesnyttolasten, så du kan automatiskt dirigera resultat till rätt kampanjhink.

4. Interaktiva applikationer

Bygg videogenerering direkt in i din egen app. En användare skriver en prompt, din backend anropar API:t, webhoken levererar det färdiga klippet. Hela loopen tar ~90 sekunder.

Slutsatsen

Arteza API är enkelt att integrera och produktionsklart. Enkel autentisering, rent REST-semantik, webhooks för asynkront arbete och batch-slutpunkter för skalning. Om du har använt Stripe eller något modernt REST API kommer du att känna dig hemma på tio minuter.

För prissättning och kreditoptimering, se prisguide. För en bredare produktöversikt, läs komplett Seedance 2.0-guide.

Redo att börja bygga? Skapa ditt kostnadsfria konto →

Fortsätt läsa: Komplett Seedance 2.0-guide • Prisguide • Seedance 2.0 vs Seedance 1.0 • Seedance 2.0 vs Runway Gen-4