Hurtigstart for PixMind API: Generer bilder med Node.js

En godtatt forespørsel om bildegenerering er ikke et ferdig bilde. Applikasjonen må ta vare på oppgave-ID-en, sjekke den samme oppgaven og håndtere mislykkede eller avbrutte forespørsler uten å starte en ny oppgave ved et uhell.

I denne veiledningen lager du en liten Node.js-klient på serversiden for denne prosessen. Den har separate kommandoer for submit og resume: Den ene oppretter en oppgave, mens den andre bare sjekker en eksisterende oppgave. Ta utgangspunkt i modell-ID-ene som støttes av API-et, ikke et modellnavn kopiert fra et banner på forsiden.

Veiledningen dekker generering av bilder fra tekst. Den laster ikke opp referansefiler, implementerer ikke et nettlesergrensesnitt og måler ikke modellkvalitet. Valideringen kombinerer 29 lokale tester med simulerte svar og én kontrollert bildeoppgave i produksjon 4. september 2026. Denne oppgaven returnerte ett bilde og registrerte en API-belastning på 120 poeng. Dette er én datert integrasjonssjekk, ikke en hastighetstest, en universell pris eller en garanti for tilgjengelighet for en annen konto.

Forsidebildet er et skjermbilde av modellkatalogen tatt 4. september 2026. Betrakt det som en datert illustrasjon, ikke et gjeldende pristilbud eller en garanti for tilgjengelighet.

Viktige punkter

• Oppbevar API-nøkkelen på serveren, utenfor kodepakker til nettleseren og offentlige kodearkiver.
• For en bildeoppgave leser du den numeriske data.taskId fra det godtatte svaret og tar vare på den til senere spørringer.
• Hent status for den lagrede oppgaven til den når ready eller failed. Les bilde-URL-er fra data.images først når oppgaven er fullført uten feil.
• Et tidsavbrudd i klienten fastslår ikke at den eksterne oppgaven mislyktes eller ble avbrutt. Gjenoppta spørringene når du har en oppgave-ID; ikke gjenta opprettelsesforespørselen ukritisk.

I denne veiledningen

• Før du begynner
• Velg en modell og konfigurer API-nøkkelen
• Send inn med cURL
• Hent oppgavestatus og les bilde-URL-er
• Komplett Node.js-eksempel
• Håndter feil
• Forskjeller for video og chat
• Kontroller integrasjonen

Før du begynner

Bruk en privat terminal eller et servermiljø med Node.js, en API-nøkkel og en konto som er konfigurert for API-fakturering. Det medfølgende eksemplet bruker innebygd fetch og JavaScript-moduler, uten installasjon av tredjepartspakker. Nodes dokumentasjon for globale API-er beskriver fetch og AbortSignal.timeout, som klienten bruker til å begrense varigheten av en enkelt forespørsel. Det lokale valideringsmiljøet er Windows med Node.js v22.22.1; dette beskriver testmiljøet og betyr ikke at alle andre versjoner er testet.

Du bør være komfortabel med å redigere en fil, sette en miljøvariabel og lese JSON. Sjekk den installerte kjøretidsversjonen før du fortsetter:

node --version

Kommandoen skal skrive ut den installerte versjonen. Den kontakter ikke genererings-API-et. Lagre den komplette klienten fra avsnittet lenger ned som examples/pixmind-image.mjs i en arbeidsmappe, og kjør deretter kommandoene fra denne mappen.

Velg en harmløs testprompt uten kundedata eller konfidensielt innhold. Denne veiledningen bruker en kaffekopp av keramikk mot en studiobakgrunn og trenger derfor ingen opplasting av referansefiler. Se gjennom den valgte modellens gjeldende API-pris før du sender inn forespørselen. Du bør ikke anta at Studio-kreditter, abonnementer og API-fakturering kan brukes om hverandre; modellkatalogen forklarer det aktuelle API-tilbudet.

Hvis du bare vil lage et bilde interaktivt, beskriver veiledningen til Image Agent denne arbeidsflyten. Klienten her er for en applikasjon som oppgir en modell-ID eksplisitt og håndterer svaret selv.

Velg en modell og konfigurer API-nøkkelen

Bruk en modell-ID som API-et støtter, og parametere som støttes av denne modellen. Eksemplet velger nano-banana-pro, med aspectRatio: "1:1" og resolution: "1K", i samsvar med bildeforespørselen i API-hurtigstarten. Et autentisert GET /models og produksjonstesten bekreftet denne kombinasjonen for testkontoen 4. september 2026. Sjekk tilgjengeligheten og parameterstøtten på nytt for din egen konto før du kjører mot produksjon. Å endre bare modellstrengen er ikke nok til å garantere at resten av forespørselen fortsatt er gyldig.

