FLUX.3 Video short-form: bozze, rendering e continuazione via API

FLUX.3 Video (su hiapi è flux-3-video) copre con lo stesso model id le tre cose necessarie al flusso di lavoro per i video brevi: output verticale 9:16, una traccia audio generata in sincrono con le immagini e la continuazione di un video a partire dall'ultimo fotogramma di un clip esistente. Questa guida usa queste tre funzionalità su un piccolo incarico: un breve video verticale da 10 secondi per un negozio di ramen aperto a tarda notte. Prima si verifica il concetto con una bozza economica, poi si esegue il render finale a 720p e infine si estende l'inquadratura oltre i 5 secondi tramite la continuazione. Ogni clip qui sotto è un output API reale e non modificato, e ogni prezzo proviene dal listino in tempo reale di hiapi.

Per il riferimento completo dei parametri e una prova della prima richiesta, consulta la guida all'API di FLUX.3 Video. Se desideri endpoint separati per image-to-video e keyframe, con un prezzo al secondo più basso, il flusso di lavoro per video brevi con FLUX 3 Max tratta quel modello. Questo articolo riguarda ciò che flux-3-video offre in più: audio, anteprima in bozza e continuazione.

Il flusso di lavoro in tre chiamate

Passo	Funzione	Campi chiave	Prezzo (al secondo)	Costo per 5 secondi
1. Bozza	Verifica se il prompt si presenta come previsto	draft: true	$0,09	$0,45
2. Render finale	Esegue il render del clip che pubblicherai	resolution: "720p"	$0,25	$1,25
3. Continuazione	Estende il clip finale di altri 5 secondi	start_video + draft: true	$0,18	$0,90

Tutti e tre usano lo stesso model id, con la stessa struttura di richiesta sull'endpoint dei task asincroni. Questa esecuzione è costata in totale $2,60, producendo un breve video verticale da 10 secondi con audio. A 1080p, la tariffa del render normale sale a $0,42/secondo, la continuazione a $0,76/secondo e la continuazione 720p non in bozza a $0,59/secondo. Le tariffe attuali sono sulla pagina del modello flux-3-video e sulla pagina dei prezzi.

Passi 1 e 2: bozza e render finale, inviati come batch

Il prompt descrive l'inquadratura in un blocco di frasi e il suono su una riga Audio: separata. Con generate_audio: true, il modello restituisce un .mp4 con una traccia audio AAC integrata, non un file audio separato.

{
  "model": "flux-3-video",
  "input": {
    "prompt": "Inquadratura verticale a mano, di notte: il vapore sale da una ciotola di ramen tonkotsu, le bacchette sollevano noodles lucidi verso l'obiettivo, dietro c'è un bancone da ramen con solo sei posti, lanterne di carta calde, la pioggia lascia strisce sul vetro, profondità di campo ridotta. Audio: brodo che sobbolle, leggeri slurp di noodles, pioggia sul vetro, conversazioni a bassa voce.",
    "duration": 5,
    "resolution": "720p",
    "aspect_ratio": "9:16",
    "draft": true,
    "generate_audio": true
  }
}

La richiesta del render finale è lo stesso corpo, senza "draft": true. Le due richieste vengono inviate una dopo l'altra. Non si attendono a vicenda, perché ogni chiamata restituisce immediatamente un taskId:

	Bozza	Finale 720p
Creazione → completamento (timestamp del server)	29 secondi	64 secondi
Dimensioni output	704×1280	704×1280
Durata	5,04 secondi	5,04 secondi
Picco audio	−23 dB	−5 dB
Costo	$0,45	$1,25

Ecco la bozza:

E il render finale 720p dello stesso prompt:

Questi due clip mostrano cosa la bozza può dirti e cosa non può:

