Guida rapida all’API PixMind: genera immagini con Node.js

Una richiesta di generazione di immagini accettata non equivale a un’immagine pronta. La tua applicazione deve conservare l’ID attività, controllare la stessa attività e gestire una richiesta non riuscita o interrotta senza avviare accidentalmente un altro lavoro.

In questo tutorial realizzerai un piccolo client Node.js lato server per questa sequenza. Il client prevede due comandi distinti, submit e resume: il primo crea un’attività, mentre il secondo controlla soltanto un’attività esistente. Parti dagli ID dei modelli supportati dall’API, non da un nome di modello copiato da un banner della pagina iniziale.

Il tutorial riguarda la generazione di immagini da testo. Non carica file di riferimento, non implementa un’interfaccia nel browser e non misura la qualità dei modelli. La validazione combina 29 test locali con risposte simulate e una sola attività di generazione di immagini eseguita in modo controllato in produzione il 4 settembre 2026. Quell’attività ha restituito un’immagine e registrato un addebito API di 120 punti. Si tratta di una singola verifica dell’integrazione riferita a una data precisa, non di un benchmark di velocità, di un prezzo universale o di una garanzia di disponibilità per un altro account.

La copertina è una schermata del catalogo dei modelli acquisita il 4 settembre 2026. Considerala un’illustrazione riferita a quella data, non un preventivo aggiornato o una garanzia di disponibilità.

Punti essenziali

• Conserva la chiave API sul server, fuori dai bundle del browser e dai repository pubblici.
• Per un’attività di generazione di immagini, leggi il valore numerico data.taskId nella risposta di accettazione e conservalo per le interrogazioni successive.
• Esegui il polling dell’attività salvata fino allo stato ready o failed. Leggi gli URL delle immagini da data.images solo dopo il completamento riuscito.
• Un timeout del client non dimostra che l’attività remota sia fallita o sia stata annullata. Riprendi le interrogazioni quando hai un ID attività; non ripetere alla cieca la richiesta di creazione.

In questa guida

• Prima di iniziare
• Scegli un modello e configura la chiave API
• Invia la richiesta con cURL
• Esegui il polling e leggi gli URL delle immagini
• Esempio completo in Node.js
• Gestisci gli errori
• Differenze per video e chat
• Verifica l’integrazione

Prima di iniziare

Usa un terminale privato o un ambiente server con Node.js, una chiave API e un account configurato per la fatturazione API. L’esempio allegato usa fetch, già integrato, e i moduli JavaScript, senza richiedere l’installazione di pacchetti di terze parti. La documentazione delle API globali di Node descrive fetch e AbortSignal.timeout, che il client usa per limitare la durata di una singola richiesta. L’ambiente di validazione locale è Windows con Node.js v22.22.1; questa è una registrazione dell’ambiente di test, non un’affermazione che tutte le altre versioni siano state provate.

Devi saper modificare un file, impostare una variabile d’ambiente e leggere JSON. Controlla il runtime installato prima di proseguire:

node --version

Il comando dovrebbe mostrare la versione installata. Non contatta l’API di generazione. Salva il client completo della sezione successiva come examples/pixmind-image.mjs in una cartella di lavoro, quindi esegui i suoi comandi da quella cartella.

Scegli un prompt di prova innocuo, senza dati dei clienti o materiale riservato. Questo tutorial usa una tazza da caffè in ceramica su uno sfondo da studio, quindi non richiede il caricamento di riferimenti. Controlla il prezzo API attuale del modello selezionato prima di inviare la richiesta. Non dare per scontato che crediti Studio, abbonamenti e fatturazione API siano intercambiabili; il catalogo dei modelli spiega l’offerta API applicabile.

Se vuoi soltanto creare un’immagine in modo interattivo, la guida a Image Agent descrive quel flusso di lavoro. Il client presentato qui è destinato a un’applicazione che specifica esplicitamente un ID modello e gestisce autonomamente la risposta.

Scegli un modello e configura la chiave API

Usa un ID modello supportato dall’API e parametri supportati da quel modello. L’esempio seleziona nano-banana-pro, con aspectRatio: "1:1" e resolution: "1K", come nella richiesta di immagini della guida rapida all’API. Una richiesta autenticata GET /models e il test in produzione hanno confermato questa combinazione per l’account di test il 4 settembre 2026. Verifica di nuovo la disponibilità e il supporto dei parametri per il tuo account prima di un’esecuzione reale. Modificare soltanto la stringa del modello non basta a garantire che il resto della richiesta rimanga valido.

