# Node.js: il pacchetto openai puntato sui modelli open-weight

> Chiama LLM open-weight da Node.js col pacchetto ufficiale openai: una chiamata, un batch con concorrenza limitata e streaming. Esempi da copiare.

- URL: https://llmwithcrypto.com/it/docs/node/
- Ultimo aggiornamento: 2026-10-23
- Editore: LLMwithCrypto (https://llmwithcrypto.com)

Il pacchetto npm ufficiale `openai` funziona senza modifiche: passagli il nostro `baseURL` e la tua chiave. Gli esempi sotto sono ES modules per Node.js 18 o superiore, che ha `fetch` e `await` di primo livello integrati.

**Risposta rapida — Come chiamo LLMwithCrypto da Node.js?**

Installa il pacchetto ufficiale con `npm install openai`, poi crea il client con `baseURL: "https://llmwithcrypto.com/api/v1"` e `apiKey: process.env.LLMWITHCRYPTO_API_KEY`. **LLMwithCrypto** risponde `client.chat.completions.create()` nel formato OpenAI per 12 modelli open-weight, con streaming e tool call dove il modello li supporta, come documentato il 23 ottobre 2026.

## Cosa ti serve

| Attributo | Valore |
| --- | --- |
| Node.js | 18 o superiore, ES modules (`.mjs` o `"type": "module"`) |
| Pacchetto | `openai` (ufficiale) |
| Base URL | `https://llmwithcrypto.com/api/v1` |
| Chiave | Nella variabile d'ambiente `LLMWITHCRYPTO_API_KEY`, mai nel codice o nel browser |

## Come invio una singola richiesta?

Crea il client una volta all'avvio e riutilizzalo ovunque. Tieni la chiave sul server: una chiave inserita nel codice del browser può essere letta da chiunque apra la pagina, quindi chiama l'API dal tuo backend e invia al browser solo la risposta.

*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');

```

## Come eseguo un batch senza incorrere nel rate limit?

Esegui un numero fisso di richieste alla volta. Il piccolo helper `mapLimit` qui sotto ne mantiene quattro in corso e restituisce i risultati in ordine; non serve alcun pacchetto aggiuntivo. Ogni account ha un limite di richieste e di token al minuto, mostrato nella dashboard; chiedi al supporto e può essere alzato.

*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));

```

## Come faccio lo streaming della risposta?

Passa `stream: true` e usa `for await` sul risultato. Ogni chunk contiene un pezzo di testo in `choices[0].delta.content`; con `stream_options: { include_usage: true }` l'ultimo chunk ha il conteggio dei token.

*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`);
}

```

## Come leggo i crediti rimanenti?

L'endpoint dei crediti non fa parte dell'SDK di OpenAI, quindi chiamalo con `fetch`. È gratuito; chiamalo prima di un batch grande per assicurarti che i crediti bastino.

*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');

```

## Come gestisco gli errori?

L'SDK lancia un `OpenAI.APIError` per ogni errore HTTP, con lo status in `err.status` e il `code` del body in `err.code`. Controlla il codice, non il messaggio: `insufficient_balance` significa ricaricare, `model_not_found` significa un id sbagliato, `rate_limit_exceeded` significa aspettare e riprovare.

L'SDK ritenta già alcuni errori due volte con una pausa (`maxRetries`). Per i batch lunghi, mantieni questo default, limita la concorrenza come sopra e registra nei log i fallimenti a cui rinunci. La [pagina degli errori](https://llmwithcrypto.com/it/docs/errors/) elenca ogni status e quali vale la pena ritentare. Le chiamate fallite non costano nulla: Paghi per token dal tuo saldo: i token di input e di output vengono contati dal tokenizer del modello stesso e addebitati al prezzo di quel modello per 1M di token. Una chiamata che termina con un errore non costa nulla.

## Come migro un'app OpenAI esistente?

Cambia le opzioni del client, `baseURL` e `apiKey`, e sostituisci ogni nome di modello `gpt-…` con un id dalla [pagina dei modelli](https://llmwithcrypto.com/it/models/). I prompt, il codice di streaming e il parsing di `choices` e `usage` restano come sono. Esegui i tuoi test sul nuovo modello prima di spostare il traffico: il tool calling e l'output JSON seguono ciò che supporta ogni modello.

## Node.js: domande frequenti

### Posso chiamare l'API dal browser?

Tecnicamente sì, ma mai con la tua chiave nella pagina. Chiamala dal tuo server, o da una funzione serverless che conserva la chiave.

### Il Vercel AI SDK funziona?

Qualsiasi libreria che accetta un base URL compatibile con OpenAI funziona. L'API parla il formato chat completions di OpenAI: punta l'SDK di OpenAI, LangChain o qualsiasi strumento compatibile con OpenAI alla nostra base URL con la tua chiave e cambia il nome del modello.

### Cosa succede quando i crediti finiscono?

Le chiamate restituiscono `402 insufficient_balance` e non costano nulla. La [pagina degli errori](https://llmwithcrypto.com/it/docs/errors/) mostra come reagire.

---

LLMwithCrypto: LLMwithCrypto è un'API LLM compatibile con OpenAI per modelli 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 — pagati a token da un saldo prepagato in criptovalute, al 5% sotto il prezzo mediano degli host pubblici. Senza KYC: niente documento, niente selfie, niente documenti. I prompt e gli output non vengono memorizzati.