Controllare i costi delle API di immagini e video AI: livelli, batch e scelta del modello

Nessuno esaurisce un budget per i media AI con una singola chiamata API da capogiro. La spesa si perde silenziosamente in tre abitudini: pagare il prezzo pieno per bozze usa e getta, non sapere su quale unità si viene effettivamente fatturati, e iterare in serie su modelli costosi perché il flusso di lavoro non è mai stato impostato per generare prima ampiamente ed economicamente le varianti.

Questa guida illustra le leve di costo che contano davvero quando si generano immagini e video con hiapi: unità di fatturazione, livelli di qualità, durata dei video, flusso di lavoro bozza-poi-aggiornamento e batch tramite l'API di attività asincrone. Tutti i prezzi riportati di seguito provengono dalla pagina prezzi live di luglio 2026 — trattali come un'istantanea e controlla i prezzi attuali prima di fare qualsiasi budget.

Chiarisci esattamente su quale unità paghi

hiapi fattura i modelli media su una base fissa per unità di output — nessun conteggio di token da ricostruire a ritroso:

• I modelli per immagini vengono fatturati per immagine, indipendentemente da quanto sia complesso il prompt.
• I modelli per video vengono fatturati per secondo di output generato.
• I modelli audio (ad esempio elevenlabs/text-to-dialogue-v3) vengono fatturati per 1.000 caratteri di testo di input.

Ecco una panoramica dei prezzi per immagine della linea text-to-image:

Modello	Prezzo per immagine
flux-schnell/text-to-image	$0.005
gpt-image-2/text-to-image@ext	$0.007
z-image	$0.008
gpt-image-2/text-to-image@beta	$0.02
qwen-image-2.0	$0.025
gpt-image-2/text-to-image	$0.03
nano-banana	$0.05
flux-1.1-pro	$0.05
flux-2/text-to-image	$0.05
nano-banana-2	$0.051
wan2.7-image/text-to-image	$0.08
nano-banana-pro	$0.17

E i prezzi per secondo dei video:

Modello	Prezzo per secondo
grok-imagine (text-to-video / image-to-video)	$0.0114
kling-3.0-omni (text-to-video / image-to-video)	$0.129
seedance-2.0	$0.136
seedance-2.0-mini	$0.147
wan2.7-video@pro (text-to-video / image-to-video)	$0.167
happyhorse-1.0	$0.168
happyhorse-1.1 (tutti gli endpoint)	$0.21
seedance-2.0-fast	$0.2357
veo-3.1-fast	$0.25
veo-3.1	$0.57

Due numeri da tenere a mente: la linea immagini va dal più economico al più costoso con un fattore di 34 volte ($0.005 → $0.17), i video di 50 volte ($0.0114 → $0.57 al secondo). La scelta del modello non è una manopola di ottimizzazione — è la singola decisione di budget più importante che prendi.

Un avvertimento: non dedurre i prezzi dal nome del modello. Nella famiglia Veo, le varianti -fast sono il livello più economico ($0.25/s contro $0.57/s), ma seedance-2.0-fast è un livello premium accelerato che costa più per secondo del seedance-2.0 base ($0.2357 contro $0.136). Leggi la tabella dei prezzi; non dare mai nulla per scontato.

Tratta i livelli di prezzo come funzionalità, non come dettagli"

La maggior parte delle famiglie di modelli viene rilasciata a livelli, e i livelli esistono proprio per non dover pagare il prezzo del flagship per ogni lavoro:

• Livello bozza ($0.005–$0.008): flux-schnell, z-image e il canale @ext di gpt-image-2. Per iterare sui prompt, testare la composizione e qualsiasi cosa che un umano guarderà una sola volta prima di scartarla.
• Livello standard ($0.02–$0.05): gpt-image-2/text-to-image, qwen-image-2.0, nano-banana, flux-2. Per la qualità di produzione di copertine di blog, immagini di prodotto e asset UI.
• Livello premium ($0.08–$0.17): wan2.7-image e nano-banana-pro. Riservati agli asset visivi finali in cui dettaglio e aderenza alle istruzioni sono cruciali.