• La bozza è un'altra versione, non un'anteprima a bassa risoluzione del render finale. La bozza inquadra una ciotola bianca semplice, con i noodles già sollevati. Il render finale sceglie una ciotola decorata, con uovo marinato, cipollotti, clienti al bancone e vapore. Lo schema della richiesta non ha un campo seed, quindi non puoi bloccare la composizione della bozza e rieseguire il render a piena qualità.
• Le dimensioni in pixel sono identiche. Entrambi gli output sono 704×1280. La differenza sta nei dettagli: la bozza è chiaramente più morbida, lo sfondo è sfocato, mentre il render finale conserva la texture dei noodles e delle scritte sulle lanterne.
• La traccia audio della bozza ha un volume molto più basso. Il suo picco è intorno a −23 dB, contro −5 dB del render finale. Non usare la bozza per giudicare il mix audio.

Quindi usa la bozza a $0,45 per ciascuna variante di prompt per verificare il concetto (il prompt riesce a produrre un primo piano di ramen notturno in verticale con il gesto delle bacchette?). Poi esegui il render finale solo per i prompt che superano la verifica, e scegli dal render finale.

Passo 3: estendere l'inquadratura con la continuazione

Un hook da 5 secondi è spesso troppo breve per un post. Anziché generare un altro clip sconnesso, passa l'URL pubblico del render finale come start_video e descrivi cosa accade dopo:

{
  "model": "flux-3-video",
  "input": {
    "prompt": "Continua la stessa inquadratura: i noodles vengono aspirati fuori dall'inquadratura, la camera a mano si sposta verso destra e verso l'alto, oltre la ciotola fumante, in direzione della finestra rigata dalla pioggia, la lanterna di carta luminosa si riflette sul vetro, fuori c'è un'insegna al neon sfocata. Audio: slurp di noodles, poi pioggia sul vetro e conversazioni al bancone che crescono dolcemente.",
    "start_video": "https://static.hiapi.ai/blog/flux-3-video-short-form-video/hook-final.mp4",
    "duration": 5,
    "resolution": "720p",
    "aspect_ratio": "9:16",
    "draft": true,
    "generate_audio": true
  }
}

Il task è passato dalla creazione al completamento in 119 secondi, al costo di $0,90 (5 secondi × $0,18 per la continuazione in bozza). Il risultato restituito è questo:

Due comportamenti da pianificare in anticipo:

1. L'output contiene solo i secondi aggiunti. Il file restituito dura 5,0 secondi. Parte dall'ultimo fotogramma del clip sorgente (i noodles sollevati davanti alla lanterna), poi si sposta verso la finestra come richiesto. Non include i 5 secondi originali, quindi devi unire tu i due file.
2. Poiché il primo fotogramma coincide, l'unione è senza cuciture. Un semplice concat produce un'unica inquadratura continua da 10 secondi:

ffmpeg -i hook-final.mp4 -i extend-draft.mp4 \
  -filter_complex "[0:v][0:a][1:v][1:a]concat=n=2:v=1:a=1[v][a]" \
  -map "[v]" -map "[a]" -c:v libx264 -crf 20 -c:a aac -movflags +faststart cut-10s.mp4

Qui la continuazione è stata renderizzata in modalità bozza per risparmiare, e la seconda metà è più morbida della prima, come accade per una bozza autonoma. Per un clip da pubblicare, la continuazione 720p non in bozza costa $0,59/secondo ($2,95 per 5 secondi). Estendere a passi di 5 secondi ti permette di approvare segmento per segmento prima di pagare il passo successivo; un render unico di 20 secondi a 720p richiede invece $5,00 in anticipo.

Script di elaborazione batch asincrona

Lo script seguente invia in parallelo un numero qualsiasi di task, esegue il polling di ogni taskId fino al completamento e scarica subito gli output. Gli URL dei risultati su temp.hiapi.ai hanno un timestamp expireAt, quindi copia i file nel tuo storage invece di collegarli direttamente. La documentazione degli endpoint è in Create Task e Get Task Detail.

import os, time, requests

