Seedance 2.5 API: guida per sviluppatori a endpoint, autenticazione e generazione video

Seedance 2.5 API: guida per sviluppatori a endpoint, autenticazione e generazione video

Seedance 2.5 è un modello video multimodale a lunga esecuzione, il che significa che l'API che lo pilota è asincrona, non un singolo ciclo richiesta-risposta. Invii un task di generazione, fai polling fino al completamento e scarichi il risultato. Una volta compreso questo pattern, insieme all'endpoint, all'header di autenticazione e ai campi del payload per durata, risoluzione e riferimenti, il resto è semplice.

Questa guida percorre l'intero contratto della Seedance 2.5 API: l'endpoint, l'autenticazione, il corpo della richiesta, il polling asincrono ed esempi funzionanti in curl e Python. Fa riferimento alla rotta della api-platform di PixMind, che rispecchia il contratto di ByteDance per il modello. Aggiunge anche un confronto side-by-side con i pattern API di Seedance 2.0 e Kling, un caso di studio end-to-end di pipeline di produzione, risorse per sviluppatori di terze parti e una FAQ ampliata che copre limiti di traffico, concorrenza, webhook e verifica dei crediti. Tutti i dettagli di endpoint e autenticazione sono verificati sul backend live al 2026-07-31.

Panoramica del modello Seedance 2.5

Punti chiave

• Endpoint: POST /api-platform/v1/generations per creare un task; GET /api-platform/v1/task/{task_id} per fare polling del risultato.
• Autenticazione: Authorization: Bearer <API_KEY> (oppure l'header X-API-Key); crea una chiave con scope video nella dashboard di PixMind.
• Payload: { model, prompt, duration, resolution, aspect_ratio, reference_images, reference_videos, generate_audio }.
• È asincrono: la chiamata di creazione restituisce un taskId; fai polling finché status è ready, poi leggi videoUrl.
• Shape tra provider: Seedance 2.5, Seedance 2.0 e Kling usano tutti lo stesso pattern invia-e-poi-fai-polling. Differiscono per percorso endpoint, budget di riferimenti e nomi dei campi.
• Pattern di produzione: aggiungi un Idempotency-Key in fase di creazione, fai polling con tentativi limitati e backoff, verifica i crediti prima dell'invio e ricorri a una rotta più economica per l'iterazione.
• L'accesso API è Coming Soon su PixMind; la rotta è documentata e pronta, la connessione al backend è in fase di finalizzazione.

Prerequisiti: ottieni una API Key

Le chiamate a Seedance 2.5 sono autenticate con una API Key con scope legato al tuo account. Crea una chiave nella dashboard della api-platform di PixMind e conservala in modo sicuro: trattala come qualsiasi altro secret. Carica la chiave da una variabile d'ambiente nel codice invece di committarla nel controllo versione:

export PIXMIND_API_KEY="pk-xxxxxxxxxxxxxxxx"

Crea una API Key

Su PixMind, i permessi delle chiavi sono limitati per workload (image / video). Assicurati che la tua chiave abbia il permesso video abilitato prima di chiamare Seedance 2.5.

Nota per sviluppatori: ruota le chiavi per ambiente (dev / staging / prod) e assegna a ciascuna chiave il workload minimo necessario. Una chiave di staging con solo scope video non può finire in una pipeline image, il che limita il raggio d'azione in caso di compromissione. Riemetti le chiavi a cadenza fissa e registra il timestamp di ultimo utilizzo, così le chiavi dormienti sono facili da trovare e revocare.

Guarda: walkthrough del workflow di Seedance 2.5

Il modo più veloce di capire l'upgrade 2.5 prima di scrivere codice è guardare i filmati demo ufficiali e le analisi della community. Questi due walkthrough coprono la generazione nativa a 30 secondi, l'output 4K, l'editing a livello di regione e il workflow con 50 riferimenti che l'API espone:

fallback noscript: Demo di Seedance 2.5 su YouTube, copre clip native a 30 secondi, modifica a livello di regione e 50 riferimenti multimodali.

Per una discussione editoriale più approfondita su cosa significano gli upgrade del workflow per una pipeline di produzione, vale la pena guardare l'analisi "Seedance 2.5 Changes Everything" insieme al reel ufficiale:

fallback noscript: "Seedance 2.5 Changes Everything" su YouTube.

Il contratto della Seedance 2.5 API

Endpoint

Crea un task di generazione:

POST /api-platform/v1/generations

Fai polling per il completamento:

GET /api-platform/v1/task/{task_id}

L'endpoint di creazione è il punto di ingresso unificato per la generazione: legge il campo model e instrada di conseguenza. Invia model: "seedance-2.5" e la rotta gestisce la pipeline video.

Autenticazione

Invia l'API Key come Bearer token (compatibile con l'OpenAI SDK):

