Il tuo ciclo di polling MiniMax H3 non esce mai. Ecco il tutorial che effettivamente termina.

Il tuo primo POST è tornato in dieci secondi con un task_id. Sembrava una vittoria.

Poi per sei minuti non è successo niente. Avevi copiato while status != "Success" da un tutorial, e il loop girava all'infinito, perché questo endpoint non restituisce più la parola Success. Quindi sei passato a un webhook. Non è arrivato nessun push, e niente ti diceva perché. La mattina dopo sei tornato per il render del giorno prima e il link dava 404.

Queste quattro cose sembrano non correlate. Nessuna è colpa del modello. Tutte e quattro riguardano il contratto asincrono, che quasi nessuno scrive. Ecco l'intero contratto, più un vero cortometraggio in due scene uscito dall'altra parte.

Punti chiave

• Tre endpoint, un loop: create restituisce un task_id e si disconnette, tu polli, scarichi. Tutto ciò che è difficile arriva dopo la chiamata create.
• I cinque stati reali sono queued, running, succeeded, failed, cancelled. Non esiste uno stato expired, qualunque cosa ti abbia detto un post.
• Due cose scadono, e nessuna è uno stato: l'URL di download ha un limite di tempo, e il record del task stesso è interrogabile solo per 7 giorni.
• Se usi un callback, MiniMax invia prima una richiesta di verifica con un campo challenge e tu devi restituirlo identico entro 3 secondi. Se fallisci, non ricevi alcun errore, solo silenzio per sempre.
• Per la generazione solo testo, ratio è obbligatorio e non può essere adaptive. Per image-to-video, il primo frame decide il formato, e qualsiasi ratio tu passi viene ignorato.

Prima la cosa finita

Il risultato finale di questo tutorial: due clip MiniMax H3 a 2K concatenate, 14.6 secondi. La clip A è image-to-video da un primo frame generato, la clip B è text-to-video. Attiva l'audio. L'audio non è una colonna sonora sovrapposta, H3 ha reso gli ingranaggi, la pioggia e la frase sussurrata come parte della stessa generazione.

Tre chiamate API hanno fatto questo. Un modello di immagine per il primo frame, due endpoint H3 per le clip, una riga di ffmpeg per unirle. Il codice qui sotto è il codice che l'ha creato.

Perché la maggior parte dei tutorial su MiniMax H3 si rompe alla seconda richiesta

Quasi tutte le guide per questo modello si fermano alla chiamata create. Questa è la metà facile. La chiamata create convalida il tuo payload, ti consegna un task_id e si disconnette, e poi sei solo con un lavoro che richiede minuti e un insieme di regole che nessuno ha stampato.

I fallimenti sono noiosamente ripetibili. Ne ho colpiti cinque su sei in un pomeriggio.

La prima riga è quella che divora intere serate, e vale la pena essere precisi. La vecchia API video di MiniMax riportava lo stato con parole in maiuscolo come Preparing / Queueing / Processing / Success / Fail. L'endpoint di query v2 usato da H3 restituisce queued, running, succeeded, failed, cancelled (Riferimento API MiniMax, agosto 2026). Molti documenti di rivenditori terzi stampano ancora il vecchio set, o mescolano entrambi in una pagina. Se hai ereditato un loop da uno di quelli, non può terminare, perché la stringa che attende non viene mai inviata.

Flusso di lavoro del tutorial MiniMax H3: tre endpoint, cinque stati, un loop

H3 è stato rilasciato il 31-07-2026 come modello video omni-modale: testo, immagine, video e audio vivono tutti nella stessa finestra di contesto, output fino a 15 secondi a 2K con audio stereo nativo (MarkTechPost, agosto 2026). Per l'API questo significa un endpoint create con un array content, e ciò che metti nell'array decide in quale modalità ti trovi.

E la parte che il tuo codice deve effettivamente gestire. Cinque stati, cinque rami diversi.