Crea una chiave nella console API, poi forniscila al processo server tramite PIXMIND_API_KEY. Se disponibile, usa il tuo sistema privato di gestione dei segreti. Gli esempi seguenti mostrano la sintassi delle variabili d’ambiente con un segnaposto, non con una credenziale funzionante.

Per PowerShell:

$env:PIXMIND_API_KEY = "REPLACE_WITH_YOUR_PRIVATE_API_KEY"
$env:PIXMIND_MODEL = "nano-banana-pro"
$env:PIXMIND_PROMPT = "A ceramic coffee cup on a plain studio background, soft side lighting, no text"

Per Bash:

export PIXMIND_API_KEY="REPLACE_WITH_YOUR_PRIVATE_API_KEY"
export PIXMIND_MODEL="nano-banana-pro"
export PIXMIND_PROMPT="A ceramic coffee cup on a plain studio background, soft side lighting, no text"

Queste assegnazioni configurano la shell corrente e i processi avviati da essa. Non creano un’attività. Proteggi la cronologia della shell e le registrazioni quando inserisci un segreto reale, e non aggiungerlo mai al controllo versione. Segui le indicazioni sull’autenticazione per usare chiavi distinte in sviluppo e in produzione e sostituirle in caso di esposizione.

L’URL di base per questo tutorial è:

https://aihub-admin.aimix.pro/api-platform/v1

Aggiungi /generations o /tasks/{taskId} a questa base. Non aggiungere un secondo /v1. Puoi ottenere l’elenco dei modelli tramite GET /models; il catalogo è il posto più comodo per leggere le funzionalità specifiche di ciascun modello prima di scegliere i parametri.

Invia la prima richiesta di generazione di immagini con cURL

La richiesta cURL è un’alternativa al comando Node.js submit, non un passaggio di configurazione da eseguire prima. Entrambi inviano una richiesta di generazione. Eseguirli entrambi può creare due attività fatturabili. Se invii la richiesta con cURL, usa poi il comando Node.js resume con l’ID attività restituito.

Questo esempio usa la sintassi Bash. In PowerShell, usa il client Node.js qui sotto invece di incollare nel terminale le continuazioni di riga di Bash.

curl --connect-timeout 10 --max-time 30 \
  --request POST \
  'https://aihub-admin.aimix.pro/api-platform/v1/generations' \
  --header "Authorization: Bearer $PIXMIND_API_KEY" \
  --header 'Content-Type: application/json' \
  --data '{
    "model": "nano-banana-pro",
    "type": "image",
    "prompt": "A ceramic coffee cup on a plain studio background, soft side lighting, no text",
    "aspectRatio": "1:1",
    "resolution": "1K"
  }'

Il prompt e i parametri nel corpo di questa richiesta cURL sono valori letterali. Modificare PIXMIND_PROMPT non modifica questo JSON; quella variabile d’ambiente viene letta dal client Node.js. Questa distinzione aiuta a tenere separata la richiesta che intendi inviare dalla configurazione della shell che la circonda.

Di seguito trovi una risposta di accettazione abbreviata e illustrativa. Il suo ID è un segnaposto, non quello del test in produzione; 12345 non è un’attività da interrogare.

{
  "code": 1000,
  "message": "success",
  "data": {
    "id": "img_12345",
    "taskId": 12345
  }
}

Le risposte multimediali provate in produzione racchiudevano i dati delle operazioni riuscite in un oggetto con code, message, data e timestamp; l’esempio omette il timestamp e altri campi. Per questo flusso di lavoro, il successo richiede sia una risposta HTTP di esito positivo sia una risposta applicativa valida. Leggi data.taskId, non data.id: quest’ultimo può contenere una stringa con un prefisso, come img_12345, mentre il percorso per interrogare l’attività usa l’ID numerico.

Salva subito quell’ID numerico. Se la richiesta va in timeout prima che tu lo riceva, fermati e verifica l’esito dell’invio nei registri delle attività del tuo account o tramite l’assistenza. Ripetere la POST non è un’alternativa sicura all’accertamento di ciò che è successo.

Esegui il polling dell’attività e leggi gli URL delle immagini

Interroga l’attività esistente finché non raggiunge uno stato finale. La documentazione sulle attività asincrone descrive pending, processing, ready e failed. Solo gli ultimi due stati concludono questo flusso di polling.

