PixMind API: Hurtig start med billedgenerering i Node.js

En accepteret anmodning om billedgenerering er ikke det samme som et færdigt billede. Din applikation skal gemme opgave-id'et, kontrollere den samme opgave og håndtere mislykkede eller afbrudte anmodninger uden utilsigtet at starte en ny opgave.

I denne vejledning bygger vi en lille Node.js-klient på serversiden til netop det forløb. Den har separate kommandoer, submit og resume: Den ene opretter en opgave, mens den anden kun kontrollerer en eksisterende opgave. Tag udgangspunkt i de model-id'er, som API'et understøtter, ikke et modelnavn kopieret fra et banner på forsiden.

Vejledningen handler om at generere billeder fra tekst. Den omfatter ikke upload af referencefiler, en brugergrænseflade i browseren eller måling af modelkvalitet. Valideringen kombinerer 29 lokale mocktests med én kontrolleret billedopgave i produktionsmiljøet den 4. september 2026. Opgaven returnerede ét billede, og der blev registreret en API-debitering på 120 point. Det er én integrationskontrol på en bestemt dato, ikke en hastighedstest, en universel pris eller en garanti for tilgængelighed på en anden konto.

Forsidebilledet er et skærmbillede af modelkataloget fra den 4. september 2026. Betragt det som en illustration fra den dato, ikke som et aktuelt pristilbud eller en garanti for tilgængelighed.

Det vigtigste kort fortalt

• Opbevar API-nøglen på serveren, uden for kodepakker til browseren og offentlige kodearkiver.
• Ved en billedopgave skal du læse det numeriske data.taskId fra det accepterede svar og gemme det til senere forespørgsler.
• Send statusforespørgsler for den gemte opgave, indtil status er ready eller failed. Læs først billed-URL'erne fra data.images, når opgaven er lykkedes.
• En timeout i klienten dokumenterer ikke, at opgaven på serveren er mislykkedes eller er blevet annulleret. Genoptag forespørgslerne, hvis du har et opgave-id; gentag ikke oprettelsesanmodningen i blinde.

I denne vejledning

• Før du går i gang
• Vælg en model, og konfigurér din API-nøgle
• Send en anmodning med cURL
• Hent opgavens status og billed-URL'er
• Komplet Node.js-eksempel
• Håndtér fejl
• Forskelle ved video og chat
• Kontrollér din integration

Før du går i gang

Brug et privat terminal- eller servermiljø med Node.js, en API-nøgle og en konto, der er konfigureret til API-afregning. Det tilhørende eksempel bruger den indbyggede fetch og JavaScript-moduler, så du ikke behøver at installere tredjepartspakker. Nodes dokumentation for globale API'er beskriver fetch og AbortSignal.timeout, som klienten bruger til at sætte en tidsgrænse for den enkelte anmodning. Den lokale validering er udført på Windows med Node.js v22.22.1; det dokumenterer testmiljøet og betyder ikke, at alle andre versioner er blevet testet.

Du skal være fortrolig med at redigere en fil, indstille en miljøvariabel og læse JSON. Kontrollér din installerede Node.js-version, før du fortsætter:

node --version

Kommandoen bør udskrive den installerede version. Den kontakter ikke genererings-API'et. Gem den komplette klient fra afsnittet længere nede som examples/pixmind-image.mjs i en arbejdsmappe, og kør derefter kommandoerne fra den mappe.

Vælg en harmløs testprompt uden kundedata eller fortroligt materiale. Denne vejledning bruger en kaffekop i keramik på en studiebaggrund, så det er ikke nødvendigt at uploade referencefiler. Kontrollér den valgte models aktuelle API-pris, før du sender anmodningen. Du bør ikke antage, at Studio-kreditter, abonnementer og API-afregning kan bruges i stedet for hinanden; modelkataloget beskriver det relevante API-tilbud.

Hvis du blot vil skabe et billede interaktivt, beskriver vejledningen til Image Agent det arbejdsforløb. Klienten her er beregnet til en applikation, der udtrykkeligt angiver et model-id og selv håndterer svaret.

Vælg en model, og konfigurér din API-nøgle

Brug et model-id, som API'et understøtter, og parametre, som den pågældende model understøtter. Eksemplet vælger nano-banana-pro med aspectRatio: "1:1" og resolution: "1K", svarende til billedanmodningen i API-vejledningen til hurtig start. Et autentificeret kald til GET /models og produktionstesten bekræftede denne kombination for testkontoen den 4. september 2026. Kontrollér tilgængelighed og parameterunderstøttelse for din egen konto igen, før du foretager et rigtigt kald. At ændre modelnavnet alene garanterer ikke, at resten af anmodningen fortsat er gyldig.

