Seedance 2.0 API: så genererar du AI-videor programmatiskt

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

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

TL;DR - API:et i korthet

• Bas-URL: https://api.arteza.ai/v1
• Autentisering: Bearer-token i Authorization-headern
• Generering: Asynkron - skicka en uppgift och poll:a eller använd webhook för slutförande
• Hastighetsgränser: 60 förfrågningar/minut, 5 samtidiga genereringar
• Modeller: Seedance 2.0, 1.0 Pro, 1.0 Lite, Seedream v3/v4.5/v5 - alla i ett API
• Kreditkostnad: Samma dynamiska prissättning per sekund som i webbgränssnittet (19-351 krediter för 2.0)

Vad API:et faktiskt kan göra

Allt som webbgränssnittet gör kan API:et också göra. Text till video, bild till video, val av modell, kontroll av längd, bildförhållande, ljudinställningar och åtkomst till varje modell på plattformen. Batch-endpoints för att generera många klipp på en gång. Webhook-notifieringar så att du inte behöver poll:a. Anpassad metadata som returneras i resultaten för spårning av A/B-tester eller kampanjvarianter.

Modeller som stöds

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

Autentisering på 30 sekunder

Skapa en API-nyckel från instrumentpanelen under Inställningar > API-nycklar. 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 är viktiga:

• Skicka aldrig din API-nyckel i kod på klientsidan eller i offentliga repos
• Lagra den i miljövariabler (SEEDANCE_API_KEY)
• Rotera nycklar regelbundet från instrumentpanelen
• Varje nyckel ärver kreditbalansen från sitt överordnade konto

Endpointen för text till video

Det här är den endpoint du kommer att använda mest.

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
}

Parameterreferens

Lyckat 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 ett task_id omedelbart och poll:ar för slutförande (eller använder webhooks).

Endpointen för bild till video

Animera en källbild med en rörelseprompt.

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

Föredrar du att inte ladda upp en fil? Skicka istället en 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"
}

Kontrollera genereringsstatus

Poll:a uppgifts-endpointen för att kontrollera förloppet.

GET /v1/tasks/{task_id}

Svar under pågående bearbetning

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

Svar vid slutförande

{
  "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 efter 24 timmar. Ladda ned och lagra dem på din egen infrastruktur utan dröjsmål.

Vill du generera sådan här utdata programmatiskt? Du är 30 sekunder från ditt första API-anrop. Hämta din API-nyckel gratis →

Produktionsklart Python-exempel

Här är ett komplett skript som skickar en generering, poll:ar för slutförande och laddar ned 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"):
    """Submit a text-to-video task. Returns 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):
    """Poll until the task finishes. Returns result dict."""
    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):
    """Stream the video to 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="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")

JavaScript (Node.js)-exempel

Samma arbetsflöde i modern 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(`Generation failed: ${data.error}`);
    }

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

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

// Användning
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}`);

Bild till video i Python

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

def generate_from_image(image_path, prompt, model="seedance-2.0", duration=8):
    """Generate video from a local image file."""
    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 håller

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

Felsvarsformat

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

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"Need {error['required_credits']} credits, have {error['available_credits']}")
        # Omdirigera användaren till /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

Hastighetsgränser och bästa praxis i produktion

Gränserna

Fem metoder som är viktiga i produktion

1. Använd webhooks, inte poll:ning, i stor skala. Poll:ning slösar API-anrop. Webhooks utlöses exakt en gång.
2. Implementera exponentiell backoff vid 429-svar. Försök inte igen omedelbart.
3. Ladda ned video-URL:er utan dröjsmål. De förfaller efter 24 timmar. Lagra dem på ditt eget CDN.
4. Validera indata på klientsidan. Fånga problem med promptlängd och filstorlek innan du når API:et.
5. Kontrollera kreditbalansen före batch-jobb. Ett 402-fel mitt i en batch är irriterande. Fråga /account/credits först.

Webhook-integration

Inkludera webhook_url i din genereringsförfrågan så skickar Arteza en POST till den när uppgiften slutförs.

{
  "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 inkluderar 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 klart.

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

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

Fyra användningsfall värda att bygga

1. Produktvideor för e-handel i stor skala

Automatisera produktanimering för hela din katalog. Loopa igenom din produktdatabas, skicka ett bild-till-video-anrop per artikel och 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"Slow 360 rotation of {product['name']}, studio lighting, white background",
        model="seedance-1.0-pro",
        duration=6,
    )
    save_task_mapping(product["id"], task_id)

Kombinera det här med guide för e-handelsvideo för tips om arbetsflöden.

2. Automatiserade pipelines för sociala medier

Mata trendande ämnen in i promptgeneratorer, generera dagliga vertikala videor och skicka dem 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 = [
    "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"},
    )

Fältet metadata returneras i slutförandenyttolasten, så att du automatiskt kan dirigera resultat till rätt kampanjhink.

4. Interaktiva applikationer

Bygg videogenerering direkt i din egen app. En användare skriver en prompt, din backend anropar API:et och webhook:en levererar det färdiga klippet. Hela loopen tar ungefär 90 sekunder.

Sammanfattning

Arteza API är enkelt att integrera och produktionsklart. Enkel autentisering, renodlad REST-semantik, webhooks för asynkront arbete och batch-endpoints 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 guide för Seedance 2.0.

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

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