Início rápido da API PixMind: gere imagens com Node.js

Um pedido de geração de imagens aceite pela API ainda não é uma imagem pronta. A aplicação precisa de guardar o ID da tarefa, consultar essa mesma tarefa e tratar pedidos falhados ou interrompidos sem iniciar outro trabalho por engano.

Este tutorial cria um pequeno cliente Node.js para executar essa sequência no servidor. Há comandos separados, submit e resume: um cria uma tarefa, enquanto o outro apenas consulta uma tarefa existente. Comece pelos IDs de modelos compatíveis com a API, não por um nome de modelo copiado de um destaque na página inicial.

O tutorial abrange a geração de imagens a partir de texto. Não envia ficheiros de referência, não implementa uma interface de navegador nem avalia a qualidade dos modelos. A validação combina 29 testes locais com respostas simuladas e uma tarefa controlada de geração de imagem em produção, realizada em 4 de setembro de 2026. Essa tarefa devolveu uma imagem e registou uma cobrança de 120 pontos na API. Trata-se de uma verificação de integração com data definida, não de um teste de velocidade, de um preço universal ou de uma garantia de disponibilidade para outra conta.

A capa é uma captura do catálogo de modelos feita em 4 de setembro de 2026. Considere-a uma ilustração datada, não uma cotação de preço atual nem uma garantia de disponibilidade.

Pontos principais

• Mantenha a chave de API no servidor, fora dos pacotes de código enviados ao navegador e dos repositórios públicos.
• Para uma tarefa de imagem, leia o valor numérico de data.taskId na resposta de aceitação e guarde-o para consultas futuras.
• Consulte periodicamente a tarefa guardada até obter ready ou failed. Leia os URLs das imagens em data.images apenas após o sucesso.
• O fim do tempo de espera do cliente não comprova que a tarefa remota falhou ou foi cancelada. Retome as consultas quando tiver um ID de tarefa; não repita o pedido de criação sem verificar o que aconteceu.

Neste guia

• Antes de começar
• Escolha um modelo e configure a chave de API
• Envie um pedido com cURL
• Consulte a tarefa e leia os URLs das imagens
• Exemplo completo em Node.js
• Trate os erros
• Diferenças para vídeo e chat
• Verifique a integração

Antes de começar

Use um terminal privado ou um ambiente de servidor com Node.js, uma chave de API e uma conta configurada para a faturação da API. O exemplo que acompanha o artigo usa o fetch integrado e módulos JavaScript, sem instalar pacotes de terceiros. A documentação das APIs globais do Node descreve fetch e AbortSignal.timeout, que o cliente usa para limitar a duração de cada pedido. O ambiente de validação local é Windows com Node.js v22.22.1; este é um registo do ambiente de teste, não uma afirmação de que todas as outras versões foram testadas.

É importante saber editar um ficheiro, definir uma variável de ambiente e ler JSON. Verifique a versão instalada antes de continuar:

node --version

O comando deve apresentar a versão instalada. Não contacta a API de geração. Guarde o cliente completo de uma secção posterior em examples/pixmind-image.mjs, dentro de uma pasta de trabalho, e execute os comandos a partir dessa pasta.

Escolha um prompt de teste inofensivo, sem dados de clientes nem material confidencial. Este tutorial usa uma chávena de café de cerâmica sobre um fundo de estúdio, por isso não precisa de enviar referências. Consulte o preço atual do modelo selecionado na API antes de enviar o pedido. Não presuma que os créditos do Studio, as subscrições e a faturação da API são intercambiáveis; o catálogo de modelos explica a oferta de API aplicável.

Se pretende apenas criar uma imagem de forma interativa, o guia do Image Agent descreve esse processo. O cliente apresentado aqui destina-se a uma aplicação que fornece explicitamente um ID de modelo e trata a resposta por conta própria.

Escolha um modelo e configure a chave de API

Use um ID de modelo compatível com a API e parâmetros suportados por esse modelo. O exemplo seleciona nano-banana-pro, com aspectRatio: "1:1" e resolution: "1K", correspondendo ao pedido de imagem no guia de início rápido da API. Um pedido autenticado a GET /models e o teste em produção confirmaram essa combinação para a conta de teste em 4 de setembro de 2026. Volte a verificar a disponibilidade e o suporte dos parâmetros na sua conta antes de uma execução real. Alterar apenas o texto do modelo não garante que o restante pedido continue válido.