Submit once
    |
Save numeric taskId
    |
GET /tasks/{taskId} <--- wait, then query again
    |                            ^
    +--- pending / processing ---+
    |
    +--- ready  ---> read images, stop
    |
    +--- failed ---> report failure, stop

Per un’interrogazione manuale in Bash, sostituisci l’ID segnaposto con il tuo:

TASK_ID="REPLACE_WITH_YOUR_NUMERIC_TASK_ID"
curl --connect-timeout 10 --max-time 30 \
  "https://aihub-admin.aimix.pro/api-platform/v1/tasks/$TASK_ID" \
  --header "Authorization: Bearer $PIXMIND_API_KEY"

Nell’attuale struttura prevista per le risposte multimediali, i campi che ti servono hanno funzioni diverse:

Una risposta ready priva di URL di immagini utilizzabili non è un risultato immagine riuscito per la tua applicazione. Segnala questa incongruenza insieme all’ID attività, così da poterla esaminare. Non sostituire il risultato con un URL di esempio e non dichiarare che un’immagine è stata scaricata.

Il client mostra gli URL delle immagini restituiti; non recupera né archivia i file immagine. Se la tua applicazione richiede un’archiviazione duratura, progettala come passaggio separato e verifica i termini applicabili alla conservazione e all’utilizzo dei contenuti. La presenza di un URL non implica una garanzia di archiviazione permanente.

Esegui l’esempio completo in Node.js

Usa submit per una nuova attività oppure resume per un’attività esistente. Se esegui lo script senza argomenti, mostra le istruzioni d’uso e non effettua chiamate API. Questo comportamento predefinito impedisce che un normale riavvio o una rapida consultazione della CLI creino un nuovo lavoro.

Salva il sorgente completo qui sotto come examples/pixmind-image.mjs:

import { pathToFileURL } from 'node:url';

const BASE_URL = 'https://aihub-admin.aimix.pro/api-platform/v1';
const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));

export class ApiError extends Error {
  constructor(message, { status = 0, transient = false, retryAfterMs = 0 } = {}) {
    super(message);
    Object.assign(this, { status, transient, retryAfterMs });
  }
}

export function parseTaskId(value) {
  if (!/^\d+$/.test(String(value))) throw new Error('Use a numeric taskId, not img_...');
  const id = Number(value);
  if (!Number.isSafeInteger(id) || id <= 0) throw new Error('Invalid taskId');
  return id;
}

export function retryAfter(value, now) {
  if (!value) return 0;
  if (/^\d+(\.\d+)?$/.test(value)) return Number(value) * 1000;
  const date = Date.parse(value);
  return Number.isFinite(date) ? Math.max(0, date - now) : 0;
}