Authorization: Bearer $PIXMIND_API_KEY

Il middleware di autenticazione accetta anche l'header X-API-Key se preferisci quella forma. Entrambi sono supportati: scegline uno e usalo in modo coerente in tutto il codice client, così log e retry sono più facili da tracciare.

Corpo della richiesta

Sui riferimenti: Seedance 2.5 accetta fino a 50 input multimodali in una singola richiesta: immagini, video, testo e audio combinati. Assegna a ciascun riferimento un solo ruolo esplicito (identità, forma, movimento, palette, ritmo) ed elimina gli asset che competono per la stessa proprietà.

Come si confronta la Seedance 2.5 API con Seedance 2.0 e Kling

Gran parte delle API di generazione video attuali condivide la stessa shape asincrona: una POST per creare un task, una GET per fare polling fino al completamento. Dove differiscono è nel percorso endpoint, nella convenzione di autenticazione, nel budget di riferimenti e nei nomi dei campi nel payload. La tabella che segue mappa queste differenze per le tre API che gli sviluppatori confrontano più spesso quando pianificano un'integrazione.

Osservazione diretta: la shape asincrona condivisa significa che il codice client è riutilizzabile tra provider. Avvolgi il ciclo crea-e-fai-polling in un'unica funzione generate_video(model, payload) e scambia l'ID del modello: puoi fare A/B tra Seedance 2.5, Seedance 2.0 Fast e Kling dallo stesso harness. Questo è il modo più economico per scegliere la rotta giusta per ogni shot senza riscrivere il codice di integrazione.

L'aspetto pratico: se il tuo team ha già costruito un client di polling per Seedance 2.0, adottare la 2.5 è solo un cambio di model-string più i nuovi campi per riferimenti e durata. Non serve ridisegnare l'integrazione.

Confronto tra i modelli Seedance 2.5 e Kling

Step 1: crea un task di generazione

Ecco una richiesta di creazione minimale, una clip da 5 secondi, 720p, 16:9 con un prompt testuale. L'header Idempotency-Key è facoltativo ma consigliato per qualsiasi invio in produzione:

curl -X POST https://aihub-admin.aimix.pro/api-platform/v1/generations \
  -H "Authorization: Bearer $PIXMIND_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{
    "model": "seedance-2.5",
    "prompt": "A courier in a yellow jacket cycling through a neon-lit rainy Tokyo street at night, tracking shot, cinematic, no text",
    "duration": 5,
    "resolution": "720p",
    "aspect_ratio": "16:9"
  }'

Una risposta corretta restituisce un task ID. Qui non ottieni il video, ottieni un handle da interrogare:

{
  "code": 1000,
  "data": {
    "taskId": "47264",
    "type": "video",
    "status": "processing"
  }
}

Se vedi code: 400 con "模型不存在或未配置" (modello inesistente o non configurato), la rotta backend per seedance-2.5 non è ancora stata abilitata su quell'endpoint. Questo è lo stato Coming-Soon su PixMind mentre la connessione viene finalizzata.

Step 2: fai polling del task fino a quando è ready

La generazione video è asincrona. Interroga l'endpoint del task con il taskId dello step 1:

curl -X GET https://aihub-admin.aimix.pro/open-api/v1/task/47264 \
  -H "Authorization: Bearer $PIXMIND_API_KEY"

Il campo status passa attraverso pending, poi processing, poi ready. Fai polling ogni 3-5 secondi. Quando il task è pronto, la risposta include l'URL finale del video:

{
  "code": 1000,
  "data": {
    "taskId": "47264",
    "status": "ready",
    "progress": 100,
    "videoUrl": "https://.../seedance-2-5-47264.mp4",
    "coverUrl": "https://.../seedance-2-5-47264-cover.webp"
  }
}

Gli stati terminali di fallimento sono failed, error, canceled e cancelled. Gestiscili e porta il campo description nei tuoi log.

Nota per sviluppatori: intervalli di polling di 3-5 secondi vanno bene per un singolo task, ma si moltiplicano in fretta su larga scala. Per una coda di 20 task, preferisci un unico ciclo dispatcher che interroghi ogni task aperto una volta per ciclo, con backoff esponenziale (5s, 5s, 10s, 15s, con tetto a 30s) man mano che i task invecchiano. Questo mantiene il volume di richieste educato senza allungare la latenza p99 per l'intero batch.

Step 3: scarica e usa il risultato

Quando status è ready, scarica videoUrl (e facoltativamente coverUrl per un fotogramma poster). Il file è un MP4 standard: transcodalo, hostalo o embeddilo come richiede la tua applicazione.

Per una landing page web, in genere lo comprimeresti in una clip H.264 da 8-10 secondi con fast-start per l'autoplay, estrarresti un poster WebP e ospiteresti entrambi sul tuo CDN. (PixMind ospita i media dei casi Seedance 2.5 su cdn.pixmind.io.) Non fare hotlink della videoUrl ospitata dall'API in produzione, perché non è garantito che l'URL dell'API persista.

Esempio Python completo

Ecco uno snippet Python completo ed eseguibile che crea un task, fa polling fino al ready e stampa l'URL del video. Aggiunge una Idempotency-Key, un ciclo di retry limitato e un tetto di timeout: le tre cose che servono a un client di produzione e che un esempio hello-world di solito omette:

import time
import uuid
import requests

API_BASE = "https://aihub-admin.aimix.pro"
API_KEY = "your-pixmind-api-key"  # scope: video

GEN = f"{API_BASE}/api-platform/v1/generations"
TASK = f"{API_BASE}/open-api/v1/task"
HEADERS = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

# 1. Create with an idempotency key so a retry does not start a second billed task
payload = {
    "model": "seedance-2.5",
    "prompt": "A 30-second continuous hero shot: a character walking through a neon city that flows into a product reveal",
    "duration": 30,
    "resolution": "1080p",
    "aspect_ratio": "16:9",
    "generate_audio": True,
}
headers = {**HEADERS, "Idempotency-Key": str(uuid.uuid4())}
create = requests.post(GEN, headers=headers, json=payload, timeout=30).json()
task_id = create["data"]["taskId"]
print(f"Task created: {task_id}")

# 2. Poll with bounded retries and gentle backoff
max_attempts, delay = 100, 5
for attempt in range(max_attempts):
    time.sleep(delay)
    t = requests.get(f"{TASK}/{task_id}", headers=HEADERS, timeout=15).json()
    status = t["data"]["status"].lower()
    print(f"attempt={attempt + 1} status={status} progress={t['data'].get('progress', 0)}%")
    if status in ("ready", "succeeded", "completed"):
        print("Video URL:", t["data"]["videoUrl"])
        break
    if status in ("failed", "error", "canceled", "cancelled"):
        raise RuntimeError(f"Task failed: {t['data']}")
    delay = min(delay + 2, 30)  # backoff, capped at 30s
else:
    raise TimeoutError(f"Task {task_id} did not finish in {max_attempts * 5}s")

Caso di studio end-to-end: una pipeline di product video da 30 secondi

Questa è la parte che la maggior parte delle guide API salta: come un team reale assembla il contratto qui sopra in una pipeline di produzione ripetibile. Lo scenario è un team creativo di quattro persone in un brand D2C che produce un hero video di 30 secondi per il lancio di un prodotto, con budget fisso e deadline rigida. Il pattern che segue è la shape che consegna in modo costante e puntuale.

Panoramica della pipeline