Non esiste uno stato expired. Questa parola viene spesso associata a questa API ma appartiene ad altre due cose: l'URL di download, che è limitato nel tempo e aggiornabile, e il record del task, che è interrogabile solo per gli ultimi 7 giorni. Entrambi sono coperti nel Passo 4.

Un altro numero prima del codice. La concorrenza per la generazione video su H3 è limitata dal numero di connessioni, non dalle richieste al minuto: 2 task concorrenti sul piano gratuito, 15 una volta pagato (Limiti di velocità MiniMax, agosto 2026). Oltre il limite ottieni un 429 immediato. Niente viene messo in coda per tuo conto. Ho anche inviato 20 lavori H3 concorrenti attraverso un gateway di routing e tutti e 20 sono stati accettati, e ho avuto un 429 sulla stessa configurazione un altro giorno, quindi considera qualsiasi numero sopra il limite documentato come tempo atmosferico, non una costante.

Diretto o tramite gateway

I tre passaggi sono gli stessi in entrambi i casi, ma le stringhe differiscono, e questo conta quando stai eseguendo il debug all'1 di notte.

Il motivo per cui ho eseguito la catena di questo tutorial su un gateway è puramente la penultima riga: il primo frame proviene da un modello di immagine OpenAI e le due clip da MiniMax, e non volevo due fornitori, due chiavi e due pagine di fatturazione per un film di 14 secondi. Se sei già all'interno della piattaforma MiniMax, rimani lì, il loop qui sotto funziona invariato a parte i percorsi e le parole di stato.

Hailuo AI Video Generator: come usarlo prima di scrivere codice

Se sei arrivato qui cercando come usare Hailuo AI video generator, sei nel posto giusto e non hai ancora bisogno di alcun codice. Hailuo è l'app consumer di MiniMax e H3 è il nome del modello usato dall'API. Stesso motore, porta diversa.

Tre minuti, nessun terminale:

1. Apri una pagina di modello, ad esempio MiniMax H3 image-to-video. Il playground è il pannello di destra della pagina.
2. Carica un'immagine come primo frame, oppure passa alla pagina text-to-video e scrivi un prompt. Imposta risoluzione e durata. Di' ad alta voce cosa vuoi sentire, non solo cosa vuoi vedere: H3 genera l'audio nello stesso passaggio, quindi "pioggia che ticchetta sul vetro, piccoli scatti di servo" è un'istruzione reale, non un abbellimento.
3. Premi Esegui. Il pulsante mostra l'importo esatto per le impostazioni scelte prima di impegnarti. Aspetta, scarica.

Questo è l'intero percorso senza codice, e per clip singole è davvero l'opzione più veloce. Nel momento in cui vuoi dieci varianti, o un primo frame generato da un altro modello e inserito direttamente, torna al codice. Questo è ciò di cui tratta il resto dell'articolo.

Il tutorial MiniMax H3: Crea, Polla, Scarica, Ripeti

Un esempio percorre tutti e sette i passaggi: un orologiaio ripara un piccolo uccello meccanico di ottone, gli sussurra una frase, e l'uccello vola fuori dall'officina. Due scene. La scena A è image-to-video, quindi l'interno è diretto artisticamente. La scena B è text-to-video perché non c'è un frame sorgente per il cielo.

Passo 1: Genera il primo frame con GPT Image 2

Image-to-video ignora ratio, quindi il primo frame è dove decidi il formato della scena A. Generalo a 16:9 e al massimo livello di qualità, perché H3 erediterà ogni difetto e poi ci aggiungerà motion blur.

Modello: openai/gpt-image-2/text-to-image. Impostazioni: qualità high, 2048x1152, 16:9, PNG.

textCopy
1A cluttered clockmaker's workshop at dusk, warm tungsten lamp over a scarred oak
2bench. An old repairman in a leather apron leans close to a small brass mechanical
3bird resting in his cupped hands, its wing plates half-open, tiny gears visible.
4Rain streaks the mullioned window behind him; a coal stove glows amber at frame
5left. Shallow depth of field, 35mm, volumetric dust in the lamp beam, deep amber
6and teal palette, photoreal, no text.
7

