Seedance 2.0: lip sync, dialoghi e 4 clip reali

Seedance 2.0 muove la bocca in base al prompt. Due clip da 5 secondi in 720P, uguali tranne l'audio acceso o spento, hanno aperto e chiuso la bocca. La nostra registrazione di 1,8 secondi è passata per reference_to_video e la frase è tornata nella traccia di uscita. Il solo audio viene rifiutato. BytePlus fattura $0.15 al secondo in 720P, quindi 5 secondi costano $0.75.

Risposta breve

• La bocca viene dal prompt. Due clip da 5 secondi in 720P con lo stesso prompt, uno con audio generato e uno muto, sono passati da chiusa → socchiusa → molto aperta.
• Il solo audio non passa. La serie 2.0 richiede almeno un'immagine o un video di riferimento (API di creazione attività di BytePlus, verificata il 3 novembre 2026).
• L'audio di riferimento accetta al massimo 3 clip, da 2 a 15 secondi ciascuna, 15 secondi in totale, in wav o mp3, 15 MB per file.
• L'audio viene usato. Il nostro mp3 da 1,8 secondi è tornato nella traccia di uscita, con la frase completa.
• Con il prezzo al secondo di BytePlus, 720P costa $0.15 al secondo, quindi 5 secondi fanno $0.75.
• Quattro clip dello stesso giorno: 720P con audio, 720P muto, immagine in video 720P quadrato e 480P con audio di riferimento.

Seedance 2.0 fa lip sync?

Nella documentazione ufficiale l'espressione «lip sync» non c'è. Quello che viene descritto è la generazione congiunta di immagine e suono, più un consiglio: mettere il dialogo tra virgolette doppie.

La pagina Seed di ByteDance presenta Seedance 2.0 come «a unified multimodal audio-video joint generation architecture that supports text, image, audio, and video inputs» (verificata il 3 novembre 2026). La guida di BytePlus ModelArk ripete il concetto e mette «Generate videos with audio» tra le capacità (pagina aggiornata il 29 settembre 2026).

Cercando in quelle pagine, «lip sync» e «talking» non compaiono mai. «mouth» compare una volta, dentro un prompt di esempio, e «dialogue» due volte, sempre parlando di generazione audio. La cosa più vicina a un'istruzione è questa frase: «It is recommended to put dialogue content in double quotes to optimize the audio generation effect» (API di creazione attività, aggiornata il 28 ottobre 2026).

La funzione sta quindi nel vuoto tra le due cose: il modello produce immagine e traccia audio, ma nessuna pagina ufficiale promette che le labbra seguano ogni sillaba. Nei nostri quattro clip la bocca si è mossa con l'audio acceso e spento, il che è normale per un modello video a cui il prompt dice che qualcuno sta parlando.

C'è chi ci prova. Un commento su Hacker News del 18 febbraio 2026 ha inviato una canzone insieme al video e ha concluso che «the model did reference the singing music I provided, but it reinterpreted it on its own» (commento). Una issue su GitHub del 3 giugno 2026 mette «Mouth movements match phoneme timing» come condizione di superamento, una misura che la documentazione non riporta (issue).

Come scrivere la battuta nel prompt

Prima il personaggio, poi la battuta tra virgolette doppie, infine il movimento di bocca e viso. Il nostro prompt descriveva personaggio e bocca, ma aveva dimenticato le virgolette: la battuta l'ha scelta il modello.

La ricetta che abbiamo usato ha cinque passaggi.

1. Il personaggio in una frase: stop-motion di plastilina, occhiali tondi grandi, sciarpa di lana, seduto a un tavolo di cucina.
2. Cosa fa: dice una battuta breve guardando la camera.
3. La battuta, così com'è, tra virgolette doppie. È il consiglio di BytePlus.
4. Bocca e viso: le labbra si aprono e si chiudono con le parole, le sopracciglia seguono la frase, la testa si inclina sulla sillaba accentata.
5. Camera e luce fisse, così si muove solo la recitazione.

Questo è il prompt inviato, senza modifiche, per tutti e quattro i clip:

A stop-motion clay character with big round glasses and a knitted scarf sits at a kitchen table, looks straight into the camera, and speaks one short line to the viewer. The mouth opens and closes in time with the words, the eyebrows move with the sentence, and the head tilts slightly on the stressed word. Fixed camera, warm lamp light, a mug of tea in front of them, gentle 24 fps stop-motion feel.