export function createClient({
  apiKey,
  fetchImpl = fetch,
  now = Date.now,
  wait = sleep,
  random = Math.random,
  requestTimeoutMs = 30_000,
  pollTimeoutMs = 300_000,
  maxConsecutiveErrors = 5,
} = {}) {
  if (typeof apiKey !== 'string' || !apiKey.trim()) throw new Error('Set PIXMIND_API_KEY');

  async function request(path, method, payload, timeoutMs = requestTimeoutMs) {
    let response;
    let body;
    try {
      response = await fetchImpl(`${BASE_URL}${path}`, {
        method,
        redirect: 'error',
        headers: {
          Authorization: `Bearer ${apiKey}`,
          ...(payload ? { 'Content-Type': 'application/json' } : {}),
        },
        ...(payload ? { body: JSON.stringify(payload) } : {}),
        signal: AbortSignal.timeout(Math.max(1, Math.ceil(timeoutMs))),
      });
      // Read the body inside the timeout/network error boundary as well.
      body = await response.text();
    } catch {
      throw new ApiError('Network error or request timeout', { transient: true });
    }
    let envelope;
    try { envelope = JSON.parse(body); } catch { /* handle below */ }
    const transient = response.status === 429 || response.status >= 500;
    if (!response.ok) {
      // Do not echo arbitrary server bodies, prompts, credentials, or output URLs.
      throw new ApiError(`HTTP ${response.status}; inspect the account and request`, {
        status: response.status,
        transient,
        retryAfterMs: retryAfter(response.headers.get('retry-after'), now()),
      });
    }
    if (!envelope || typeof envelope !== 'object') {
      throw new ApiError('Expected a JSON API response');
    }
    if (envelope.code !== 1000 || !envelope.data) {
      throw new ApiError('API returned an unsuccessful or incomplete envelope');
    }
    return envelope.data;
  }

  async function submit({ model = 'nano-banana-pro', prompt } = {}) {
    if (typeof model !== 'string' || !model.trim()) throw new Error('A model is required');
    if (typeof prompt !== 'string' || !prompt.trim()) throw new Error('A prompt is required');
    try {
      const data = await request('/generations', 'POST', {
        model, type: 'image', prompt, aspectRatio: '1:1', resolution: '1K',
      });
      // The public media contract returns a number, not the prefixed display ID.
      if (typeof data.taskId !== 'number') throw new Error('Missing numeric taskId');
      return parseTaskId(data.taskId);
    } catch (error) {
      // A timeout or malformed response does not prove that creation failed.
      throw new Error(`Submission not confirmed: ${error.message}. No automatic retry was made. Check task records before submitting again.`);
    }
  }

  async function poll(taskId) {
    const id = parseTaskId(taskId);
    const deadline = now() + pollTimeoutMs;
    let attempts = 0;
    let errors = 0;
    const timedOut = () => new Error(`Stopped waiting for task ${id}; it may still be running. Resume this ID later.`);
    while (now() < deadline) {
      let retryFloor = 0;
      let task;
      try {
        task = await request(`/tasks/${id}`, 'GET', undefined,
          Math.min(requestTimeoutMs, deadline - now()));
        errors = 0;
      } catch (error) {
        if (now() >= deadline) throw timedOut();
        if (!(error instanceof ApiError) || !error.transient) throw error;
        errors += 1;
        if (errors >= maxConsecutiveErrors) {
          throw new Error(`Stopped after ${errors} consecutive query errors for task ${id}; resume this ID later.`);
        }
        retryFloor = error.retryAfterMs;
      }
      if (now() >= deadline) throw timedOut();
      if (task) {
        if (task.taskId !== id) throw new Error('Task response ID does not match the requested task');
        if (task.status === 'failed') throw new Error(`Task ${id} failed; inspect its record before creating another task.`);
        if (task.status === 'ready') {
          if (!Array.isArray(task.images) || task.images.length === 0 ||
              !task.images.every(url => {
                try { return ['https:', 'http:'].includes(new URL(url).protocol); }
                catch { return false; }
              })) throw new Error(`Task ${id} is ready but has no valid image URLs`);
          return task.images;
        }
        if (!['pending', 'processing'].includes(task.status)) {
          throw new Error(`Task ${id} returned an unrecognized status; inspect its record.`);
        }
      }
      // Client policy, not a PixMind latency guarantee or server-side retry feature.
      const ceiling = Math.min(10_000, 1_000 * 2 ** Math.min(attempts++, 4));
      const delay = Math.max(retryFloor, ceiling * (0.5 + 0.5 * random()));
      const remaining = deadline - now();
      if (delay >= remaining) {
        // Never poll earlier than Retry-After just to fit the local deadline.
        await wait(Math.max(0, remaining));
        throw timedOut();
      }
      await wait(delay);
    }
    throw timedOut();
  }

  return { submit, poll };
}

export async function main(args = process.argv.slice(2), env = process.env, deps = {}) {
  const log = deps.log ?? console.log;
  const [mode, rawId] = args;
  if (!mode) {
    log('Usage: node examples/pixmind-image.mjs submit | resume TASK_ID');
    return;
  }
  if (!((mode === 'submit' && args.length === 1) || (mode === 'resume' && args.length === 2))) {
    throw new Error('Use submit, or resume followed by a numeric taskId');
  }
  const resumeId = mode === 'resume' ? parseTaskId(rawId) : undefined;
  const client = createClient({ ...deps, apiKey: env.PIXMIND_API_KEY });
  const id = resumeId ?? await client.submit({
    model: env.PIXMIND_MODEL || 'nano-banana-pro',
    prompt: env.PIXMIND_PROMPT || 'A studio photograph of an unbranded ceramic coffee cup on a plain background',
  });
  // Save this line in your application record before relying on the polling process.
  log(`TASK_ID=${id}`);
  log(`Resume without a new generation: node examples/pixmind-image.mjs resume ${id}`);
  const images = await client.poll(id);
  log(JSON.stringify({ taskId: id, images }, null, 2));
}