Opprett en nøkkel i API-konsollen, og gjør den tilgjengelig for serverprosessen som PIXMIND_API_KEY. Bruk din private løsning for hemmelighetshåndtering når du har en slik løsning. Eksemplene nedenfor viser syntaks for miljøvariabler med en plassholder, ikke en gyldig legitimasjonsopplysning.

For 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"

For 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"

Disse tilordningene konfigurerer det gjeldende skallet og prosesser som startes fra det. De oppretter ingen oppgave. Beskytt skallhistorikk og opptak når du oppgir en ekte hemmelighet, og legg aldri denne hemmeligheten inn i versjonskontroll. Følg veiledningen om autentisering for separate utviklings- og produksjonsnøkler og rotasjon etter eksponering.

Basis-URL-en i denne veiledningen er:

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

Legg til /generations eller /tasks/{taskId} etter denne basisadressen. Ikke legg til enda en /v1. Du kan finne modeller via GET /models; katalogen er et mer praktisk sted å lese om modellspesifikke muligheter før du velger parametere.

Send inn din første forespørsel om bildegenerering med cURL

cURL-forespørselen er et alternativ til Node.js-kommandoen submit, ikke et oppsettstrinn du må kjøre først. Begge sender inn en genereringsforespørsel. Å kjøre begge kan opprette to fakturerbare oppgaver. Hvis du sender inn med cURL, bruker du Node.js-kommandoen resume etterpå med oppgave-ID-en du får tilbake.

Dette eksemplet bruker Bash-syntaks. I PowerShell bruker du Node.js-klienten nedenfor i stedet for å lime inn Bash-linjefortsettelser i terminalen.

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"
  }'

Prompten og parameterne i denne cURL-forespørselskroppen er bokstavelige verdier. Å endre PIXMIND_PROMPT endrer ikke denne JSON-koden; miljøvariabelen leses av Node.js-klienten. Dette skillet hjelper deg med å holde forespørselen du vil sende, atskilt fra skallkonfigurasjonen rundt den.

Nedenfor vises et forkortet, illustrerende svar på en godtatt forespørsel. ID-en er en plassholder, ikke ID-en fra produksjonstesten; 12345 er ikke en oppgave du skal spørre etter.

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

De testede mediesvarene fra produksjon pakket vellykkede data inn i et objekt med code, message, data og timestamp; illustrasjonen utelater tidsstempelet og andre felt. I denne arbeidsflyten krever et vellykket resultat både et vellykket HTTP-svar og et gyldig applikasjonssvar. Les data.taskId, ikke data.id: Sistnevnte kan inneholde en streng med prefiks, for eksempel img_12345, mens oppgavespørringens sti bruker den numeriske ID-en.

Lagre den numeriske ID-en med en gang. Hvis forespørselen får tidsavbrudd før du mottar den, stopper du og avklarer hva som skjedde med innsendingen ved hjelp av kontoens oppgaveregistreringer eller kundestøtte. Å gjenta POST er ikke et trygt alternativ til å finne ut hva som skjedde.

Hent oppgavestatus og les bilde-URL-ene

Spør etter den eksisterende oppgaven til den når en sluttilstand. Dokumentasjonen om asynkrone oppgaver beskriver pending, processing, ready og failed. Bare de to siste avslutter denne pollingen av oppgavestatus.

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

For en manuell spørring i Bash erstatter du plassholder-ID-en med din egen:

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"

I det gjeldende formatet for mediesvar har feltene du trenger, ulike oppgaver:

Et ready-svar uten brukbare bilde-URL-er er ikke et vellykket bilderesultat for applikasjonen din. Synliggjør dette avviket sammen med oppgave-ID-en, slik at det kan undersøkes. Ikke sett inn en eksempel-URL eller rapporter at et bilde ble lastet ned.

Klienten skriver ut bilde-URL-ene den får tilbake; den henter eller arkiverer ikke bildefilene. Hvis applikasjonen trenger varig lagring, må du utforme det som et separat trinn og bekrefte de relevante vilkårene for lagring og bruk av ressursene. Ikke tolk tilstedeværelsen av en URL som en garanti for permanent lagring.

Kjør det komplette Node.js-eksemplet

Bruk submit for én ny oppgave, eller resume for en eksisterende oppgave. Hvis du kjører skriptet uten argumenter, skriver det ut bruksanvisningen og gjør ingen API-kall. Denne standardoppførselen hindrer at en vanlig omstart eller en rask titt på kommandolinjegrensesnittet oppretter en ny oppgave.