Manca la battuta. Il prompt diceva solo «una battuta breve», quindi le parole le ha scelte il modello. Con l'audio acceso dice «You look like you could use a warm hug.», una frase che non stava da nessuna parte nella richiesta. Per controllare il dialogo, il passaggio 3 va aggiunto prima dell'invio.

Abbiamo guardato la bocca con un fotogramma ogni 0,5 secondi. Il clip con audio parte a bocca chiusa, resta socchiusa dal fotogramma 2 al 7, si apre del tutto all'8 e poi si richiude. Il clip muto mostra chiusa, socchiusa, molto aperta, socchiusa, molto aperta, e gli ultimi due fotogrammi socchiusa.

Lo stesso testo sceglie anche un altro personaggio: il clip muto è tornato con corpo arancione, riga castano-grigia e sciarpa verde scuro. La frase del personaggio conviene scriverla come suggerimento. In entrambi i clip la camera non si è mossa, ed è l'effetto di «Fixed camera».

Si può inviare il proprio audio?

Sì, con un'immagine o un video di riferimento nella stessa richiesta. Il nostro mp3 da 1,8 secondi è passato come audio di riferimento e le sue parole sono tornate nella traccia di uscita.

Abbiamo usato reference_to_video con tre pezzi: il fermo immagine di plastilina come immagine di riferimento, la registrazione come audio di riferimento e il prompt qui sopra. I parametri erano 480P, 5 secondi e audio attivo. OmniaKey ha risposto 202, l'attività task_3Ay0Ktf2mbYXh9GNZpZ5j9kGyOIzz8Pv è riuscita e dopo 120,2 secondi è arrivato un MP4 da 864×496 con traccia aac da 5.06 secondi.

La trascrizione di quella traccia è una frase sola: «Why tow it? I told you the keys were in the drawer.». La seconda metà è esattamente la nostra registrazione, parola per parola. Le prime tre parole non erano nel nostro file; la trascrizione non distingue il nostro respiro da qualcosa aggiunto dal modello, quindi lasciamo quello che si sente.

Dieci fotogrammi, uno ogni 0,5 secondi, mostrano solo che la bocca si muove. Per l'allineamento per fonema servono fotogrammi più fitti e una misura dedicata, e non l'abbiamo fatta: le labbra non si possono quindi dichiarare sincrone con ogni suono.

I limiti vengono dall'API di creazione attività di BytePlus (verificata il 3 novembre 2026). L'audio accetta 3 clip, da 2 a 15 secondi ciascuna, 15 secondi in totale, in wav o mp3, 15 MB per file. La clip può arrivare come URL pubblico, stringa Base64 o id di risorsa. Solo audio no: «Audio-only input is not supported; include at least one reference image or video.»

Immagine in video cambia inquadratura da solo

Il nostro clip immagine in video è passato da un piano intero in piedi a un piano medio seduto in cucina al fotogramma 4, e il prompt non chiedeva né stacco né movimento di camera.

Il primo fotogramma è un fermo immagine creato per questa prova: il personaggio in piedi davanti a una parete bianca calda, braccia lungo i fianchi, figura intera, 1254×1254 pixel. Il prompt è quello sopra, che lo mette seduto a un tavolo di cucina. I fotogrammi da 1 a 3 restano in piedi, il 4 salta al piano medio seduto e resta lì. La bocca è chiusa fino al fotogramma 7, socchiusa all'8, molto aperta al 9 e al 10. Nell'audio si sente «Well, what do you think?» e rumore di tessuto.

Qui conta la composizione, non la bocca. In questo modello il prompt decide dove sta il personaggio e come si muove la camera, e il primo fotogramma decide l'aspetto. L'inquadratura che conta va scritta nel prompt.

Il file è arrivato a 960×960, non a 1280×720. La causa: abbiamo usato un'immagine quadrata come primo fotogramma e non abbiamo inviato la proporzione, e l'API segue l'immagine. Per scegliere il formato si scrive ratio invece di dedurlo dal nome della risoluzione.

La richiesta in Python

Creare l'attività, interrogare l'id, scaricare l'MP4: tre richieste e solo la libreria standard. Lo stesso helper serve per tutti e tre i passaggi.

import base64
import json
import os
import time
import urllib.error
import urllib.request
import uuid

