# Node.js: o pacote openai apontado para modelos de pesos abertos

> Chame LLMs de pesos abertos a partir do Node.js com o pacote oficial openai: uma chamada, um lote com limite de concorrência, streaming e o saldo restante.

- URL: https://llmwithcrypto.com/pt/docs/node/
- Última atualização: 2026-10-23
- Editor: LLMwithCrypto (https://llmwithcrypto.com)

O pacote npm oficial `openai` funciona sem alterações: passe a ele nossa `baseURL` e sua chave. Os exemplos abaixo são ES modules para Node.js 18 ou superior, que já traz `fetch` e `await` de nível superior embutidos.

**Resposta rápida — Como chamo LLMwithCrypto a partir do Node.js?**

Instale o pacote oficial com `npm install openai` e crie o cliente com `baseURL: "https://llmwithcrypto.com/api/v1"` e `apiKey: process.env.LLMWITHCRYPTO_API_KEY`. **LLMwithCrypto** responde `client.chat.completions.create()` no formato da OpenAI para 12 modelos de pesos abertos, com streaming e tool calls onde o modelo suportar, conforme documentado em 23 de outubro de 2026.

## O que você precisa

| Atributo | Valor |
| --- | --- |
| Node.js | 18 ou superior, ES modules (`.mjs` ou `"type": "module"`) |
| Pacote | `openai` (oficial) |
| URL base | `https://llmwithcrypto.com/api/v1` |
| Chave | Na variável de ambiente `LLMWITHCRYPTO_API_KEY`, nunca no código ou no navegador |

## Como envio uma requisição?

Crie o client uma vez na inicialização e reutilize-o em todo lugar. Mantenha a chave no servidor: uma chave embutida no código do navegador pode ser lida por qualquer pessoa que abra a página, então chame a API do seu backend e envie apenas a resposta para o navegador.

*one-call.mjs*

```javascript
import OpenAI from 'openai';

const client = new OpenAI({
  baseURL: 'https://llmwithcrypto.com/api/v1',
  apiKey: process.env.LLMWITHCRYPTO_API_KEY,
});

const resp = await client.chat.completions.create({
  model: 'deepseek-v4-pro',
  messages: [
    { role: 'system', content: 'Answer in two sentences.' },
    { role: 'user', content: 'What is a context window?' },
  ],
  max_tokens: 200,
});
console.log(resp.choices[0].message.content);
console.log(resp.usage.prompt_tokens, 'in,', resp.usage.completion_tokens, 'out');

```

## Como executo um lote sem estourar o rate limit?

Execute um número fixo de requisições por vez. O pequeno helper `mapLimit` abaixo mantém quatro em andamento e retorna os resultados em ordem; nenhum pacote extra é necessário. Toda conta tem um limite de requisições e de tokens por minuto, mostrado no dashboard; peça ao suporte e ele pode ser aumentado.

*batch.mjs*

```javascript
import OpenAI from 'openai';

const client = new OpenAI({
  baseURL: 'https://llmwithcrypto.com/api/v1',
  apiKey: process.env.LLMWITHCRYPTO_API_KEY,
});

async function translate(text) {
  const resp = await client.chat.completions.create({
    model: 'qwen3-235b-a22b-instruct-2507',
    messages: [
      { role: 'system', content: 'Translate into Spanish. Reply with the translation only.' },
      { role: 'user', content: text },
    ],
    max_tokens: 200,
  });
  return resp.choices[0].message.content;
}

// at most 4 requests in flight
async function mapLimit(items, limit, fn) {
  const out = new Array(items.length);
  let next = 0;
  async function worker() {
    while (next < items.length) {
      const i = next++;
      out[i] = await fn(items[i]);
    }
  }
  await Promise.all(Array.from({ length: limit }, worker));
  return out;
}

const lines = ['Your order has shipped.', 'Your payment was received.', 'Your key was revoked.'];
console.log(await mapLimit(lines, 4, translate));

```

## Como faço streaming da resposta?

Passe `stream: true` e use `for await` no resultado. Cada chunk traz um trecho de texto em `choices[0].delta.content`; com `stream_options: { include_usage: true }` o último chunk tem a contagem de tokens.

*stream.mjs*

```javascript
import OpenAI from 'openai';

const client = new OpenAI({
  baseURL: 'https://llmwithcrypto.com/api/v1',
  apiKey: process.env.LLMWITHCRYPTO_API_KEY,
});

const stream = await client.chat.completions.create({
  model: 'deepseek-v4.1-flash',
  messages: [{ role: 'user', content: 'Write a haiku about latency.' }],
  stream: true,
  stream_options: { include_usage: true },
  max_tokens: 120,
});
for await (const chunk of stream) {
  const text = chunk.choices[0]?.delta?.content;
  if (text) process.stdout.write(text);
  if (chunk.usage) console.log(`\n${chunk.usage.prompt_tokens} in, ${chunk.usage.completion_tokens} out`);
}

```

## Como consulto os créditos restantes?

O endpoint de créditos não faz parte do SDK da OpenAI, então chame-o com `fetch`. É gratuito; chame antes de um lote grande para garantir que o saldo cobre o lote.

*credits.mjs*

```javascript
const res = await fetch('https://llmwithcrypto.com/api/v1/credits', {
  headers: { Authorization: `Bearer ${process.env.LLMWITHCRYPTO_API_KEY}` },
});
const credits = await res.json();
console.log('credit left:', credits.balance_usd, 'USD');

```

## Como trato os erros?

O SDK lança um `OpenAI.APIError` para cada erro HTTP, com o status em `err.status` e o `code` do corpo em `err.code`. Teste o código, não a mensagem: `insufficient_balance` significa recarregar, `model_not_found` significa id errado, `rate_limit_exceeded` significa esperar e tentar de novo.

O SDK já tenta alguns erros duas vezes com uma pausa (`maxRetries`). Para lotes longos, mantenha esse padrão, limite a concorrência como acima e registre as falhas que você desistir de tentar. A [página de erros](https://llmwithcrypto.com/pt/docs/errors/) lista cada status e quais valem uma nova tentativa. Chamadas com falha não custam nada: Você paga por token a partir do seu saldo: tokens de entrada e de saída são contados pelo tokenizer do próprio modelo e cobrados ao preço daquele modelo por 1M de tokens. Uma chamada que termina em erro não custa nada.

## Como migro um app OpenAI existente?

Altere as opções do client, `baseURL` e `apiKey`, e substitua cada nome de modelo `gpt-…` por um id da [página de modelos](https://llmwithcrypto.com/pt/models/). Prompts, código de streaming e o parsing de `choices` e `usage` continuam iguais. Rode seus testes no novo modelo antes de trocar o tráfego: tool calling e saída JSON seguem o que cada modelo suporta.

## Node.js: perguntas frequentes

### Posso chamar a API do navegador?

Tecnicamente sim, mas nunca com sua chave na página. Chame do seu servidor, ou de uma função serverless que guarda a chave.

### O Vercel AI SDK funciona?

Qualquer biblioteca que aceite uma base URL compatível com OpenAI funciona. A API fala o formato de chat completions da OpenAI: aponte o SDK da OpenAI, o LangChain ou qualquer ferramenta compatível com OpenAI para a nossa base URL com a sua chave e troque o nome do modelo.

### O que acontece quando os créditos acabam?

As chamadas retornam `402 insufficient_balance` e não custam nada. A [página de erros](https://llmwithcrypto.com/pt/docs/errors/) mostra como reagir.

---

LLMwithCrypto: O LLMwithCrypto é uma API de LLM compatível com OpenAI para modelos open-weight — DeepSeek V4 Pro, DeepSeek V4.1 Flash, DeepSeek R1, Qwen3.5 397B A17B, Qwen3 235B A22B Instruct, gpt-oss-120b, gpt-oss-20b, GLM-4.7, Llama 3.3 70B Instruct, Gemma 4 31B, Mistral Large 3, Mistral Small 4 — paga por token a partir de um saldo cripto pré-pago, a 5% abaixo do preço mediano dos hosts públicos. Sem KYC: sem documento de identidade, sem selfie, sem documentos. Prompts e respostas não são armazenados.