Playground di GPT Image 2 su Atlas Cloud con il prompt del primo frame di questo tutorial e l'officina dell'orologiaio renderizzata nel pannello di output

GPT Image 2 su Atlas Cloud, qualità alta a 2048x1152. Il pulsante Esegui mostra l'importo esatto per le impostazioni scelte, $0.1745 per questa, prima di impegnarti.

Conserva l'URL restituito. Il Passo 2 lo invia direttamente a H3, senza bisogno di un download di andata e ritorno.

Passo 2: Crea il task MiniMax H3 e conserva il task_id

La chiamata create fa due cose e poi smette di interessarsi a te: convalida il payload e restituisce un task_id. Un 400 qui è il tuo payload, non un fallimento transitorio, quindi non metterlo dietro un loop di ripetizione. Ogni altro tipo di problema si presenta dopo, durante il polling.

L'unica abitudine che fa risparmiare soldi veri: persisti il task_id prima di fare qualsiasi altra cosa. I task sono interrogabili solo per 7 giorni, e se il tuo processo muore con l'id in memoria, hai pagato per un render che non puoi più raggiungere.

pythonCopy
1import os, json, time, requests
2
3BASE = "https://api.minimax.io"
4HEADERS = {
5    "Authorization": f"Bearer {os.environ['MINIMAX_API_KEY']}",
6    "Content-Type": "application/json",
7}
8
9def create_task(payload: dict) -> str:
10    r = requests.post(f"{BASE}/v2/video_generation",
11                      headers=HEADERS, json=payload, timeout=60)
12    if r.status_code == 400:
13        # il tuo payload è sbagliato. riprovarlo sarà solo di nuovo sbagliato.
14        raise ValueError(f"rifiutato: {r.text}")
15    r.raise_for_status()
16    task_id = r.json()["task_id"]
17    with open("tasks.jsonl", "a") as f:                 # persisti PRIMA di qualsiasi altra cosa
18        f.write(json.dumps({"task_id": task_id, "at": int(time.time()),
19                            "payload": payload}) + "\n")
20    return task_id
21
22SHOT_A_PROMPT = (
23    "The old repairman's hands steady the brass bird. Its glass eyes flicker alight, "
24    "wing plates click open one by one. He leans in and whispers, close to the mic, "
25    ""Let's see if you still remember the sky." Slow 50mm push-in, lamp light raking "
26    "across the brass, rain ticking on the window, coal stove crackling, tiny servo "
27    "clicks under his voice. Warm amber key, teal window fill. No on-screen text."
28)
29
30shot_a = create_task({
31    "model": "MiniMax-H3",
32    "resolution": "2K",
33    "duration": 8,
34    # nessun "ratio" qui di proposito: image-to-video prende il formato dal primo frame
35    "content": [
36        {"type": "text", "text": SHOT_A_PROMPT},
37        {"type": "image_url", "role": "first_frame",
38         "image_url": {"url": FIRST_FRAME_URL}},
39    ],
40})
41print("shot A task:", shot_a)
42

Ecco lo stesso prompt e primo frame in esecuzione come lavoro, così puoi vedere come appare un invio corretto dall'altra parte:

Playground MiniMax H3 image-to-video su Atlas Cloud con il primo frame dell'officina caricato e la clip renderizzata nel pannello di output

MiniMax H3 image-to-video: primo frame caricato a sinistra, clip 2K finita in OUTPUT a destra. Nota il campo Aspect Ratio bloccato su adaptive e il preventivo di $1.12 per 2K a 8 secondi.

Passo 3: Polla e gestisci tutti e cinque gli stati di MiniMax H3

Questo è il loop che tutti sbagliano, quindi vale la pena scriverlo per intero. Quattro regole: rallenta invece di martellare, limita l'attesa totale, tratta succeeded come "scarica ora", e solleva eccezione per qualsiasi stato non nell'enum.