if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
  main().catch(error => { console.error(error.message); process.exitCode = 1; });
}

Per prima cosa, esamina l’interfaccia dei comandi senza inviare alcuna richiesta:

node examples/pixmind-image.mjs

Dopo aver controllato la chiave, i parametri del modello e l’addebito previsto, crea una sola attività:

node examples/pixmind-image.mjs submit

Quando la creazione riesce, il client mostra immediatamente TASK_ID, prima di attendere l’immagine. Copia il valore effettivo in un luogo privato. Questo esempio non lo salva in un file o in un database, quindi chiudendo il terminale potresti perdere il riferimento necessario per riprendere l’attività se non hai conservato l’output.

Per continuare a interrogare un’attività, sostituisci 12345 con quel valore salvato:

node examples/pixmind-image.mjs resume 12345

Questo comando esegue soltanto richieste GET sull’attività. Non legge un nuovo prompt e non crea un’altra immagine. Uno stato finale di successo dovrebbe produrre gli URL dei risultati della tua attività; qui non viene fornito alcun risultato di produzione inventato come benchmark.

L’esempio imposta un limite di 30 secondi per ogni richiesta HTTP e una scadenza di cinque minuti per il polling. I nuovi tentativi GET usano un’attesa esponenziale con una componente casuale, un limite locale di 10 secondi per tale attesa e, quando applicabile, un’intestazione di risposta Retry-After valida. Un’attesa più lunga richiesta dal server ha la precedenza; se non rientra nella scadenza locale, il client si ferma senza interrogare in anticipo. Il quinto errore GET transitorio consecutivo termina il tentativo complessivo, consentendo quattro nuovi tentativi in quella sequenza di errori. Questi valori sono impostazioni del client, non un accordo sul livello di servizio né una promessa che ogni immagine venga completata entro cinque minuti.

Scegli una politica di attesa complessiva adatta alla tua applicazione. Un lavoro di lunga durata può proseguire oltre una sessione del terminale o una richiesta web. In un servizio distribuito in produzione, salva l’ID attività insieme al tuo record del lavoro ed esponi un endpoint di stato separato per il browser, invece di obbligare l’utente a mantenere aperta un’unica connessione.

Gestisci gli errori senza duplicare i lavori a pagamento

Tratta l’incertezza sulla creazione in modo diverso da un’interrogazione di stato non riuscita. Puoi ripetere una GET di interrogazione dell’attività senza creare un’altra generazione. Una POST di creazione di cui si è persa la risposta potrebbe avere già avviato il lavoro; per questo l’esempio non la reinvia mai automaticamente.

Non dare per scontato che tutti gli errori abbiano la stessa struttura di risposta. Nella verifica in produzione del 4 settembre, GET /models senza autenticazione ha restituito HTTP 401 con i soli campi code e message; le risposte multimediali autenticate riuscite includevano anche data e timestamp. Questo tutorial, quindi, non promette la presenza di un requestId, di un flag retryable o di un campo prezzo in ogni risposta. Gli altri casi di errore elencati sopra descrivono la gestione da parte del client, non affermano che ciascuno sia stato riprodotto in produzione. Conserva lo stato HTTP e un messaggio applicativo ripulito dai dati sensibili, quando presente; tratta i corpi malformati come errori invece di causare un arresto all’interno di JSON.parse.

Un timeout del polling significa che il client ha smesso di attendere, non che l’attività remota sia stata annullata. Conserva l’ID e riprendi in seguito. Nemmeno uno stato sconosciuto dimostra il successo: questo client si ferma e lo segnala perché venga esaminato. Non passare mai a «completato» solo perché un valore non era previsto in un’istruzione switch.

Per risolvere i problemi, conserva ID attività, ID modello, operazione, stato HTTP e ora approssimativa. Evita di registrare intestazioni di autorizzazione o corpi completi delle richieste contenenti prompt privati. Prima di condividerli, controlla se i corpi delle risposte diagnostiche o gli URL dei risultati contengono informazioni sensibili.

Adatta il flusso a video e chat

Per i video puoi usare la stessa logica di invio e polling, ma servono una validazione della richiesta e una lettura del risultato specifiche. Controlla i contenuti multimediali di input richiesti dal modello video selezionato, la durata, la risoluzione e le opzioni audio, invece di riutilizzare per supposizione i campi del corpo della richiesta di immagini. Un video completato usa data.videoUrl, non data.images.