Opret en nøgle i API-konsollen, og giv den derefter til serverprocessen som PIXMIND_API_KEY. Brug din private løsning til håndtering af hemmeligheder, hvis du har en. Følgende eksempler viser syntaksen for miljøvariabler med en pladsholder, ikke en fungerende nøgle.

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

Til 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 tildelinger konfigurerer den aktuelle kommandoskal og processer, der startes fra den. De opretter ikke en opgave. Beskyt kommandohistorik og optagelser, når du indtaster en rigtig hemmelighed, og læg aldrig hemmeligheden i versionsstyring. Følg vejledningen om autentificering om separate udviklings- og produktionsnøgler samt udskiftning af nøgler, der er blevet eksponeret.

Basis-URL'en i denne vejledning er:

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

Tilføj /generations eller /tasks/{taskId} til denne adresse. Tilføj ikke /v1 endnu en gang. Du kan hente modeloversigten med GET /models; kataloget er det mest praktiske sted at læse om de enkelte modellers funktioner, før du vælger parametre.

Send din første anmodning om billedgenerering med cURL

cURL-anmodningen er et alternativ til Node.js-kommandoen submit, ikke et opsætningstrin, du skal køre først. Begge sender en genereringsanmodning. Hvis du kører begge, kan du oprette to opgaver, der hver kan blive faktureret. Hvis du sender anmodningen med cURL, skal du bagefter bruge Node.js-kommandoen resume med det returnerede opgave-id.

Dette eksempel bruger Bash-syntaks. I PowerShell skal du bruge Node.js-klienten nedenfor i stedet for at indsætte Bash-linjefortsættelser 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 parametrene i denne cURL-anmodnings indhold er faste værdier. Ændringer af PIXMIND_PROMPT ændrer ikke denne JSON; miljøvariablen læses af Node.js-klienten. Denne skelnen gør det lettere at holde selve den anmodning, du vil sende, adskilt fra den omgivende konfiguration af kommandoskallen.

Nedenfor ses et forkortet, illustrativt eksempel på et accepteret svar. Id'et er en pladsholder og ikke produktionstestens id; 12345 er ikke en opgave, du skal forespørge på.

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

I de testede mediesvar fra produktionsmiljøet var data fra vellykkede kald pakket ind i et objekt med code, message, data og timestamp; illustrationen udelader tidsstemplet og andre felter. I dette arbejdsforløb kræver succes både et vellykket HTTP-svar og et gyldigt applikationssvar. Læs data.taskId, ikke data.id: Sidstnævnte kan indeholde en streng med et præfiks såsom img_12345, mens stien til opgaveforespørgslen bruger det numeriske id.

Gem det numeriske id med det samme. Hvis anmodningen får timeout, før du modtager det, skal du stoppe og afklare, hvad der skete med indsendelsen, via kontoens opgavehistorik eller support. At gentage POST-anmodningen er ikke en sikker erstatning for at finde ud af, hvad der skete.

Hent opgavens status og billed-URL'er med statusforespørgsler

Forespørg på den eksisterende opgave, indtil den når en sluttilstand. Dokumentationen om asynkrone opgaver beskriver pending, processing, ready og failed. Kun de sidste to afslutter dette forløb med statusforespørgsler.

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

Ved en manuel forespørgsel i Bash skal du erstatte pladsholder-id'et med dit eget:

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 den aktuelle struktur for mediesvar har de relevante felter forskellige roller:

Et ready-svar uden brugbare billed-URL'er er ikke et vellykket billedresultat for din applikation. Vis denne uoverensstemmelse sammen med opgave-id'et, så den kan undersøges. Indsæt ikke en eksempel-URL som erstatning, og oplys ikke, at et billede er blevet downloadet.

Klienten udskriver de returnerede billed-URL'er; den henter eller arkiverer ikke billedfilerne. Hvis din applikation har brug for varig lagring, skal du designe det som et separat trin og kontrollere de relevante vilkår for opbevaring og brug af filer. En URL er ikke i sig selv en garanti for permanent lagring.

Kør det komplette Node.js-eksempel

Brug submit til én ny opgave eller resume til en eksisterende opgave. Hvis du kører scriptet uden argumenter, udskriver det en brugsvejledning og foretager ingen API-kald. Denne standardadfærd forhindrer, at en almindelig genstart eller et hurtigt kig på kommandolinjegrænsefladen opretter en ny opgave.

Gem 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; });
}

Undersøg først kommandogrænsefladen uden at sende noget:

node examples/pixmind-image.mjs

Når du har kontrolleret nøglen, modelparametrene og den forventede debitering, kan du oprette én opgave:

node examples/pixmind-image.mjs submit

Når oprettelsen lykkes, udskriver klienten straks TASK_ID, før den begynder at vente på billedet. Kopiér den faktiske værdi til et privat sted. Eksemplet gemmer den ikke i en fil eller database, så hvis du lukker terminalen uden at have gemt udskriften, kan du miste det id, du skal bruge til at genoptage forløbet.

Hvis du vil fortsætte med at forespørge på en opgave, skal du erstatte 12345 med den gemte værdi:

node examples/pixmind-image.mjs resume 12345

Denne kommando udfører kun GET-anmodninger for opgaven. Den læser ikke en ny prompt og opretter ikke et nyt billede. En vellykket sluttilstand bør give resultat-URL'er for din egen opgave; der leveres ikke opdigtede produktionsresultater her som sammenligningsgrundlag.

Eksemplet bruger en grænse på 30 sekunder pr. HTTP-anmodning og en samlet frist på fem minutter for statusforespørgslerne. Gentagne GET-forsøg bruger eksponentielt stigende ventetid med tilfældig variation, et lokalt loft på 10 sekunder for denne ventetid og en gyldig Retry-After-svarheader, når den er relevant. Hvis serveren kræver længere ventetid, har det forrang; kan ventetiden ikke rummes inden for den lokale frist, stopper klienten uden at forespørge for tidligt. Den femte midlertidige GET-fejl i træk afslutter forsøget, hvilket tillader fire genforsøg i den pågældende fejlserie. Disse værdier er klientindstillinger, ikke en serviceniveauaftale eller et løfte om, at alle billeder bliver færdige inden for fem minutter.

Vælg en samlet ventepolitik, der passer til din applikation. En langvarig opgave kan fortsætte længere end en terminalsession eller en webanmodning. I en tjeneste, der er sat i drift, bør du gemme opgave-id'et sammen med din egen opgaveregistrering og stille et separat statusendepunkt til rådighed for browseren i stedet for at kræve, at brugeren holder én forbindelse åben.

Håndtér fejl uden at oprette betalte opgaver dobbelt

Skeln mellem usikkerhed om oprettelsen og en mislykket statusforespørgsel. En GET-forespørgsel på en opgave kan gentages uden at oprette en ny generering. En POST-anmodning til oprettelse kan allerede have sat arbejdet i gang, selvom svaret er gået tabt, så eksemplet sender den aldrig automatisk igen.

Antag ikke, at alle fejl har samme svarstruktur. Ved produktionskontrollen den 4. september returnerede GET /models uden autentificering HTTP 401 med kun code og message; autentificerede, vellykkede mediesvar indeholdt også data og timestamp. Derfor lover denne vejledning ikke, at alle svar indeholder et requestId, et retryable-flag eller et prisfelt. De øvrige fejltilfælde ovenfor beskriver klientens håndtering og er ikke en påstand om, at hvert af dem blev reproduceret i produktionsmiljøet. Gem HTTP-statussen og en applikationsmeddelelse renset for følsomme oplysninger, hvis en sådan findes; behandl fejlformateret svarindhold som en fejl i stedet for at lade programmet bryde sammen inde i JSON.parse.

En timeout under statusforespørgsler betyder, at klienten holdt op med at vente, ikke at opgaven på serveren blev annulleret. Gem id'et, og genoptag senere. En ukendt status er heller ikke dokumentation for succes: Denne klient stopper og rapporterer den, så den kan undersøges. Lad aldrig en ukendt værdi blive behandlet som »fuldført«, blot fordi den ikke findes i en switch-sætning.

Til fejlfinding bør du gemme opgave-id, model-id, operation, HTTP-status og omtrentligt tidspunkt. Undgå at registrere autorisationsheadere eller hele anmodninger med private prompts. Kontrollér, om svarindhold til fejlfinding eller resultat-URL'er indeholder følsomme oplysninger, før du deler dem.

Tilpas fremgangsmåden til video og chat

Video kan bruge samme fremgangsmåde med indsendelse og efterfølgende statusforespørgsler, men kræver sin egen validering af anmodninger og sin egen læsning af resultater. Kontrollér den valgte videomodels krav til inputmedier, varighed, opløsning og lydmuligheder i stedet for at genbruge felterne fra billedanmodningen ud fra en antagelse. En færdig video bruger data.videoUrl, ikke data.images.