Il team suddivide il lavoro in quattro fasi: iterazione (test A/B economici su Seedance 2.0 Fast), generazione finale (una run Seedance 2.5 a 1080p / 30s), revisione e modifiche di regione (rigenerazione mirata di regione su Seedance 2.5) e delivery (transcodifica, poster, upload su CDN). Ogni fase usa lo stesso codice client; cambiano solo l'ID del modello e il payload. Questa separazione è ciò che rende la pipeline ripetibile tra campagne.

Allocazione dei riferimenti

Prima di qualsiasi chiamata API, il team assegna a ciascun riferimento un singolo ruolo esplicito, registrato in un foglio di calcolo condiviso così che prompt e payload restino sincronizzati. Cinque riferimenti sul budget di 50 input, ciascuno con un compito:

Il prompt mappa ciascuno in modo esplicito: "mantieni il personaggio di @Image 1 invariato; combacia il prodotto in @Image 2; usa @Video 1 solo per il movimento della camera; allinea i tagli a @Audio 1." La mappatura è il contratto tra la direzione creativa e il payload dell'API. Se un riferimento non ha un ruolo assegnato, non entra nella richiesta.

Fase di iterazione (controllo dei costi)

Prima di spendere per una run 2.5 da 30 secondi, il team valida prompt e riferimenti su Seedance 2.0 Fast a 5 secondi e 720p. È la stessa chiamata POST /api-platform/v1/generations con model: "seedance-2.0-fast". Tre iterazioni costano una frazione di una run 2.5 e portano in luce i conflitti tra riferimenti prima che il budget sia impegnato. Il dispatcher registra per ogni iterazione taskId, status ed elapsed secondi, così il lead creativo può confrontare le varianti side-by-side.

Osservazione diretta: i team che saltano questa fase e vanno dritti a una generazione 2.5 da 30 secondi in genere bruciano tre o quattro run a prezzo pieno per sistemare conflitti di prompt che avrebbero potuto intercettare su Fast. La fase di iterazione è la parte del pipeline con il ROI più alto in assoluto, e i team che consegnano in modo affidabile sono quelli che la trattano come obbligatoria.

Generazione finale (Seedance 2.5 a 30s / 1080p)

Quando l'iterazione su Fast conferma che il prompt funziona, il team invia la generazione reale: model: "seedance-2.5", duration: 30, resolution: "1080p", con tutti e cinque i riferimenti allegati e il prompt completo con la mappatura dei ruoli. La chiamata di creazione include una Idempotency-Key così che un retry di rete dal runner CI non avvii un secondo task a pagamento. Il lead creativo revisiona il log di invio del taskId finale prima che al dispatcher sia permesso confermarlo: è un controllo di un minuto che previene costosissimi refusi nel prompt.

Polling, errori e idempotenza

Un unico dispatcher interroga il task ogni 5 secondi con backoff fino a 30 secondi, per un massimo di 100 tentativi (circa 8 minuti). I fallimenti terminali (failed, error) innescano un singolo retry con una nuova Idempotency-Key solo se la descrizione dell'errore indica un problema transiente del backend. Gli errori di riferimenti o prompt vengono segnalati al lead creativo e corretti prima di un nuovo invio, non ritentati alla cieca. Il dispatcher scrive una riga di log strutturato per tentativo (task ID, status, progress, elapsed secondi) così che costo e latenza siano verificabili dopo il lancio.

Modifiche di regione

In revisione, il cliente chiede di sostituire il prodotto sulla mensola destra dello shot finale. Il team invia un task di modifica a livello di regione che colpisce solo quell'area, preservando il movimento e l'identità del resto della clip. Questa è la feature 2.5 più preziosa per il lavoro per clienti: un round-trip di un giorno diventa una rigenerazione di 10 minuti. La pipeline mantiene il taskId originale e il taskId della modifica collegati nel log di progetto, così la lineage di ogni fotogramma consegnato è tracciabile.

Delivery

La videoUrl ready viene scaricata, transcodificata in H.264 con fast-start per l'autoplay web, abbinata a un poster WebP estratto da coverUrl e caricata sul CDN del team. Gli asset finali vengono pubblicati sulla landing page e revisionati fotogramma per fotogramma (identità, mani, geometria del prodotto, logo, sync audio) prima della pubblicazione.