pythonCopy
1TERMINAL_OK   = {"succeeded"}
2TERMINAL_BAD  = {"failed", "cancelled"}
3IN_FLIGHT     = {"queued", "running"}
4
5def poll(task_id: str, timeout_s: int = 900) -> dict:
6    delay, deadline = 3.0, time.time() + timeout_s
7    while time.time() < deadline:
8        r = requests.get(f"{BASE}/v2/query/video_generation/{task_id}",
9                         headers=HEADERS, timeout=30)
10        r.raise_for_status()
11        task = r.json()["task"]
12        status = task["status"]
13
14        if status in TERMINAL_OK:
15            return task                                  # content.url è attivo ORA
16        if status in TERMINAL_BAD:
17            raise RuntimeError(f"{status}: {json.dumps(r.json())[:400]}")
18        if status not in IN_FLIGHT:
19            # uno stato che l'enum non ha. NON cadere in "continua ad aspettare".
20            raise RuntimeError(f"stato sconosciuto {status!r} -- leggi il changelog")
21
22        print(f"  {status} ... prossimo controllo tra {delay:.0f}s")
23        time.sleep(delay)
24        delay = min(delay * 1.5, 15.0)                    # 3s -> limite 15s
25    raise TimeoutError(f"{task_id} ancora non terminale dopo {timeout_s}s")
26

Tre cose in questo sono intenzionali:

status not in IN_FLIGHT solleva eccezione invece di continuare. Se MiniMax aggiunge un sesto stato il prossimo trimestre, vuoi un crash rumoroso, non un loop che aspetta una parola che non arriva mai. Questa singola riga è la differenza tra il tutorial rotto e questo.

failed non riprova. Un render fallito di solito significa che il prompt ha innescato un filtro o il payload aveva una combinazione errata, e inviare lo stesso identico payload ti compra lo stesso identico fallimento a prezzo pieno. Logga il corpo, guardalo, poi decidi.

Il backoff inizia a 3 secondi e arriva a 15. H3 a 2K richiede minuti, non secondi. Pollare una volta al secondo brucia solo il tuo limite di velocità sull'endpoint di query.

Passo 4: Scarica prima che l'URL scada

Nel momento in cui arriva succeeded, trasmetti il file su disco. L'URL in content.url è esplicitamente un link temporaneo: "Scaricalo o conservalo tempestivamente; interroga di nuovo per ottenere un nuovo URL dopo la scadenza" (Riferimento API MiniMax, agosto 2026). Non è un percorso CDN che puoi mettere nel tuo database e dimenticare.

La seconda metà è la buona notizia, ed è la risposta al 404 che hai ricevuto la mattina dopo. Il render non è sparito. Interroga di nuovo lo stesso task_id e ottieni un URL fresco, per un massimo di 7 giorni dopo la creazione.

pythonCopy
1def download(url: str, path: str) -> str:
2    with requests.get(url, stream=True, timeout=300) as r:
3        r.raise_for_status()
4        with open(path, "wb") as f:
5            for chunk in r.iter_content(1 << 20):
6                f.write(chunk)
7    return path
8
9def refresh_url(task_id: str) -> str:
10    """Link morto? Il render è a posto. Chiedi di nuovo, entro la finestra di 7 giorni."""
11    r = requests.get(f"{BASE}/v2/query/video_generation/{task_id}",
12                     headers=HEADERS, timeout=30)
13    r.raise_for_status()
14    return r.json()["task"]["content"]["url"]
15
16task = poll(shot_a)
17download(task["content"]["url"], "shot-a.mp4")
18

Cosa torna per la scena A, accanto allo still da cui è partita:

Affiancati: il primo frame generato a sinistra, un frame dalla clip MiniMax H3 finita a destra, che mostra le piastre delle ali dell'uccello aperte e gli occhi illuminati

Left: lo still GPT Image 2 del Passo 1, esattamente come inviato. Right: un frame estratto dalla clip 2K restituita da H3. Stessa scena, stessa luce, le piastre delle ali e gli occhi sono ciò che si è mosso.