Vejledningen til Video Agent forklarer et interaktivt, kreativt arbejdsforløb. Den kan hjælpe dig med at definere den ønskede indstilling, før du automatiserer genereringen, men en Agent-funktion er ikke bevis for, at der findes en API-parameter med samme navn.

Chat er et separat integrationsforløb. Den dokumenterede /chat/completions-rute er OpenAI-kompatibel og returnerer et chatsvar eller en strøm, når der anmodes om streaming. Send ikke det svar ind i billedklientens parser til data.taskId. At endepunkterne har samme basis-URL, betyder ikke, at de har samme svarstruktur.

Hold billedklienten afgrænset, indtil dette forløb er verificeret. Tilføj en videoadapter eller chatklient separat, med tests af dens egen svarstruktur. Denne opdeling er lettere at gennemskue end én funktion, der gætter på, om et returneret objekt er en billedopgave, en videoopgave eller en chatbesked.

Kontrollér din integration, og vælg næste skridt

Lokale mocktests kontrollerer klientens adfærd uden at bruge af API-saldoen. Den tilhørende testsamling bestod 29 tests i det angivne Windows- og Node.js-miljø, herunder indsendelse med én POST-anmodning, genoptagelse udelukkende med GET, fejlformaterede svar, fejl som sluttilstand, tidsfrister og grænser for genforsøg. Gem den tilhørende testfil ved siden af klientens kildekode, og kør derefter testsamlingen fra vejledningens mappe:

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

Mocktests dokumenterer ikke tilgængelighed eller afregning i produktionsmiljøet. En separat, kontrolleret test den 4. september 2026 brugte den samme klient med følgende registrerede omfang:

Kontrollen brugte én eksisterende API-nøgle fra projektet, en prompt uden følsomme oplysninger, ingen referenceuploads og ingen automatisk gentagelse af oprettelsesanmodningen. Posteringen i transaktionsoversigten blev knyttet til opgave-id'et og ikke udledt af en saldovisning i Studio. Kun denne ene konfiguration og det vellykkede billedforløb blev testet i produktionsmiljøet; video, chat, afregning ved fejl, tilbagebetalinger og pålidelighed ved gentagne kørsler blev ikke testet. Kontrollér prisen igen, før du selv sender en anmodning, i stedet for at behandle denne historiske debitering som et stående pristilbud.

Før du kobler eksemplet til et reelt, brugerrettet arbejdsforløb, skal du kontrollere, at:

• Nøglen bliver på serveren og ikke findes i kodepakker til klienten, skærmbilleder eller offentlige logfiler.
• Den valgte model og hver enkelt parameter understøttes af det aktuelle API-tilbud.
• En accepteret indsendelse efterlader dig med et numerisk opgave-id, som du kan finde frem igen.
• resume ikke foretager nogen POST-anmodning til oprettelse, heller ikke efter midlertidige fejl i forespørgsler.
• En mislykket opgave, et tomt resultat og en lokal timeout giver forskellige diagnostiske resultater.
• Et mistet svar på oprettelsen ikke udløser en automatisk indsendelse nummer to.

Ved din egen kontrollerede test i produktionsmiljøet skal du registrere konto, model, godkendt omkostningsramme, anmodning renset for følsomme oplysninger, opgave-id, svar med sluttilstand og den faktiske afregningspost. Undersøg selve resultatet separat fra kontrollen af, at dets URL findes. Kør ikke gentagne »grundlæggende funktionstests« uden at tage højde for, at hver ny indsendelse kan oprette en betalt opgave.

Når du er klar, kan du oprette en API-nøgle og vælge én indsendelsesmetode. Byg videre på arbejdsforløbet med gemte opgaver, før du tilføjer køer, uploads eller batchbehandling. Hvis dit næste skridt er at integrere genererede filer i en kreativ gennemgangsproces, giver arbejdsforløbet for produktannoncer i Canvas et separat eksempel styret af mennesker; det er ikke et løfte om, at Canvas-projekter kan køres via dette API.

Redaktionelt ansvar: PixMind Editorial Team er den organisatoriske afsender af denne vejledning. Dokumentationsgrundlaget er officiel dokumentation, projektets mediecontroller-implementering, 29 lokale mocktests og den ene produktionskontrol beskrevet ovenfor, alt sammen gennemgået den 4. september 2026. Opgave- og afregningsoplysninger renset for følsomme data opbevares til redaktionel verifikation. Der fremsættes ingen påstande om en bestemt ingeniørs kvalifikationer, sammenlignende resultater for modelkvalitet eller målinger af ydeevne.

Wan 3.0-video: komplet guide til input, lyd, priser og API