Lagre hele kildekoden nedenfor som 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; });
}

Se først på kommandogrensesnittet uten å sende inn noe:

node examples/pixmind-image.mjs

Etter at du har sjekket nøkkelen, modellparameterne og forventet belastning, oppretter du én oppgave:

node examples/pixmind-image.mjs submit

Når opprettelsen lykkes, skriver klienten ut TASK_ID umiddelbart, før den venter på bildet. Kopier den faktiske verdien til et privat sted. Dette eksemplet lagrer den ikke i en fil eller database, så du kan miste referansen du trenger for å gjenoppta arbeidet hvis du lukker terminalen uten å ha lagret utdataene.

For å fortsette å spørre etter en oppgave erstatter du 12345 med den lagrede verdien:

node examples/pixmind-image.mjs resume 12345

Denne kommandoen utfører bare GET-forespørsler for oppgaver. Den leser ikke en ny prompt og oppretter ikke et nytt bilde. En vellykket sluttilstand skal gi resultat-URL-er for din egen oppgave; her oppgis ingen oppdiktede produksjonsresultater som sammenligningsgrunnlag.

Eksemplet bruker en grense på 30 sekunder per HTTP-forespørsel og en tidsfrist på fem minutter for polling av oppgavestatus. Nye GET-forsøk bruker eksponentielt økende ventetid med tilfeldig variasjon, en lokal maksimal ventetid på 10 sekunder og en gyldig Retry-After-svarheader når det er aktuelt. En lengre ventetid angitt av serveren har forrang; hvis den ikke får plass innenfor den lokale tidsfristen, stopper klienten uten å spørre for tidlig. Den femte midlertidige GET-feilen på rad avslutter forsøket, slik at det tillates fire nye forsøk i denne feilrekken. Disse verdiene er klientinnstillinger, ikke en tjenestenivåavtale eller et løfte om at alle bilder blir ferdige innen fem minutter.

Velg en samlet ventepolicy som passer applikasjonen. En langvarig oppgave kan fortsette etter at en terminaløkt eller nettforespørsel er avsluttet. I en utrullet tjeneste bør du lagre oppgave-ID-en sammen med din egen oppgaveregistrering og tilby nettleseren et separat statusendepunkt, i stedet for å kreve at brukeren holder én tilkobling åpen.

Håndter feil uten å opprette betalte oppgaver flere ganger

Behandle usikkerhet om opprettelse annerledes enn en mislykket statusspørring. En GET-spørring for en oppgave kan gjentas uten å opprette en ny generering. En POST-forespørsel for opprettelse der svaret gikk tapt, kan allerede ha satt i gang arbeidet, så eksemplet sender den aldri på nytt automatisk.

Ikke anta at alle feil har samme svarstruktur. I produksjonssjekken 4. september returnerte GET /models uten autentisering HTTP 401 med bare code og message; vellykkede, autentiserte mediesvar inneholdt også data og timestamp. Denne veiledningen lover derfor ikke at hvert svar inneholder en requestId, et retryable-flagg eller et prisfelt. De andre feiltilfellene ovenfor beskriver klienthåndtering, ikke at hvert tilfelle ble gjenskapt i produksjon. Ta vare på HTTP-statusen og en applikasjonsmelding renset for sensitiv informasjon når den finnes; behandle feilformede svarkropper som feil i stedet for å krasje inne i JSON.parse.

Et tidsavbrudd under polling betyr at klienten sluttet å vente, ikke at den eksterne oppgaven ble avbrutt. Ta vare på ID-en og fortsett senere. En ukjent status er heller ikke bevis på et vellykket resultat: Denne klienten stopper og rapporterer den for nærmere undersøkelse. La aldri programmet ende på «fullført» fordi en verdi manglet i en switch-setning.

For feilsøking bør du ta vare på oppgave-ID, modell-ID, operasjon, HTTP-status og omtrentlig tidspunkt. Unngå å registrere autorisasjonsheadere eller hele forespørselskropper som inneholder private prompter. Sjekk om diagnostiske svarkropper eller resultat-URL-er inneholder sensitiv informasjon før du deler dem.

Tilpass mønsteret til video og chat

Video kan bruke den samme ideen med innsending og polling, men trenger sin egen validering av forespørsler og lesing av resultater. Sjekk den valgte videomodellens krav til inndatamedier, varighet, oppløsning og lydalternativer i stedet for å anta at du kan gjenbruke feltene fra bildeforespørselen. En fullført video bruker data.videoUrl, ikke data.images.