Passo 5: Scena B con MiniMax H3 text-to-video, dove ratio è obbligatorio

Nessun frame sorgente per il cielo, quindi la scena B è solo testo. Questo inverte la regola di ratio da "ignorato" a "obbligatorio": per un prompt solo testo, ratio è obbligatorio e non può essere adaptive (Riferimento API MiniMax, agosto 2026). Se lo ometti o invii adaptive ottieni un 400 immediato, prima che inizi qualsiasi render.

Modello: minimax/h3/text-to-video. Impostazioni: 2K, durata 6, rapporto 16:9.

textCopy
1The brass bird bursts through a half-open workshop skylight into a rain-washed
2evening sky, wings beating in a whir of gears, droplets spraying off the metal
3feathers as it climbs past wet slate rooftops toward a break of gold cloud.
4Camera cranes up behind it, 24mm, backlit rim from the low sun. Sound: wing
5servos whirring, wind rising, distant church bell, rain fading out. No text.
6

pythonCopy
1shot_b = create_task({
2    "model": "MiniMax-H3",
3    "resolution": "2K",
4    "duration": 6,
5    "ratio": "16:9",          # obbligatorio qui. se ometti o passi "adaptive" -> 400
6    "content": [{"type": "text", "text": SHOT_B_PROMPT}],
7})
8download(poll(shot_b)["content"]["url"], "shot-b.mp4")
9

Playground MiniMax H3 text-to-video su Atlas Cloud con il prompt dell'uccello che vola e la clip finita nel pannello di output

MiniMax H3 text-to-video con il prompt della scena B e Aspect Ratio impostato esplicitamente su 16:9. Questa esecuzione ha usato i 8 secondi predefiniti della pagina anziché i 6 del payload sopra.

Passo 6: Salta il polling con un callback ed echeggia il challenge in 3 secondi

Se preferisci che ti venga detto piuttosto che chiedere, passa callback_url nella chiamata create. C'è esattamente un problema, è documentato in una singola parentesi nel riferimento API, ed è il modo più comune in cui i callback self-hosted falliscono.

Prima che MiniMax ti invii qualcosa, invia una richiesta di verifica contenente un campo challenge, e "devi restituire il challenge identico entro 3 secondi per completare la verifica" (Riferimento API MiniMax, agosto 2026). Se manchi, non c'è alcun errore da nessuna parte. Le tue chiamate create continuano ad avere successo, i tuoi render continuano a finire, e semplicemente non ricevi mai un push. Niente in nessun log dice perché.

Dodici righe di FastAPI, e l'ordine al loro interno è il punto centrale:

pythonCopy
1from fastapi import FastAPI, Request
2
3app = FastAPI()
4
5@app.post("/minimax/callback")
6async def callback(req: Request):
7    body = await req.json()
8    if "challenge" in body:                 # stretta di mano di verifica, rispondi PRIMA
9        return {"challenge": body["challenge"]}   # identico, sincrono, nessun gate di autenticazione
10    task_id = body.get("task_id")
11    status  = body.get("status")
12    enqueue(task_id, status)                # notifica reale: passa il compito, torna veloce
13    return {"ok": True}
14

Gli errori che lo uccidono, in ordine di frequenza con cui li ho visti:

• La richiesta di challenge passa attraverso il tuo middleware di autenticazione e ottiene un 401 o un redirect. La verifica è non autenticata per definizione. Metti il percorso in whitelist.
• Il gestore mette il challenge in una coda e risponde in modo asincrono. Troppo tardi. Quella risposta deve essere nel corpo della risposta di quella richiesta.
• Il valore viene re-serializzato, tagliato o avvolto. Echeggialo byte per byte.
• Stai testando attraverso un tunnel su un server di sviluppo serverless, e il cold start da solo supera i 3 secondi. Riscaldalo prima, o verifica con un processo già in esecuzione.