API = "https://api.omniakey.com/v1/media/tasks"
KEY = os.environ["OMNIAKEY_API_KEY"]
MODEL = "dreamina-seedance-2-0-260128"

PROMPT = (
    "A stop-motion clay character with big round glasses and a knitted scarf sits at a kitchen table, "
    "looks straight into the camera, and speaks one short line to the viewer. The mouth opens and closes "
    "in time with the words, the eyebrows move with the sentence, and the head tilts slightly on the "
    "stressed word. Fixed camera, warm lamp light, a mug of tea in front of them, gentle 24 fps "
    "stop-motion feel."
)

MIME = {".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg",
        ".webp": "image/webp", ".mp3": "audio/mpeg", ".wav": "audio/wav"}


def call(method, url, body=None, idempotency_key=None):
    headers = {"Authorization": f"Bearer {KEY}", "User-Agent": "omniakey-example/1"}
    data = None
    if body is not None:
        headers["Content-Type"] = "application/json"
        data = json.dumps(body).encode()
    if idempotency_key:
        headers["Idempotency-Key"] = idempotency_key
    req = urllib.request.Request(url, data=data, headers=headers, method=method)
    with urllib.request.urlopen(req, timeout=120) as resp:
        return json.load(resp)


def data_url(path, limit_mb):
    raw = open(path, "rb").read()
    if len(raw) > limit_mb * 1024 * 1024:  # 30 MB per le immagini, 15 MB per l'audio
        raise ValueError(f"{path} is over {limit_mb} MB, the limit for this input type")
    mime = MIME[os.path.splitext(path)[1].lower()]
    return f"data:{mime};base64," + base64.b64encode(raw).decode()


def wait(task_id, timeout=900, step=5):
    deadline = time.time() + timeout
    while time.time() < deadline:
        state = call("GET", f"{API}/{task_id}")
        if state["status"] not in ("queued", "processing"):
            return state
        time.sleep(step)
    raise TimeoutError(f"{task_id} is still running: poll it again, do not resubmit")


def run(body, out_path):
    task_id = call("POST", API, body, str(uuid.uuid4()))["id"]
    print("task", task_id, flush=True)
    state = wait(task_id)
    if state["status"] != "succeeded":
        raise RuntimeError(state.get("error") or state["status"])
    signed = state["assets"][0]["url"]  # scade, quindi si scarica subito
    req = urllib.request.Request(signed, headers={"User-Agent": "omniakey-example/1"})
    with urllib.request.urlopen(req, timeout=300) as resp, open(out_path, "wb") as f:
        f.write(resp.read())
    return task_id


def reference_to_video(prompt, image_path, audio_path, out_path):
    body = {
        "model": MODEL,
        "type": "video",
        "operation": "reference_to_video",
        "input": {
            "prompt": prompt,
            "media": [
                {"type": "reference_image", "url": data_url(image_path, 30)},
                {"type": "reference_audio", "url": data_url(audio_path, 15)},
            ],
        },
        "parameters": {"duration": 5, "resolution": "480P", "ratio": "16:9",
                       "generate_audio": True, "watermark": False},
    }
    return run(body, out_path)


if __name__ == "__main__":
    print("done", reference_to_video(PROMPT, "character.png", "line.mp3", "line-clip.mp4"))

Tre dettagli vale la pena tenerli. La Idempotency-Key è un UUID nuovo per ogni corpo, così un reinvio restituisce l'attività originale invece di pagare due volte. Il ciclo di attesa si ferma dopo 15 minuti con un'eccezione, perché un timeout significa che il clip sta ancora renderizzando e un nuovo invio ne compra un altro. Il download avviene al primo succeeded, perché assets[0].url è un link firmato che scade.

Le altre due operazioni cambiano solo il corpo e tengono gli helper:

def text_to_video(prompt, out_path):
    body = {
        "model": MODEL,
        "type": "video",
        "operation": "text_to_video",
        "input": {"prompt": prompt},
        "parameters": {"duration": 5, "resolution": "720P", "ratio": "16:9",
                       "generate_audio": True, "watermark": False},
    }
    return run(body, out_path)