La stessa logica vale per le varianti di canale: la pagina prezzi elenca le versioni @beta e @ext di gpt-image-2/text-to-image rispettivamente a $0.02 e $0.007, mentre il canale standard costa $0.03. Se il tuo carico di lavoro tollera i termini dei canali di anteprima, risparmi dal 20% al 77% sugli stessi prompt. Approfondiamo l'interazione tra costo per immagine, risoluzione e tasso di tentativi in L'API di generazione immagini più economica: come confrontare il vero costo per immagine.

Per i video, la durata è un moltiplicatore

Il costo di un video è tariffa × secondi, il che significa che ogni valore predefinito che non hai messo in discussione viene amplificato. Lo stesso clip di 8 secondi costa:

Modello	Clip di 8 secondi
grok-imagine/text-to-video	$0.09
kling-3.0-omni/text-to-video	$1.03
veo-3.1-fast/text-to-video	$2.00
veo-3.1/text-to-video	$4.56

Ne derivano direttamente due abitudini:

1. Richiedi la durata più breve che soddisfa l'inquadratura. Ridurre un clip veo-3.1 da 8 a 5 secondi fa risparmiare $1.71 — per ogni clip, ogni volta.
2. Itera su modelli economici, renderizza su modelli costosi. Sei iterazioni di bozza da 4 secondi su grok-imagine costano in totale circa $0.27 — meno del costo di mezzo secondo di output di veo-3.1. Consuma lì la tua sperimentazione sui prompt, poi spendi $4.56 una sola volta.

Bozze economiche, finalizzazione premium

Il singolo cambiamento di flusso di lavoro con il maggiore impatto è separare l'esplorazione dalla consegna. Esempio pratico per un'immagine di prodotto:

• 20 iterazioni di bozza su z-image a $0.008 ciascuna = $0.16
• 3 render finali su nano-banana-pro a $0.17 ciascuno = $0.51
• Totale: $0.67

Eseguire tutte e 23 le generazioni su nano-banana-pro sarebbe costato $3.91. Stesso numero di chiamate API, stessi asset finali, spesa ridotta di circa l'83% — e il ciclo di bozze è anche più veloce, perché i modelli di livello bozza rispondono in pochi secondi.

L'unica cosa a cui prestare attenzione: i prompt non si trasferiscono perfettamente tra famiglie diverse. Nelle ultime una o due iterazioni, mantieni il ciclo di bozze sul modello che userai per la finalizzazione, così scopri le particolarità della famiglia prima di impegnare il budget premium.

Batch tramite l'API di attività asincrone

Ogni modello media su hiapi passa attraverso endpoint di attività asincrone: POST /v1/tasks restituisce immediatamente un ID attività, poi esegui il polling del risultato. Il batch non ha sconti per richiesta — il vantaggio è architetturale. Poiché l'invio è disaccoppiato dal completamento, puoi distribuire un intero lotto di bozze in una volta invece di attendere in serie ogni generazione, ed è proprio questo che rende praticabile il ciclo bozza-poi-aggiornamento:

import requests, time

API = "https://api.hiapi.ai/v1/tasks"
HEADERS = {"Authorization": "Bearer YOUR_API_KEY"}

def create_task(model: str, prompt: str) -> str:
    r = requests.post(API, headers=HEADERS, json={
        "model": model,
        "input": {"prompt": prompt, "aspect_ratio": "1:1"},
    })
    r.raise_for_status()
    return r.json()["data"]["taskId"]

def wait_task(task_id: str, timeout: int = 600) -> str:
    deadline = time.time() + timeout
    while time.time() < deadline:
        task = requests.get(f"{API}/{task_id}", headers=HEADERS).json()["data"]
        if task["status"] == "success":
            return task["output"][0]["url"]  # expiring URL — download it now
        if task["status"] == "fail":
            raise RuntimeError(task.get("error"))
        time.sleep(5)
    raise TimeoutError(task_id)