Il polling va perfettamente bene, comunque. Se hai una manciata di lavori all'ora, il loop del Passo 3 è meno codice e meno cose da rompere. Il callback ripaga quando hai molti lavori e non vuoi un poller per lavoro.

Passo 7: Concatena le due clip in un unico film

Entrambe le clip sono tornate come 2560x1440 h264 a 24fps con audio stereo AAC a 32kHz. Stesso contenitore, stesso tutto, quindi questa è una copia del flusso piuttosto che una re-encode. Nessuna perdita di qualità, nessuna attesa.

Una piccola sorpresa che vale la pena aspettarsi: chiedere 6 secondi mi ha restituito un file di 6,58 secondi. Le durate tornano vicine a ciò che hai chiesto, non esatte al fotogramma, quindi le due clip sommano a 14,62 secondi anziché un netto 14.

bashCopy
1printf "file 'shot-a.mp4'\nfile 'shot-b.mp4'\n" > list.txt
2ffmpeg -f concat -safe 0 -i list.txt -c copy brass-bird-two-shot.mp4
3

Quell'output è il video all'inizio di questo articolo. Se -c copy si lamenta, le tue due clip hanno risoluzioni o frame rate diversi, il che su H3 significa che hai cambiato resolution tra le chiamate. Abbinale, oppure elimina -c copy e accetta una re-encode.

Variazioni del tutorial MiniMax H3 che vale la pena rubare

Cinque cose da provare una volta che il loop sopra funziona, in ordine approssimativo di quanto risparmio ti danno.

Bozza a 768P, finisci a 2K. Entrambi i livelli sono lo stesso modello, e 768P costa circa il 29% in meno al secondo. Rendi le tue candidate brevi ed economiche, guardale, poi ri-esegui solo la vincitrice a 2K con lo stesso prompt. È qui che vive la maggior parte dei risparmi in una lista di scene. Di quale livello hai effettivamente bisogno per la consegna è un discorso a parte, e l'ho fatto in 768P vs 2K.

La durata è ogni intero da 4 a 15. Non un insieme di preset. Se l'azione arriva a 7 secondi, chiedi 7 e smetti di pagare per 8.

Primo frame più ultimo frame. Invia un secondo elemento immagine con role: "last_frame" e H3 costruirà la transizione tra di loro. Utile per passaggi tra scene che hai già diretto artisticamente.

Reference-to-video per continuità. role: "reference_image" mantiene un personaggio tra le scene invece di rigenerare la sua faccia ogni volta. C'è un ruolo reference_audio corrispondente con una finestra da 2 a 15 secondi per la clip di riferimento, che è come mantieni una voce coerente. Vedi reference-to-video.

Testa parlante verticale. ratio: "9:16" con una riga di dialogo nel prompt è il caso d'uso più massiccio di questo modello al momento, perché l'audio esce dallo stesso passaggio e le labbra coincidono senza un passaggio separato di lip-sync.

La scrittura dei prompt è un'abilità separata dalla parte asincrona, e se le tue scene sono tecnicamente pulite ma visivamente piatte, il problema è a monte di questo articolo. Inizia con la guida ai prompt H3.

Quanto è costato eseguire questo tutorial MiniMax H3

Voci reali dall'esecuzione che ha prodotto il film all'inizio, quotate dal pulsante Esegui e verificate il 12-08-2026. H3 fattura al secondo di output e la tariffa è a livelli per risoluzione: i lavori a 2K hanno quotato $1.12 per 8 secondi, che è $0.14 al secondo, e la tariffa iniziale del catalogo di $0.10 è il livello 768P. Tutti e tre gli endpoint H3 sono a prezzo pieno in questo momento, nessuno sconto applicato.

Vale la pena notare che le stesse due scene abbozzate a 768P sarebbero costate $0.80 e $0.60 invece di $1.12 e $0.84, circa il 29% in meno, per filmati su cui puoi assolutamente giudicare una ripresa.