def image_to_video(prompt, image_path, out_path):
    body = {
        "model": MODEL,
        "type": "video",
        "operation": "image_to_video",
        "input": {"prompt": prompt,
                  "media": [{"type": "first_frame", "url": data_url(image_path, 30)}]},
        "parameters": {"duration": 5, "resolution": "720P", "ratio": "adaptive",
                       "generate_audio": True, "watermark": False},
    }
    return run(body, out_path)

La lista dei campi è corta: model, type, operation, input.prompt, input.media[] con type a first_frame, reference_image, reference_video o reference_audio, e parameters.duration, resolution, ratio, generate_audio, watermark. La stessa forma è nella documentazione dell'API video di OmniaKey, e il ciclo crea, interroga, scarica è descritto nella panoramica dell'API media. Questo modello si prova dalla pagina del modello Seedance 2.0.

Quanto costa

BytePlus fattura al secondo. Il prezzo di listino per 5 secondi in 16:9 senza video in ingresso è questo (pagina prezzi ModelArk, verificata il 3 novembre 2026):

Facendo il conto con la colonna al secondo viene lo stesso, con un centesimo di arrotondamento sulla pagina: 5 secondi × $0.15 = $0.75, contro 0.76 della riga 720p. I nostri due clip testo in video erano 720P da 5 secondi, quindi ognuno sta su quei $0.75.

Una richiesta con video in ingresso viene fatturata in un altro modo, e più caro, quindi un'attività con video di riferimento non rientra in questa tabella (pagina prezzi ModelArk, verificata il 3 novembre 2026). OmniaKey fattura al secondo generato e restituisce l'addebito quando l'attività finisce in failed o canceled (panoramica dell'API media, verificata il 3 novembre 2026); il prezzo attuale è sulla pagina del modello.

Cosa va storto

• Il solo audio viene rifiutato. Aggiungete almeno un'immagine o un video di riferimento accanto alla traccia.
• I volti reali non passano. Un'immagine o un video di riferimento con una persona vera viene bloccato, quindi usate un personaggio di plastilina, disegnato o in CG.
• generate_audio è attivo per impostazione predefinita. Per un file muto va spento; per una battuta si lascia com'è e il prompt dice che qualcuno parla.
• La dimensione consegnata segue ratio. 720P ha dato 1280×720 dal testo, 960×960 da un fermo immagine quadrato senza proporzione e 864×496 in 480P con 16:9.
• La velocità varia. Quattro attività da 5 secondi hanno impiegato 259,0, 202,0, 155,3 e 120,2 secondi, quindi mettete in conto da due a cinque minuti e interrogate lo stato.
• La durata va da 4 a 15 secondi in uscita, e le clip di riferimento da 2 a 15 secondi ciascuna, 15 in totale. Tutti e quattro i file sono tornati a 24 fps.

Domande frequenti

Se carico un WAV, la bocca segue la mia registrazione?

Sì, insieme a un'immagine di riferimento, e il modello lo usa: la nostra registrazione è tornata nella traccia di uscita. Se le labbra cadano su ogni suono del file, i nostri fotogrammi non possono mostrarlo; un fotogramma ogni mezzo secondo mostra la bocca che si muove, non una corrispondenza misurata.

Perché la mia richiesta con solo audio è stata rifiutata?

La serie 2.0 non accetta l'audio come unico ingresso. Aggiungete un'immagine o un video di riferimento nella stessa richiesta e la traccia passa insieme.

Audio attivo o spento per una battuta?

Lasciatelo attivo, è il valore predefinito. Con false il file non ha traccia audio, e il personaggio apre la bocca lo stesso se il prompt dice che parla, come nel nostro clip muto.

Quanto può durare l'audio di riferimento?

Ogni clip va da 2 a 15 secondi, al massimo 3 clip, 15 secondi in totale, in wav o mp3 e 15 MB per file (API di creazione attività di BytePlus, verificata il 3 novembre 2026). Il nostro durava 1,8 secondi, meno di quel minimo, ed è passato comunque come URL di dati Base64.

Fonti verificate

• ByteDance Seed: Seedance 2.0, verificata il 3 novembre 2026
• BytePlus ModelArk: guida a Seedance 2.0, verificata il 3 novembre 2026
• BytePlus ModelArk: API di creazione attività video, verificata il 3 novembre 2026
• BytePlus ModelArk: prezzi dei modelli, verificati il 3 novembre 2026

Cronologia

• 3 novembre 2026: prima versione, con quattro clip creati lo stesso giorno.