# Fan out 12 draft variations on a $0.008 model: ~$0.10 for the whole batch
variations = [f"studio product shot of a ceramic mug, camera angle {i}" for i in range(12)]
task_ids = [create_task("z-image", p) for p in variations]
urls = [wait_task(t) for t in task_ids]

Invia tutte e dodici prima, poi esegui il polling — le attività vengono generate in parallelo lato piattaforma, mentre il tuo codice attende una sola volta. I campi di input oltre a prompt variano da modello a modello (alcuni accettano resolution, altri solo aspect_ratio), quindi consulta la tabella dei parametri del modello prima di fare batch; la guida pratica a gpt-image-2 mostra il pattern dall'inizio alla fine.

Quando aumenti la scala della distribuzione, rispetta i limiti di concorrenza della piattaforma — un burst che genera 429 aggiunge solo latenza ai tentativi. Limiti di velocità delle API di generazione immagini spiegati illustra come si comportano i limiti e come fare backoff in modo pulito.

Dieci righe di guardia del budget trasformano "terremo d'occhio la spesa" in un vero invariante:

PRICES = {"z-image": 0.008, "gpt-image-2/text-to-image": 0.03, "nano-banana-pro": 0.17}
BUDGET_USD = 5.00
spent = 0.0

def spend(model: str, images: int = 1) -> None:
    global spent
    cost = PRICES[model] * images
    if spent + cost > BUDGET_USD:
        raise RuntimeError(f"budget cap: ${spent + cost:.2f} would exceed ${BUDGET_USD:.2f}")
    spent += cost

Chiamala prima di ogni create_task: un ciclo fuori controllo fallirà rumorosamente a $5, invece di comparire sulla fattura del mese prossimo.

Non pagare due volte lo stesso output

La perdita di costo più insidiosa è la rigenerazione — pagare il prezzo pieno per un output che già possiedi:

• Scarica subito i risultati. Gli URL di output delle attività hanno una scadenza. Se memorizzi un hotlink invece del file e il link scade, l'unica soluzione è pagare per rigenerare. Dettagli e pattern di download qui.
• Distingui "l'attività è fallita" da "il mio polling ha rinunciato". Un'attività che ha avuto successo dopo che il client è andato in timeout è denaro speso per un output che nessuno ha raccolto. Imposta il timeout del polling molto più alto del tempo di completamento reale del modello — prima di presumere un fallimento, qui spieghiamo come diagnosticare le attività bloccate.
• Riusa la tua libreria. Prima della quinta generazione di una "pulita foto da studio su sfondo bianco", controlla gli asset che hai già pagato. Un bucket condiviso con prompt ricercabili è il modello più economico del tuo stack.

Checklist per il controllo dei costi

1. Fai il budget nell'unità nativa del modello: per immagine, per secondo, per 1.000 caratteri.
2. Scegli un modello di livello bozza e uno di livello delivery per ogni tipo di media; instrada in base alla fase di lavoro.
3. Per i video, metti in discussione ogni valore predefinito di durata — i secondi sono un moltiplicatore.
4. Distribuisci le bozze tramite /v1/tasks; promuovi solo i vincitori ai render premium.
5. Applica limiti di spesa rigidi nel codice, non in una dashboard che controlli una volta a settimana.
6. Scarica subito ogni output; non memorizzare mai URL che scadono.

I prezzi dei modelli cambiano con il rilascio di nuove versioni, quindi parti dalla pagina prezzi live, scegli i tuoi modelli di livello bozza e delivery dal catalogo modelli e collega il pattern di distribuzione sopra descritto alla tua pipeline — i primi lotti di attività che esegui ti diranno esattamente il vero costo di ogni asset disponibile.