Disciplina dei costi

La pipeline tappa la spesa in tre punti. Primo, le run di iterazione avvengono su Fast invece che su 2.5. Secondo, un pre-check dei crediti prima di ogni invio 2.5 abortisce se il saldo del wallet è sotto la soglia per la durata e la risoluzione scelte. Terzo, un budget rigido di task per lancio nel dispatcher rifiuta di inviare nuovi task una volta raggiunto. I prezzi di Seedance 2.5 non sono pubblicati, quindi il team tratta ogni cifra al secondo come una stima e legge il generatore live per i crediti correnti prima di ogni campagna.

Gestire i 50 riferimenti multimodali

La feature principale, fino a 50 input multimodali, compare nel payload come array di URL pubblici:

{
  "model": "seedance-2.5",
  "prompt": "Keep the character from the first image unchanged; use the video for body motion and the audio for rhythm",
  "duration": 20,
  "resolution": "1080p",
  "aspect_ratio": "16:9",
  "reference_images": ["https://cdn.example.com/character.jpg", "https://cdn.example.com/product.jpg"],
  "reference_videos": ["https://cdn.example.com/motion.mp4"],
  "generate_audio": true
}

Tutti gli URL di riferimento devono essere raggiungibili pubblicamente. Assegna a ciascuno un solo ruolo e descrivi quel ruolo nel prompt ("usa @Video 1 solo per il movimento del corpo"), così il modello sa quale input controlla quale proprietà.

Nota per sviluppatori: pre-valida che ogni URL di riferimento restituisca HTTP 200 con il content-type atteso prima dell'invio. Un 403 su un asset protetto da CDN è la causa più comune di task failed in produzione, e spreca un intero budget di generazione. Un controllo HEAD di due righe nel tuo client prevvede un'intera classe di fallimenti. Usa anche URL stabili e content-addressed (per esempio con un hash o una versione nel percorso), così che sostituire un asset a metà campagna non cambi silenziosamente ciò che il modello riceve.

Gestione degli errori e idempotenza

• 401 "API Key 无效" (API Key non valida): chiave errata o la chiave non ha scope video. Verifica la chiave e i suoi permessi.
• 400 "模型不存在或未配置" (modello inesistente o non configurato): la rotta seedance-2.5 non è ancora abilitata su questo backend. Su PixMind è lo stato Coming-Soon.
• 4001 "余额不足" (saldo insufficiente): la richiesta è valida ma il wallet non ha crediti; il task non viene creato.
• 429 rate limit: fai backoff esponenziale e ritenta; l'endpoint di creazione applica limiti di concorrenza per chiave e tetti di request-rate. Se lo hiti regolarmente, contatta il supporto per alzarli oppure distribuire gli invii su brevi intervalli.
• 502 / 504 gateway: transiente; ritenta la chiamata di creazione con la stessa Idempotency-Key così che il backend faccia deduplication e non parta un secondo task a pagamento.
• Polling timeout: tetta i tentativi (per esempio 100 × 5s, circa 8 minuti) e tratta il timeout come un fallimento con un singolo retry.

In produzione, passa un header Idempotency-Key a ogni chiamata di creazione così che un retry del client non avvii un secondo task a pagamento. Usa un UUID per task logico (non per tentativo HTTP), generato una sola volta e conservato dalla tua parte, così che la stessa generazione logica venga deduplicata tra retry, CI rerun e replay di coda. Il pattern è: genera l'UUID quando l'utente (o il job runner) decide di creare il task, persistilo prima della prima chiamata HTTP e riutilizzalo per ogni retry dello stesso task logico.

Risorse per sviluppatori di terze parti

Il contratto qui sopra è il percorso di implementazione su PixMind. Per un contesto più approfondito sul modello sottostante di ByteDance e sulla superficie API ufficiale, queste sono le risorse a cui gli sviluppatori ricorrono più spesso, verificate al 2026-07-31:

• Pagina risorse BytePlus Seedance 2.5, ai.byteplus.com/lumina/en/resource/bytedance-seedance-2-5. L'inquadramento di 2.5 da parte di ByteDance, orientato alla generazione video pubblicitaria e ai demo di prodotto. Utile per la narrazione delle capacità e per i casi d'uso che ByteDance stessa punta. Listing verificato, 2026-07-31.
• Documentazione API BytePlus ModelArk, la superficie sviluppatore ufficiale per invocare Seedance attraverso il cloud di ByteDance. Referenzia i nomi dei campi e le modalità quando devi confermare cosa espone la rotta connessa, poi rispecchia quei nomi nel tuo client.
• Documentazione Volcengine 火山方舟 (Volcano Engine Ark), volcengine.com/docs/82379. L'endpoint domestico (Cina) per la stessa famiglia di modelli. Il pattern asincrono invia-e-fai-polling è identico alla rotta PixMind; nomi dei campi e flusso di auth differiscono leggermente. Listing verificato, 2026-07-31; conferma il percorso live prima di integrare.
• Guida alla ricreazione dei demo MakeFun AI, makefun.ai/seedance-2-5-demo-videos/. Percorre la ricreazione dei workflow demo ricchi di riferimenti di BytePlus ModelArk. Utile quando vuoi riprodurre il look ufficiale prima di disegnare il tuo prompt.
• Analisi della community: l'analisi Topview/Medium sulla 2.5, la copertura FORCE di Pixo e la guida completa di ToSea coprono tutti gli upgrade del workflow da un'angolazione editoriale. Utili per il contesto, non per i dettagli degli endpoint; conferma sempre le specifiche tecniche rispetto all'API live.

Nota per sviluppatori: le guide di terze parti invecchiano in fretta. Trattale come punto di partenza e conferma percorsi endpoint, nomi dei campi e costi in crediti rispetto alla rotta connessa il giorno in cui integri. I dettagli di endpoint e autenticazione di questa guida sono verificati al 2026-07-31, ma il modello è ancora in rollout, quindi ricontrolla prima del lancio in produzione.

FAQ sulla Seedance 2.5 API

Qual è l'endpoint della Seedance 2.5 API?

Crea un task con POST /api-platform/v1/generations, poi fai polling su GET /api-platform/v1/task/{task_id} finché status è ready. Il campo model è seedance-2.5.

Come mi autentico alla Seedance 2.5 API?

Invia la tua API Key come Authorization: Bearer <key>. È accettato anche l'header X-API-Key. Crea una chiave con permesso video nella dashboard di PixMind e caricala da una variabile d'ambiente invece di incorporarla nel codice sorgente.

La Seedance 2.5 API è disponibile su PixMind?

La rotta è documentata e pronta; l'accesso backend è in fase di finalizzazione e il modello è marcato Coming Soon. La pagina /api-platform/models/seedance-2-5 ha il riferimento di endpoint e parametri, e la pagina /ai-video/seedance-2-5 ospita il generatore web nel frattempo.

Quanti riferimenti posso inviare in una singola richiesta Seedance 2.5?

Fino a 50 input multimodali, immagini, video, testo e audio combinati, in una singola richiesta. È un aumento rispetto ai 9 di Seedance 2.0. Ogni riferimento deve essere un URL pubblicamente raggiungibile.

La Seedance 2.5 API restituisce il video in modo sincrono?

No. La generazione video è asincrona. La chiamata di creazione restituisce un taskId; fai polling sull'endpoint del task finché status è ready, poi leggi videoUrl. Una generazione tipica di 30 secondi richiede diversi minuti, quindi progetta il client per il polling, non per il bloccante.

Quali sono i rate limit e i tetti di concorrenza?

L'endpoint di creazione applica limiti di request-rate e di concorrenza per chiave. Se li superi, la risposta restituisce 429 e dovresti fare backoff esponenziale. Per workload in batch (più di un pugno di task concorrenti), distribuisci gli invii su brevi intervalli e contatta il supporto per alzare i limiti se hiti 429 regolarmente. I limiti numerici esatti sono tarati per account, quindi verificalli sulla tua chiave prima di progettare un job in batch grande.