Crie uma chave na consola da API e forneça-a ao processo do servidor como PIXMIND_API_KEY. Use um mecanismo privado de gestão de segredos, quando disponível. Os exemplos seguintes mostram a sintaxe das variáveis de ambiente com um valor de substituição, não uma credencial funcional.

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

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

Estas atribuições configuram a sessão de shell atual e os processos iniciados a partir dela. Não criam uma tarefa. Proteja o histórico da shell e as gravações ao introduzir um segredo real, e nunca inclua esse segredo no controlo de versões. Siga as orientações de autenticação para usar chaves separadas de desenvolvimento e produção e substituí-las após uma exposição.

O URL base deste tutorial é:

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

Acrescente /generations ou /tasks/{taskId} a essa base. Não acrescente um segundo /v1. A descoberta de modelos está disponível através de GET /models; o catálogo é o local mais conveniente para consultar as capacidades de cada modelo antes de escolher os parâmetros.

Envie o primeiro pedido de imagem com cURL

O pedido cURL é uma alternativa ao comando submit do Node.js, não um passo de configuração que seja necessário executar primeiro. Ambos enviam um pedido de geração. Executar os dois pode criar duas tarefas sujeitas a cobrança. Se enviar o pedido com cURL, use depois o comando resume do Node.js com o ID de tarefa devolvido.

Este exemplo usa sintaxe Bash. Em PowerShell, use o cliente Node.js abaixo em vez de colar no terminal as continuações de linha de 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"
  }'

O prompt e os parâmetros neste corpo cURL são valores literais. Alterar PIXMIND_PROMPT não altera este JSON; essa variável de ambiente é lida pelo cliente Node.js. Esta distinção ajuda a separar o pedido que pretende enviar da configuração da shell que o envolve.

Abaixo encontra-se uma resposta de aceitação ilustrativa e abreviada. O ID é um valor de exemplo, não o ID do teste em produção; 12345 não é uma tarefa que deva consultar.

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

As respostas de conteúdos multimédia testadas em produção incluíam os dados de sucesso num objeto com code, message, data e timestamp; a ilustração omite o carimbo de data e hora e outros campos. Neste processo, o sucesso exige uma resposta HTTP bem-sucedida e uma resposta válida da aplicação. Leia data.taskId, não data.id: este último pode conter uma cadeia com prefixo, como img_12345, enquanto o caminho de consulta da tarefa usa o ID numérico.

Guarde esse ID numérico imediatamente. Se o tempo de espera do pedido terminar antes de o receber, pare e confirme o envio nos registos de tarefas da conta ou junto do suporte. Repetir o POST não é uma alternativa segura a descobrir o que aconteceu.

Faça a consulta periódica da tarefa e leia os URLs das imagens

Consulte a tarefa existente até atingir um estado final. A documentação de tarefas assíncronas descreve pending, processing, ready e failed. Apenas os dois últimos encerram este processo de consulta periódica.

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

Para uma consulta manual em Bash, substitua o ID de exemplo pelo seu:

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"

No contrato atual das respostas de conteúdos multimédia, os campos necessários têm funções diferentes:

Uma resposta ready sem URLs de imagem utilizáveis não representa um resultado de imagem bem-sucedido para a aplicação. Apresente essa incompatibilidade com o ID da tarefa para que seja possível investigá-la. Não a substitua por um URL de exemplo nem indique que uma imagem foi transferida.

O cliente apresenta os URLs das imagens devolvidos; não transfere nem arquiva os ficheiros de imagem. Se a aplicação precisar de armazenamento duradouro, conceba essa funcionalidade como um passo separado e confirme os termos relevantes de retenção e utilização dos conteúdos. A presença de um URL não permite concluir que existe uma garantia de armazenamento permanente.

Execute o exemplo completo em Node.js

Use submit para uma nova tarefa ou resume para uma tarefa existente. Executar o script sem argumentos apresenta as instruções de utilização e não faz qualquer chamada à API. Este comportamento predefinido impede que um reinício normal ou uma consulta rápida da interface de linha de comandos crie uma nova tarefa.

Guarde o código completo abaixo como 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; });
}