Veiledningen til Video Agent forklarer en interaktiv kreativ arbeidsflyt. Den kan hjelpe deg med å definere det ønskede opptaket før du automatiserer genereringen, men en Agent-funksjon er ikke bevis på at det finnes en API-parameter med samme navn.

Chat er en separat integrasjonsvei. Den dokumenterte ruten /chat/completions er OpenAI-kompatibel og returnerer et chatsvar, eller en strøm når strømming er forespurt. Ikke send dette svaret til bildeklientens parser for data.taskId. Den samme basis-URL-en betyr ikke at alle endepunkter har samme svarstruktur.

Hold bildeklienten avgrenset til dette formålet til denne integrasjonsveien er verifisert. Legg til en videoadapter eller chatklient separat, med tester for dens egen svarstruktur. Dette skillet er enklere å forstå enn én funksjon som gjetter om et returnert objekt er en bildeoppgave, en videooppgave eller en chatmelding.

Kontroller integrasjonen og velg neste steg

Lokale tester med simulerte svar sjekker klientens oppførsel uten å bruke API-saldo. Den medfølgende testpakken bestod 29 tester i det oppgitte Windows- og Node.js-miljøet, inkludert innsending med én POST, gjenopptakelse med bare GET, feilformede svar, endelig oppgavefeil, tidsfrister og grenser for nye forsøk. Lagre den medfølgende testfilen ved siden av klientens kildekode, og kjør deretter testpakken fra veiledningens mappe:

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

Tester med simulerte svar fastslår ikke tilgjengelighet eller fakturering i produksjon. En separat kontrollert sjekk 4. september 2026 brukte den samme klienten med følgende registrerte omfang:

Sjekken brukte én eksisterende API-nøkkel for prosjektet, en prompt uten sensitiv informasjon, ingen opplasting av referansefiler og ingen automatisk gjentakelse av opprettelsen. Transaksjonen ble koblet til oppgave-ID-en, ikke utledet fra en saldovisning i Studio. Bare denne ene konfigurasjonen og det vellykkede bildeforløpet ble testet mot produksjon; video, chat, fakturering ved feil, refusjoner og pålitelighet ved gjentatte kjøringer ble ikke testet. Sjekk prisen på nytt før din egen innsending, i stedet for å behandle denne historiske belastningen som et stående pristilbud.

Før du kobler eksemplet til en reell brukervendt arbeidsflyt, må du sjekke at:

• Nøkkelen blir på serveren og ikke finnes i klientpakker, skjermbilder eller offentlige logger.
• Den valgte modellen og hver parameter støttes av det gjeldende API-tilbudet.
• En godtatt innsending gir deg en numerisk oppgave-ID som du kan finne igjen.
• resume ikke utfører noen POST for opprettelse, heller ikke etter midlertidige spørringsfeil.
• En oppgavefeil, et tomt resultat og et lokalt tidsavbrudd gir ulike diagnostiske utfall.
• Et tapt opprettelsessvar ikke utløser en automatisk andre innsending.

Ved din egen kontrollerte sjekk mot produksjon registrerer du kontoen, modellen, den godkjente kostnadsrammen, forespørselen renset for sensitiv informasjon, oppgave-ID-en, svaret med sluttilstanden og den faktiske faktureringstransaksjonen. Kontroller selve resultatet separat fra å sjekke at URL-en finnes. Ikke kjør gjentatte «røyktester» uten å ta hensyn til at hver ny innsending kan opprette betalt arbeid.

Når du er klar, oppretter du en API-nøkkel og velger én innsendingsmetode. Bygg videre på arbeidsflyten med lagrede oppgaver før du legger til køer, opplastinger eller satsvis behandling. Hvis neste steg er å integrere genererte ressurser i en kreativ gjennomgangsprosess, gir arbeidsflyten for produktannonser i Canvas et separat, menneskestyrt eksempel; den er ikke et løfte om at Canvas-prosjekter kan kjøres gjennom dette API-et.

Redaksjonelt ansvar: PixMind Editorial Team er organisasjonsnavnet som står som forfatter av denne veiledningen. Dokumentasjonsgrunnlaget er offisiell dokumentasjon, prosjektets implementasjon av mediekontrolleren, 29 lokale tester med simulerte svar og den ene produksjonssjekken beskrevet ovenfor, alt gjennomgått 4. september 2026. Oppgave- og faktureringsregistreringer renset for sensitiv informasjon oppbevares for redaksjonell verifisering. Det fremsettes ingen påstander om kvalifikasjonene til en enkelt ingeniør, sammenlignende modellkvalitetsresultater eller ytelsesmålinger.

Wan 3.0-video: komplett guide til inndata, lyd, priser og API