La Seedance 2.5 API supporta webhook o callback?

La rotta PixMind verificata usa solo polling, non callback push. Se la tua architettura ha bisogno di notifiche push, lancia un singolo dispatcher che interroga l'endpoint del task ed emette un webhook verso i tuoi servizi downstream quando status raggiunge uno stato terminale. Questo mantiene l'integrazione semplice ed evita di accoppiare il pipeline a un URL di callback che può cambiare tra ambienti.

Quanti task concorrenti posso eseguire?

La concorrenza è limitata dai tetti per chiave e dal tuo saldo crediti. Per lavori a 30 secondi 1080p, aspettati di lanciare in parallelo un pugno di task, non decine. Tratta il tetto live come verificato-sul-tuo-account: invia un piccolo batch di calibrazione, misura quanti task passano da pending a processing simultaneamente e dimensiona la coda rispetto a quel numero.

Quale formato video restituisce l'API?

Il task ready restituisce una videoUrl che punta a un file MP4 standard, più una coverUrl per un fotogramma poster. Scarica e transcodifica nel formato richiesto dalla tua destinazione di delivery (H.264 con fast-start per il web, encode verticali per i social, ProRes per il mastering di montaggio). Non fare hotlink della videoUrl ospitata dall'API in produzione perché non è garantito che persista; copia il file sul tuo CDN quando è ready.

Come verifico i crediti prima di inviare?

Leggi il generatore live per il costo in crediti alla durata e risoluzione scelte, poi verifica il saldo del wallet. L'API restituisce 4001 "余额不足" (saldo insufficiente) se il saldo è troppo basso, nel qual caso il task non viene creato. Per i pipeline di produzione, aggiungi un pre-check del saldo prima dell'invio che abortisce early se il saldo è sotto la soglia per task, così non metti in coda lavoro che il wallet non può coprire.

Come risolvo l'errore "模型不存在或未配置"?

Questa risposta 400 significa che la rotta seedance-2.5 non è abilitata sull'endpoint backend che stai colpendo. Su PixMind è lo stato Coming-Soon mentre la connessione al backend viene finalizzata. Conferma di star chiamando il percorso documentato /api-platform/v1/generations con model: "seedance-2.5" (minuscolo, esatto). Se entrambi sono corretti e l'errore persiste, la rotta non è ancora aperta sul tuo account; monitora la pagina /api-platform/models/seedance-2-5 per la disponibilità.

Quali risoluzioni e durate posso richiedere?

Durate fino a 30 secondi in un singolo shot; risoluzioni di 480p, 720p, 1080p e 4K nativo. Conferma le opzioni esatte nel generatore live prima di inviare, dato che la rotta connessa può esporne un sottoinsieme.

I prezzi della Seedance 2.5 API sono pubblicati?

Non ancora. Tratta ogni cifra al secondo che vedi altrove come una stima. Leggi il generatore live per i crediti correnti alla durata e risoluzione scelte prima di inviare, e struttura il pipeline in modo che possa assorbire un aggiornamento di prezzo senza riscrivere l'integrazione.

Inizia a costruire con la Seedance 2.5 API

La Seedance 2.5 API è un contratto standard di generazione video asincrona: una chiamata di creazione, un ciclo di polling, un download. Una volta che hai una chiave con scope video, gli esempi curl e Python qui sopra sono tutto ciò che ti serve per spedire una prima integrazione. La tabella di confronto e il caso di studio sul pipeline mostrano come scalare quel contratto da una singola clip a un workflow di produzione ripetibile che sopravvive a modifiche del cliente, pressioni di budget e deadline.

→ Leggi il riferimento completo della rotta Seedance 2.5 API, oppure prova il modello nel generatore web mentre l'accesso API viene finalizzato.

Confronta tutte le rotte Seedance

I dettagli di endpoint e autenticazione verificati rispetto al backend api-platform di PixMind al 2026-07-31. Link a risorse di terze parti verificati al 2026-07-31. I campi del confronto con l'API Kling sono marcati come stima e vanno confermati rispetto ai documenti Kling live. I prezzi di Seedance 2.5 non sono pubblicati e sono marcati come solo-stima.