Comece por consultar a interface de comandos sem enviar qualquer pedido:

node examples/pixmind-image.mjs

Depois de verificar a chave, os parâmetros do modelo e a cobrança prevista, crie uma tarefa:

node examples/pixmind-image.mjs submit

Quando a criação é bem-sucedida, o cliente apresenta TASK_ID imediatamente, antes de esperar pela imagem. Copie o valor real para um local privado. Este exemplo não o guarda num ficheiro nem numa base de dados; por isso, fechar o terminal pode fazer perder a referência de recuperação se não tiver guardado a saída.

Para continuar a consultar uma tarefa, substitua 12345 pelo valor guardado:

node examples/pixmind-image.mjs resume 12345

Este comando executa apenas pedidos GET de consulta da tarefa. Não lê um novo prompt nem cria outra imagem. Um estado final bem-sucedido deve produzir URLs de saída da sua própria tarefa; não se apresenta aqui qualquer resultado de produção inventado como referência de desempenho.

O exemplo usa um limite de 30 segundos por pedido HTTP e um prazo de cinco minutos para a consulta periódica. As novas tentativas de GET usam intervalos de espera exponenciais com variação aleatória, um limite local de espera de 10 segundos e um cabeçalho de resposta Retry-After válido, quando aplicável. Uma espera mais longa solicitada pelo servidor tem prioridade; se não couber no prazo local, o cliente para sem consultar antecipadamente. O quinto erro transitório consecutivo de GET encerra a tentativa, permitindo quatro repetições nessa sequência de erros. Estes valores são configurações do cliente, não um acordo de nível de serviço nem uma promessa de que todas as imagens ficam prontas em cinco minutos.

Escolha uma política de tempo total de espera adequada à aplicação. Uma tarefa demorada pode continuar para além de uma sessão de terminal ou de um pedido web. Num serviço em produção, guarde o ID da tarefa no seu próprio registo de trabalho e disponibilize ao navegador um endpoint separado para consultar o estado, em vez de obrigar a pessoa a manter uma ligação aberta.

Trate os erros sem duplicar tarefas pagas

Trate a incerteza na criação de forma diferente de uma consulta de estado falhada. É possível repetir um GET de consulta de tarefa sem criar outra geração. Um POST de criação cuja resposta se perdeu pode já ter iniciado o trabalho; por isso, o exemplo nunca o reenvia automaticamente.

Não presuma que todos os erros têm a mesma estrutura de resposta. Na verificação em produção de 4 de setembro, GET /models sem autenticação devolveu HTTP 401 apenas com code e message; as respostas autenticadas e bem-sucedidas de conteúdos multimédia também incluíam data e timestamp. Por isso, este tutorial não promete um requestId, um indicador retryable ou um campo de preço em todas as respostas. Os restantes casos de erro acima descrevem o tratamento pelo cliente, não afirmam que cada um foi reproduzido em produção. Guarde o estado HTTP e uma mensagem da aplicação sem dados sensíveis, quando existir; trate corpos malformados como erros em vez de deixar a execução falhar dentro de JSON.parse.

O fim do prazo de consulta periódica significa que o cliente deixou de esperar, não que a tarefa remota foi cancelada. Guarde o ID e retome mais tarde. Um estado desconhecido também não é prova de sucesso: este cliente para e comunica-o para análise. Nunca assuma «concluído» porque um valor não estava previsto numa instrução de seleção.

Para resolver problemas, conserve o ID da tarefa, o ID do modelo, a operação, o estado HTTP e a hora aproximada. Evite registar cabeçalhos de autorização ou corpos completos de pedidos com prompts privados. Verifique se os corpos das respostas de diagnóstico ou os URLs de saída contêm informações sensíveis antes de os partilhar.

Adapte o padrão para vídeo e chat

O vídeo pode usar a mesma ideia de envio e consulta periódica, mas precisa da sua própria validação de pedidos e leitura de resultados. Verifique os conteúdos de entrada obrigatórios, a duração, a resolução e as opções de áudio do modelo de vídeo selecionado, em vez de presumir que pode reutilizar os campos do corpo do pedido de imagem. Um vídeo concluído usa data.videoUrl, não data.images.