Due dettagli di fatturazione che è facile imparare a caro prezzo. Una richiesta rifiutata all'invio non costa nulla, quindi un 400 per un ratio mancante è gratuito. Una richiesta che rende qualcosa di inutile non è gratuita: se il lavoro raggiunge succeeded, ti viene addebitato, anche se l'output non è quello che volevi. Questo è il vero argomento per abbozzare a 768P.

Le tariffe al secondo, il confronto 768P e 2K, e come si comporta l'addebito in base alla durata sono analizzati correttamente nel prezzi API MiniMax H3 complementare a questo articolo. Questo è il codice, quello è il conto.

Attribuzione e territorio prima di pubblicare

Due cose da controllare prima che questo vada da qualche parte pubblicamente. I termini API di MiniMax includono un obbligo di difesa condizionale che copre le rivendicazioni di brevetto e copyright contro l'output dell'API, e tale obbligo non si estende a marchi o somiglianze, quindi un logo riconoscibile o una persona reale nel tuo prompt sono comunque un problema tuo. Separatamente, la licenza open-weights per H3 ha una clausola di Territori Esclusi, e tale clausola governa i pesi scaricati e i loro output, non l'API ospitata, i cui termini nominano una regione di servizio USA che puoi selezionare. Leggi qualunque contratto tu abbia effettivamente firmato. E etichetta l'output H3 come output H3 nella tua interfaccia.

FAQ tutorial MiniMax H3

Quali sono gli stati dei task MiniMax H3, e ne esiste uno expired?

Cinque: queued, running, succeeded, failed, cancelled. Non esiste uno stato expired. Altre due cose scadono e vengono confuse con uno: l'URL di download in content.url è limitato nel tempo, e il record del task stesso è interrogabile solo per gli ultimi 7 giorni.

Devo usare un callback, o il polling è sufficiente per MiniMax H3?

Il polling è sufficiente ed è meno codice. Usa un callback quando hai abbastanza lavori concorrenti che un poller per lavoro è eccessivo. Se lo fai, l'endpoint deve restituire il campo challenge identico entro 3 secondi, in modo sincrono, prima di qualsiasi middleware di autenticazione. Una stretta di mano fallita non produce alcun messaggio di errore, solo silenzio permanente.

Perché la mia richiesta MiniMax H3 text-to-video dà 400 con "ratio is required and cannot be adaptive"?

Perché sei in modalità solo testo, dove non c'è un primo frame da cui dedurre il formato. Passa un valore esplicito: 21:9, 16:9, 4:3, 1:1, 3:4 o 9:16. La stessa regola spiega perché ratio sembra non fare nulla in image-to-video, dove il primo frame decide e qualsiasi rapporto tu invii viene ignorato.

Quanti lavori MiniMax H3 posso eseguire in parallelo?

Il limite documentato è basato sulle connessioni: 2 task concorrenti gratuiti, 15 a pagamento. Oltre il limite ottieni un 429 immediato anziché uno slot in coda, quindi limita il tuo conto di richieste in volo. I gateway di routing a volte assorbono di più, e ho avuto 20 lavori concorrenti tutti completati, ma sono stato anche 429 sulla stessa configurazione un altro giorno. Non costruire uno scheduler che presuppone il numero più alto.

Il mio URL video MiniMax H3 dà 404 un giorno dopo. Il render è sparito?

No. L'URL è scaduto, il render no. Interroga di nuovo lo stesso task_id e la risposta porta un URL fresco, in qualsiasi momento entro la finestra di query di 7 giorni. Dopo 7 giorni il record del task stesso non è più interrogabile, motivo per cui il Passo 2 persiste il task_id prima di fare qualsiasi altra cosa.

Ho cercato "hailuo ai video generator how to use" e sono finito su un tutorial MiniMax H3. Sono nel posto giusto?

Sì. Hailuo è l'app consumer e H3 è il nome del modello usato dall'API. Stesso motore. Se vuoi una clip, usa il percorso playground nella sezione workflow sopra, nessun codice richiesto. Se vuoi dieci varianti o un primo frame inserito da un altro modello, i sette passaggi sono per te.