Source: https://ailoot.ai/models/it/doubao-seedance-2-0-260128/
Canonical: https://ailoot.ai/models/it/doubao-seedance-2-0-260128/
Language: it

# ByteDance: Seedance 2.0

[Markdown](https://ailoot.ai/models/it/doubao-seedance-2-0-260128/index.md) · [JSON](https://ailoot.ai/models/it/doubao-seedance-2-0-260128/facts.json)

## [ByteDance: Seedance 2.0](https://ailoot.ai/models/it/doubao-seedance-2-0-260128/)

Seedance 2.0 genera e modifica video usando testo, immagini e riferimenti video e audio. Può continuare filmati esistenti e generare suono sincronizzato, con durata di 4–15 secondi, uscita 480p o 720p e ruoli espliciti dei riferimenti.

- [**Ailoot Ultra · Generazione video** `POST /v1/videos` `doubao-seedance-2-0-260128`](https://ailoot.ai/models/it/doubao-seedance-2-0-260128/#method-0)

Informazioni sul modello

Questa descrizione illustra le funzionalità del modello. Gli input, gli output e le opzioni disponibili in Ailoot per il metodo selezionato sono elencati di seguito.

Seedance 2.0 genera video da una scena scritta o da una combinazione di riferimenti immagine, video e audio. Il selettore esatto doubao-seedance-2-0-260128 identifica il profilo 2.0 standard. I flussi di lavoro documentati comprendono generazione di nuovi video, modifica ed estensione di filmati esistenti. Usate i riferimenti per comunicare aspetto, movimento, linguaggio della camera e suono, poi indicate quali parti della scena devono controllare.

Il testo può essere fornito da solo. Le combinazioni multimodali documentate consentono anche immagini o video con testo opzionale, immagini con audio, video con audio e immagini, video e audio insieme. In queste combinazioni elencate, l’audio accompagna quindi contenuti visivi; non è descritto come una richiesta autonoma di generazione video dal solo audio. Scrivete chiaramente il risultato desiderato anche quando il testo è opzionale, affinché il ruolo di ogni riferimento sia esplicito anziché dedotto da materiali non correlati.

L’array content distingue elementi text, image\_url, video\_url e audio\_url. I riferimenti multimodali usano ruoli come reference\_image, reference\_video e reference\_audio. Un’immagine può definire la persona, l’oggetto, il luogo o l’aspetto. Un video può mostrare un’interpretazione, un movimento o una vista della camera e l’audio può stabilire una traccia o la temporizzazione. Indicate l’assegnazione nella richiesta: mantenere il soggetto dell’immagine, seguire la vista della camera del video e usare l’audio come sottofondo. Non chiedete a ogni riferimento di definire tutte le proprietà contemporaneamente.

L’esempio pubblicitario documentato combina due immagini di prodotto con un video e un riferimento audio. Descrive una vista iniziale, una sequenza d’azione, un dettaglio ravvicinato del prodotto e una composizione finale mantenendo coerente la voce di sottofondo. La stessa struttura può organizzare una breve presentazione: introdurre l’oggetto, mostrare un’azione e terminare sulla sua caratteristica riconoscibile. Per una modifica, identificate il filmato di origine e l’elemento da cambiare; per un’estensione, spiegate l’azione che prosegue oltre la scena esistente preservando il soggetto e la direzione del movimento.

Il profilo 2.0 documenta una durata in secondi interi da quattro a quindici oppure -1 per una durata selezionata automaticamente in quell’intervallo. Il valore predefinito è cinque secondi. Le opzioni di risoluzione sono 480p e 720p, con 720p come valore predefinito; 1080p è escluso per 2.0. I rapporti d’aspetto fissi comprendono 16:9, 4:3, 1:1, 3:4, 9:16 e 21:9. Il rapporto adattivo può scegliere l’inquadratura dal prompt o dal riferimento: il lavoro sul primo fotogramma segue l’immagine iniziale e quello multimodale usa la scena desiderata o il primo contenuto multimediale pertinente, dando priorità al video rispetto alle immagini. Verificate nel risultato dell’attività il rapporto e la durata effettivi.

Il suono generato è controllato separatamente dai contenuti multimediali di riferimento. generate\_audio=true richiede voci, effetti e musica di sottofondo sincronizzati in base al testo e al contenuto visivo; false richiede un video senza audio. Il valore predefinito documentato è true e per il parlato si raccomanda il dialogo tra virgolette. Specificate chi parla e come il suono si collega all’azione visibile, poi esaminate le parole effettive, l’assegnazione delle voci e i tempi. Fornire un riferimento audio e attivare il suono generato sono scelte separate della richiesta.

La guida di 2.0 esclude i vecchi controlli frames e camera\_fixed e non supporta l’elaborazione offline flex. Usate il campo duration e descrivete il movimento della camera nella scena stessa. Seed e filigrana restano controlli documentati; la guida dice che la stessa richiesta e lo stesso seed possono produrre risultati simili senza garantire un’identità esatta. Evitate di trattare un seed come prova di riproducibilità o una richiesta ripetuta come una clip già esaminata.

L’utilizzo di token video si calcola come (durata del video in ingresso + durata del video in uscita) × larghezza dell’uscita × altezza dell’uscita × frequenza dei fotogrammi dell’uscita / 1024. Le richieste contenenti video in ingresso e quelle senza video in ingresso appartengono a categorie di fatturazione distinte. La consultazione dell’attività riporta usage.completion\_tokens e usage.total\_tokens; conservate queste quantità riportate insieme alla clip completata.

Il flusso di lavoro è asincrono: l’invio restituisce un identificatore dell’attività e l’attività completata fornisce content.video\_url insieme a durata, risoluzione, rapporto, frequenza dei fotogrammi e utilizzo di token riportati. Preservate l’identificatore e salvate il video completato con i riferimenti originali e il prompt. Il campo di scadenza ha 172 800 secondi come valore predefinito e accetta 3 600–259 200 secondi dalla creazione dell’attività; un’attività che supera l’intervallo passa allo stato expired. Verificate l’intera uscita, compreso il raccordo della modifica o della continuazione, per aspetto dei personaggi, dettagli degli oggetti, relazioni spaziali, continuità della camera e sincronizzazione tra suono e immagini.

**Ailoot Ultra · Generazione video** `POST /v1/videos` `doubao-seedance-2-0-260128`

[`doubao-seedance-2-0-260128`](https://ailoot.ai/models/it/#m=doubao-seedance-2-0-260128&route=Ultra&caller=doubao-seedance-2-0-260128&fmt=videos)

ByteDance /`doubao-seedance-2-0-260128`

### Introduzione

Seedance 2.0 genera e modifica video usando testo, immagini e riferimenti video e audio. Può continuare filmati esistenti e generare suono sincronizzato, con durata di 4–15 secondi, uscita 480p o 720p e ruoli espliciti dei riferimenti.

Input accettati

Testo · Immagini · Video · Audio

Risultati

Video

### Disponibile in Ailoot · input e metodi

**Ailoot Ultra · Generazione video** `POST /v1/videos`

Tipi di input

`text`, `image`, `video`, `audio`

Tipi di output

`video`

| Campo | Tipo | Requisito | Valori e limiti | Predefinito |
| --- | --- | --- | --- | --- |
| Campo`model` | Tipo`string` | RequisitoObbligatorio | Valori e limiti doubao-seedance-2-0-260128 | Predefinito— |
| Campo`content` | Tipo`array` | RequisitoObbligatorio | Valori e limiti Condizioni: Oggetti nativi di testo o contenuti multimediali; l'array esterno non deve essere vuoto. Questo costruttore generico Ailoot non convalida i tipi dei nodi annidati. | Predefinito— |
| Campo`generate_audio` | Tipo`boolean` | RequisitoFacoltativo | Valori e limiti Condizioni: Audio sincronizzato incorporato nel video. | Predefinitotrue |
| Campo`duration` | Tipo`integer` | RequisitoFacoltativo | Valori e limiti Condizioni: Intero 4–15 oppure -1; viene restituita la durata effettiva del risultato. | Predefinito5 |
| Campo`resolution` | Tipo`string` | RequisitoFacoltativo | Valori e limiti 480p, 720p Condizioni: 1080p è esplicitamente non supportato per 2.0/fast. | Predefinito720p |
| Campo`ratio` | Tipo`string` | RequisitoFacoltativo | Valori e limiti 16:9, 4:3, 1:1, 3:4, 9:16, 21:9, adaptive Condizioni: Adaptive è esplicitamente limitato a 2.0/fast/1.5; l'esempio per 2.5 usa solo 16:9. | Predefinitoadaptive |
| Campo`watermark` | Tipo`boolean` | RequisitoFacoltativo | Valori e limiti | Predefinitofalse |
| Campo`seed` | Tipo`integer` | RequisitoFacoltativo | Valori e limiti Minimo: -1 Massimo: 4.294.967.295 | Predefinito-1 |
| Campo`execution_expires_after` | Tipo`integer` | RequisitoFacoltativo | Valori e limiti Minimo: 3600 Massimo: 259.200 Unità: secondi | Predefinito172.800 |
| Campo`service_tier` | Tipo`string` | RequisitoFacoltativo | Valori e limiti default Condizioni: 2.0/fast escludono flex offline; l'ambito per 2.5 non è stabilito. | Predefinitodefault |
| Campo`safety_identifier` | Tipo`string` | RequisitoFacoltativo | Valori e limiti | Predefinito— |
| Campo`tools` | Tipo`object` | RequisitoFacoltativo | Valori e limiti Condizioni: Solo 2.0/fast; type=web\_search documentato. | Predefinito— |

Combinazioni di materiali in input

Parametri e ciclo di vita del metodo

| Parametro | Contratto |
| --- | --- |
| Parametro`content_type` | Contrattoapplication/json |
| Parametro`required` | Contrattocontent, model |
| Parametro`optional` | Contrattogenerate\_audio, duration, resolution, ratio, watermark, seed, execution\_expires\_after, service\_tier, safety\_identifier, tools |
| Parametro`material_types` | Contrattotext, image, video, audio |
| Parametro`additional_properties` | Contrattotrue |
| Parametro`validation_scope` | ContrattoAiloot verifica i tipi dei campi obbligatori e che model/content sia un array non vuoto. Gli altri campi della richiesta vengono conservati per il modello selezionato. |
| Parametro`material_combinations` | Contrattotext, image, video, image, audio, image, video, video, audio, image, video, audio |
| Parametro`optional_text_with_media` | Contrattotrue |
| Parametro`reference_media_count_and_size_limits` | Contrattonull |

Alias del metodo: `/v1/videos/generations`

Ciclo di vita: `submit_once_poll_original`

`GET /v1/videos/{request_id}`

`GET /v1/videos/generations/{request_id}`

`GET /v1/videos/{request_id}/content`

`GET /v1/videos/generations/{request_id}/content`

Crea una sola volta e conserva id/polling\_url pubblici restituiti.

Interroga periodicamente l'attività originale; scarica content.video\_url effettivo di tua proprietà dopo succeeded.

### Tariffe

##### Calcolo del costo finale

Le tariffe visualizzate stimano il costo prima della generazione. L'addebito finale viene calcolato in base al costo registrato per la generazione originale. La durata misurata dell'output e le quantità previste non costituiscono la quantità finale fatturabile.

Le tariffe non aggiungono opzioni alla richiesta. I parametri supportati sono elencati nel metodo selezionato.

Modalità rapida

Non specificato Quando è selezionata la modalità rapida

Modalità flex

Non specificato Quando è selezionata la modalità flex

Sforzo massimo di ragionamento

Non specificato Quando lo sforzo massimo di ragionamento usa l'adeguamento predefinito (default)

#### Tariffe stimate per il confronto

#### Prezzi per configurazione

Associa ogni costo alle condizioni indicate. Usa una sola tariffa per ogni insieme di configurazioni alternative.

| Configurazione | Listino delle tariffe | Quantità prevista | Unità di fatturazione | Costo |
| --- | --- | --- | --- | --- |
| ConfigurazioneTariffe base dei token | Listino delle tariffeTariffa base | Quantità prevista— | Unità di fatturazione— | Costo Input · Token in input · Stima solo a fini di confronto **—** / 1K token Output · Token in output · Stima solo a fini di confronto **—** / 1K token Input · Lettura dalla cache · Stima solo a fini di confronto **—** / 1K token Input · Scrittura nella cache · Stima solo a fini di confronto **—** / 1K token Input · Scrittura nella cache, 1 ora · Stima solo a fini di confronto **—** / 1K token |
| ConfigurazioneL’ingresso contiene video. | Listino delle tariffe— | Quantità prevista— | Unità di fatturazioneper 1K token video | Costo Output · Stima solo a fini di confronto **$0.0096** per 1K token video |
| ConfigurazioneL’ingresso non contiene video. | Listino delle tariffe— | Quantità prevista— | Unità di fatturazioneper 1K token video | Costo Output · Stima solo a fini di confronto **$0.015768** per 1K token video |
| ConfigurazioneCosto stimato della generazione | Listino delle tariffe— | Quantità previstastima per una generazione | Unità di fatturazione— | Costo Output · Costo di generazione stimato · Stima solo a fini di confronto **$0.822402** stima prima della generazione Questa stima non è un addebito aggiuntivo né una tariffa fissa per la generazione completata. |

Ailoot prenota un importo stimato prima di una richiesta. Dopo il risultato, addebita il costo finale in base all’utilizzo misurato. Per lo streaming, l’addebito usa il record finale di utilizzo. [Come funzionano la prenotazione e l’addebito finale →](https://ailoot.ai/docs/it/billing/reserve/)

### Esempi di richieste

#### Ailoot Ultra · Generazione video

curl · crea un videocurl · leggi il task originalecurl · scarica il video di tua proprietà

```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
cat > request.json <<'JSON_REQUEST'
{"model":"doubao-seedance-2-0-260128","content":[{"type":"text","text":"女孩抱着狐狸，女孩睁开眼，温柔地看向镜头，狐狸友善地抱着，镜头缓缓拉出，女孩的头发被风吹动"}]}
JSON_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/videos \
  -H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
  --data-binary @request.json -D response-headers.txt -o result.json
```

```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
python3 - <<'PY_POLL'
import json
from pathlib import Path
from urllib.parse import quote,urljoin,urlsplit
r=json.loads(Path("result.json").read_text())
i=r.get("id")
if not isinstance(i,str) or not i.startswith("native302_"):raise SystemExit("Keep original response/headers/id; do not resubmit creation.")
u=urljoin("https://api.ailoot.ai",r.get("polling_url") or "/v1/videos/"+quote(i,safe=""))
p=urlsplit(u)
if p.scheme!="https" or p.netloc!="api.ailoot.ai" or not p.path.startswith("/v1/videos/"):raise SystemExit("Use actual Ailoot lookup path.")
Path("poll-url.txt").write_text(u)
PY_POLL
curl --fail-with-body --silent --show-error "$(cat poll-url.txt)" -H "Authorization: Bearer $AILOOT_API_KEY" -D status-headers.txt -o status.json
```

```bash
set -eu
python3 - <<'PY_ASSETS'
import json
from pathlib import Path
from urllib.parse import urlsplit
r=json.loads(Path("status.json").read_text())
if r.get("status")!="succeeded":raise SystemExit("Poll same original job until an owned result is returned.")
u=r.get("content",{}).get("video_url")
urls=[u] if isinstance(u,str) else u
if not isinstance(urls,list) or not urls:raise SystemExit("No completed video URL.")
for u in urls:
    if not isinstance(u,str):raise SystemExit("Invalid returned URL.")
    p=urlsplit(u)
    if p.scheme!="https" or p.netloc!="api.ailoot.ai" or not p.path.startswith("/v1/media/assets/") or not p.path.endswith("/content") or not p.query:raise SystemExit("Wait for actual Ailoot-owned signed result.")
Path("asset-urls.txt").write_text("\n".join(urls)+"\n")
PY_ASSETS
index=0
while IFS= read -r asset_url; do
  curl --fail-with-body --silent --show-error "$asset_url" -o "video-${index}.bin"
  index=$((index + 1))
done < asset-urls.txt
```

### Ricevi e salva i risultati

#### Ailoot Ultra · Generazione video

JSON nativo con id/polling\_url pubblici. Dopo la pubblicazione content.video\_url contiene uno o più URL firmati di proprietà di Ailoot; prima della pubblicazione gli URL dei risultati selezionati sono vuoti.

- `GET /v1/videos/{request_id}`
- `GET /v1/videos/generations/{request_id}`
- `GET /v1/videos/{request_id}/content`
- `GET /v1/videos/generations/{request_id}/content`

##### Conserva tutti i risultati completati

Salva ogni video completato o file restituito; recupera ogni URL di risorsa effettivamente restituito.

Conserva ogni URL effettivo in content.video\_url; index deve identificare un risultato reale restituito.

##### Se occorre verificare la risposta originale

Conserva risposta, intestazioni e id originali e interroga periodicamente quell'operazione; non inviare mai nuovamente una creazione dall'esito sconosciuto.

Campi della risposta

| Campo | Tipo |
| --- | --- |
| Campo`id` | Tipostring |
| Campo`provider_task_id` | Tipostring |
| Campo`polling_url` | Tipostring |
| Campo`status` | Tipostring when supplied |
| Campo`content.video_url` | Tipostring\|string\[\] |
| Campo`usage` | Tipoobject when supplied |

Errori e passaggi successivi

| Risposta | Condizione | Passaggio successivo |
| --- | --- | --- |
| Risposta400 · `invalid_request_error` | CondizioneJSON, modello, tipi dei campi obbligatori o indice del contenuto non validi. | Passaggio successivo |
| Risposta401 · `authentication_error` | CondizioneChiave API Ailoot non valida. | Passaggio successivo |
| Risposta404 · `not_found_error` | CondizioneAttività o risultato assente oppure non appartenente allo stesso utente, alla stessa chiave API o allo stesso gruppo. | Passaggio successivo |
| Risposta502 · `result_pending_check` | CondizioneInvio o stato originale incompleto; conserva l'ID originale e non inviare nuovamente la richiesta. | Passaggio successivo |
| Risposta503 · `result_pending_check` | CondizioneIl contenuto multimediale, la rotta o il conguaglio dell'addebito originale è in verifica; prosegui con l'operazione originale. | Passaggio successivo |

### Alias

#### Alias del modello

**Ailoot Ultra** [`doubao-seedance-2-0-260128`](https://ailoot.ai/models/it/#m=doubao-seedance-2-0-260128&route=Ultra&caller=doubao-seedance-2-0-260128&fmt=videos)

#### Alias dei percorsi dei metodi

`/v1/videos/generations`

#### ID di chiamata correlati

[`doubao-seedance-2-0-260128`](https://ailoot.ai/models/it/#m=doubao-seedance-2-0-260128&route=Ultra&caller=doubao-seedance-2-0-260128&fmt=videos)

FAQ · ByteDance: Seedance 2.0

Quali input e risultati sono disponibili?

`POST /v1/videos` · `doubao-seedance-2-0-260128`: `text`, `image`, `video`, `audio` → `video`

Quali campi usa la richiesta?

`POST /v1/videos` · `doubao-seedance-2-0-260128`: `model`, `content`, `generate_audio`, `duration`, `resolution`, `ratio`, `watermark`, `seed`, `execution_expires_after`, `service_tier`, `safety_identifier`, `tools`

Quali limiti si applicano?

`POST /v1/videos` · `doubao-seedance-2-0-260128`: `seed.minimum`: `-1`; `seed.maximum`: `4294967295`; `execution_expires_after.minimum`: `3600`; `execution_expires_after.maximum`: `259200`

Collega Ailoot a Claude Code, OpenCode, Hermes o alla tua applicazione.

## L’azienda e il suo portafoglio di progetti

L’azienda e il suo portafoglio di progetti: milioni di clienti; vendite nell’ordine dei miliardi ogni mese.

## Acquista token con uno sconto.

Sconto con abbonamento per lavoro regolare. Codici fino al 50% sull’acquisto di token.

Abbonamento

Scegli un piano scontato per richieste regolari.

Codice fino al 50%

Inserisci il codice all’acquisto. Il prezzo si aggiorna secondo la promozione.

Spese nella cronologia

Modello, token e importo sono salvati per ogni richiesta.

[Scegli abbonamento](https://ailoot.ai/docs/it/billing/subscriptions/) · [Consulta prezzi dei modelli](https://ailoot.ai/models/it/)

## Collega l’API al prodotto che vendi.

SaaS, app e bot secondo offerta e accordo di licenza Ailoot. Per rivendere, richiedi una licenza reseller.

Applicazione commerciale

Integra generazione di testo, immagini, video e suono nelle funzioni a pagamento.

Licenza reseller

Invia descrizione del progetto e schema di accesso. Richiedi condizioni scritte per uso e rivendita.

Documenti sul sito

Offerta, accordo di licenza e politica sui dati sono disponibili prima della connessione.

[Richiedi licenza reseller](mailto:support@ailoot.ai) · [Offerta e accordo di licenza](https://ailoot.ai/legal/offer?lang=it)

## Ailoot · L’azienda e il suo portafoglio di progetti





Ailoot si basa su un’esperienza operativa consolidata, un’ampia base di clienti, un servizio stabile e un controllo costante dei KPI.





L’azienda e il suo portafoglio di progetti: milioni di clienti; vendite nell’ordine dei miliardi ogni mese.





Ailoot mette questa esperienza operativa al servizio dell’accesso API alle funzioni AI nei prodotti dei clienti, negli agenti, nelle applicazioni e nelle automazioni.