O guia do Video Agent explica um processo criativo interativo. Pode ajudar a definir o plano pretendido antes de automatizar a geração, mas uma funcionalidade do Agent não prova que exista um parâmetro de API com o mesmo nome.

O chat é uma via de integração separada. A rota documentada /chat/completions é compatível com OpenAI e devolve uma resposta de chat, ou um fluxo de dados quando é solicitado esse modo de transmissão. Não encaminhe essa resposta para o analisador de data.taskId do cliente de imagens. Partilhar o mesmo URL base não implica que todos os endpoints tenham a mesma estrutura de resposta.

Mantenha o cliente de imagens focado nessa função até verificar esse processo. Acrescente um adaptador de vídeo ou um cliente de chat separadamente, com testes para a respetiva estrutura de resposta. Esta separação é mais fácil de compreender do que uma função que tenta adivinhar se um objeto devolvido é uma tarefa de imagem, uma tarefa de vídeo ou uma mensagem de chat.

Verifique a integração e escolha o próximo passo

Os testes locais com respostas simuladas verificam o comportamento do cliente sem consumir o saldo da API. A bateria de testes que acompanha o artigo passou nos 29 testes no ambiente Windows e Node.js indicado, incluindo o envio com um único POST, a retoma apenas com GET, respostas malformadas, falha terminal, prazos e limites de repetição. Guarde o ficheiro de testes incluído junto do código do cliente e execute os testes a partir da pasta do tutorial:

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

Os testes com respostas simuladas não comprovam a disponibilidade nem a faturação em produção. Uma verificação controlada separada, em 4 de setembro de 2026, usou o mesmo cliente com o seguinte âmbito registado:

A verificação usou uma chave de API já existente no projeto, um prompt sem dados sensíveis, nenhum envio de referências e nenhuma repetição automática da criação. A entrada no registo de faturação foi associada ao ID da tarefa, não deduzida a partir da apresentação do saldo do Studio. Apenas esta configuração e o processo de imagem bem-sucedido foram testados com a API real; vídeo, chat, faturação de falhas, reembolsos e fiabilidade de execuções repetidas não foram testados. Volte a verificar o preço antes do seu próprio envio, em vez de considerar esta cobrança histórica uma cotação permanente.

Antes de ligar o exemplo a um processo real destinado ao público, confirme que:

• A chave permanece no servidor e não aparece nos pacotes de código do cliente, em capturas de ecrã nem em registos públicos.
• O modelo selecionado e todos os parâmetros são suportados pela oferta atual da API.
• Um envio aceite deixa disponível um ID numérico de tarefa recuperável.
• resume não faz qualquer POST de criação, mesmo após erros transitórios de consulta.
• Uma falha de tarefa, um resultado vazio e o fim do tempo de espera local produzem diagnósticos diferentes.
• A perda da resposta de criação não desencadeia automaticamente um segundo envio.

Na sua própria verificação controlada com a API real, registe a conta, o modelo, o âmbito de custos aprovado, o pedido sem dados sensíveis, o ID da tarefa, a resposta final e a entrada de faturação efetiva. Inspecione o resultado separadamente da verificação da existência do respetivo URL. Não execute repetidos «testes rápidos» sem considerar que cada novo envio pode criar trabalho pago.

Quando estiver pronto, crie uma chave de API e escolha um método de envio. Desenvolva a partir do processo de tarefas guardadas antes de acrescentar filas, envios de ficheiros ou processamento em lote. Se o próximo passo for integrar os conteúdos gerados num processo de revisão criativa, o processo de anúncios de produtos com Canvas apresenta um exemplo separado, conduzido por pessoas; não é uma promessa de que os projetos Canvas possam ser executados através desta API.

Responsabilidade editorial: PixMind Editorial Team é a assinatura institucional deste tutorial. A base de evidências inclui a documentação oficial, a implementação do controlador de conteúdos multimédia do projeto, 29 testes locais com respostas simuladas e a única verificação em produção descrita acima, todos revistos em 4 de setembro de 2026. Os registos da tarefa e da faturação, sem dados sensíveis, são conservados para verificação editorial. Não se reivindicam credenciais de qualquer engenheiro individual, resultados comparativos da qualidade dos modelos ou medições de desempenho.

Wan 3.0 Video: guia completo de entradas, áudio, preços e API