API = "https://api.hiapi.ai/v1/tasks"
HEADERS = {"Authorization": f"Bearer {os.environ['HIAPI_API_KEY']}"}

BASE = {"duration": 5, "resolution": "720p", "aspect_ratio": "9:16",
        "generate_audio": True}

jobs = {
    "ramen_draft":  {**BASE, "draft": True,  "prompt": "Inquadratura verticale a mano, di notte: …"},
    "coffee_draft": {**BASE, "draft": True,  "prompt": "Primo piano verticale: gocce di espresso …"},
    "ramen_final":  {**BASE,                 "prompt": "Inquadratura verticale a mano, di notte: …"},
}

# 1. Invia tutto; ogni chiamata restituisce subito un taskId
task_ids = {}
for name, inp in jobs.items():
    r = requests.post(API, headers=HEADERS,
                      json={"model": "flux-3-video", "input": inp}, timeout=60)
    r.raise_for_status()
    task_ids[name] = r.json()["data"]["taskId"]

# 2. Esegui il polling finché ogni task non raggiunge lo stato finale
pending = dict(task_ids)
while pending:
    time.sleep(10)
    for name, tid in list(pending.items()):
        data = requests.get(f"{API}/{tid}", headers=HEADERS, timeout=30).json()["data"]
        if data["status"] == "success":
            url = data["output"][0]["url"]
            with open(f"{name}.mp4", "wb") as f:
                f.write(requests.get(url, timeout=120).content)
            print(name, "salvato")
            pending.pop(name)
        elif data["status"] in ("fail", "failed"):
            print(name, "fallito:", data.get("error"))
            pending.pop(name)

Per il passo di continuazione, aggiungi "start_video": "<URL pubblico del render finale approvato>" nell'input. L'URL deve essere accessibile pubblicamente, quindi carica prima il render finale approvato sul tuo storage.

Regole della richiesta da conoscere prima di inviare in batch

Queste risposte sono state restituite dall'API durante questa esecuzione. Le richieste non valide vengono rifiutate al momento dell'invio con 400 INVALID_REQUEST e non creano alcun task:

• aspect_ratio accetta auto, 21:9, 2:1, 16:9, 4:3, 1:1, 3:4, 9:16. Qualsiasi altro valore viene rifiutato.
• duration ha un massimo di 20 (maximum: got 99, want 20).
• start_video deve essere una stringa URL.
• I campi sconosciuti vengono rifiutati (additional properties ... not allowed), quindi un errore di battitura genera un errore esplicito invece di essere ignorato.

Al contrario: una richiesta che supera la validazione è un task reale e addebitato. Non inviare prompt di "test" senza draft: true. Un semplice {"prompt": "test"} è valido e renderizza un clip a prezzo pieno.

Domande frequenti

Qual è il modo più economico per provare i prompt di flux-3-video? La modalità bozza a 720p: $0,09/secondo, quindi un clip da 5 secondi costa $0,45. Mostra se il concetto è praticabile, ma il render finale sarà un'altra versione.

flux-3-video genera audio? Sì. Con generate_audio: true, la traccia audio è integrata nel .mp4 restituito. In questo test, descrivere il suono su una riga Audio: separata nel prompt ha prodotto un ambiente sonoro coerente (sobbollio, slurp, pioggia, conversazioni).

Quanto può essere lungo un clip di flux-3-video? Fino a 20 secondi per richiesta. Con la continuazione tramite start_video, puoi estendere a passi e approvare ogni passo prima di pagare il successivo.

La continuazione restituisce il video completo già unito? No. In questo test restituisce solo i 5 secondi aggiuntivi, partendo dall'ultimo fotogramma del clip sorgente. Unisci tu i file.

Inizia a costruire

Apri la pagina del modello flux-3-video per vedere i prezzi attuali e usare il playground. Poi usa lo script batch qui sopra per abbozzare alcuni hook verticali, esegui il render finale di quelli che funzionano ed estendi il migliore.