La guida a Video Agent spiega un flusso creativo interattivo. Può aiutarti a definire l’inquadratura desiderata prima di automatizzare la generazione, ma la presenza di una funzionalità Agent non prova che esista un parametro API con lo stesso nome.

La chat segue un percorso di integrazione separato. La route documentata /chat/completions è compatibile con OpenAI e restituisce una risposta di chat, oppure un flusso quando viene richiesto lo streaming. Non passare quella risposta al parser di data.taskId del client per immagini. Lo stesso URL di base non implica la stessa struttura di risposta per ogni endpoint.

Mantieni circoscritto il client per immagini finché quel percorso non è verificato. Aggiungi separatamente un adattatore video o un client chat, con test per la rispettiva struttura di risposta. Questa separazione è più facile da comprendere rispetto a un’unica funzione che cerca di indovinare se l’oggetto restituito sia un’attività immagine, un’attività video o un messaggio di chat.

Verifica l’integrazione e scegli il passaggio successivo

I test locali con risposte simulate controllano il comportamento del client senza consumare il saldo API. La suite allegata ha superato 29 test nell’ambiente Windows e Node.js indicato, inclusi il percorso di invio con una sola POST, la ripresa con sole GET, le risposte malformate, il fallimento finale, le scadenze e i limiti dei nuovi tentativi. Salva il file di test allegato accanto al sorgente del client, quindi esegui la suite dalla cartella del tutorial:

node --test examples/pixmind-image.test.mjs

I test con risposte simulate non dimostrano la disponibilità in produzione né le modalità di fatturazione. Una verifica controllata separata, eseguita il 4 settembre 2026, ha usato lo stesso client con il seguente ambito documentato:

La verifica ha usato una chiave API di progetto già esistente, un prompt privo di dati sensibili, nessun caricamento di riferimenti e nessun nuovo tentativo automatico di creazione. La voce del registro contabile è stata associata all’ID attività, non dedotta dalla visualizzazione di un saldo Studio. Sono stati provati dal vivo soltanto questa configurazione e il percorso riuscito di generazione di un’immagine; non sono stati provati video, chat, addebiti in caso di errore, rimborsi o affidabilità su esecuzioni ripetute. Controlla di nuovo il prezzo prima di inviare la tua richiesta, invece di trattare questo addebito storico come un preventivo permanente.

Prima di collegare l’esempio a un flusso di lavoro reale rivolto agli utenti, verifica che:

• La chiave rimanga sul server e sia assente da bundle del client, schermate e log pubblici.
• Il modello selezionato e ogni parametro siano supportati dall’offerta API attuale.
• Un invio accettato ti lasci un ID attività numerico recuperabile.
• resume non effettui alcuna POST di creazione, neppure dopo errori transitori di interrogazione.
• Un’attività fallita, un risultato vuoto e un timeout locale producano esiti diagnostici diversi.
• La perdita di una risposta di creazione non provochi un secondo invio automatico.

Per la tua verifica controllata dal vivo, registra account, modello, limiti di spesa approvati, richiesta ripulita dai dati sensibili, ID attività, risposta finale e voce di fatturazione effettiva. Ispeziona il risultato separatamente dalla verifica dell’esistenza del suo URL. Non eseguire ripetuti «smoke test» senza considerare che ogni nuovo invio può creare un lavoro a pagamento.

Quando sei pronto, crea una chiave API e scegli un solo metodo di invio. Parti dal flusso basato sull’attività salvata prima di aggiungere code, caricamenti o elaborazione in batch. Se il tuo prossimo passaggio è integrare i contenuti generati in un processo di revisione creativa, il flusso di lavoro per annunci di prodotto con Canvas offre un esempio separato guidato da una persona; non promette che i progetti Canvas possano essere eseguiti tramite questa API.

Responsabilità editoriale: PixMind Editorial Team è la firma dell’organizzazione per questo tutorial. Le sue basi documentali sono la documentazione ufficiale, l’implementazione del controller multimediale del progetto, 29 test locali con risposte simulate e la singola verifica in produzione descritta sopra, tutti esaminati il 4 settembre 2026. I registri delle attività e della fatturazione, ripuliti dai dati sensibili, sono conservati per la verifica editoriale. Non si rivendicano qualifiche di singoli ingegneri, risultati comparativi sulla qualità dei modelli o benchmark delle prestazioni.

Video Wan 3.0: guida completa a input, audio, prezzi e API