# Node.js : le package openai pointé vers des modèles à poids ouverts

> Appelez des LLM à poids ouverts depuis Node.js avec le package openai : un appel, un lot, le streaming et le solde restant. Exemples à copier.

- URL: https://llmwithcrypto.com/fr/docs/node/
- Dernière mise à jour: 2026-10-23
- Éditeur: LLMwithCrypto (https://llmwithcrypto.com)

Le package npm officiel `openai` fonctionne sans modification : donnez-lui notre `baseURL` et votre clé. Les exemples ci-dessous sont des modules ES pour Node.js 18 ou plus récent, qui intègre `fetch` et le `await` de haut niveau.

**Réponse rapide — Comment appeler LLMwithCrypto depuis Node.js ?**

Installez le package officiel avec `npm install openai`, puis créez le client avec `baseURL: "https://llmwithcrypto.com/api/v1"` et `apiKey: process.env.LLMWITHCRYPTO_API_KEY`. **LLMwithCrypto** répond en `client.chat.completions.create()` au format OpenAI pour 12 modèles à poids ouverts, avec streaming et tool calls là où le modèle les prend en charge, comme documenté le 23 octobre 2026.

## Ce qu'il vous faut

| Attribut | Valeur |
| --- | --- |
| Node.js | 18 ou plus récent, modules ES (`.mjs` ou `"type": "module"`) |
| Package | `openai` (officiel) |
| URL de base | `https://llmwithcrypto.com/api/v1` |
| Key | Dans la variable d'environnement `LLMWITHCRYPTO_API_KEY`, jamais dans le code ni dans le navigateur |

## Comment envoyer une requête ?

Créez le client une fois au démarrage et réutilisez-le partout. Gardez la clé côté serveur : une clé présente dans du code navigateur peut être lue par quiconque ouvre la page, alors appelez l'API depuis votre backend et n'envoyez que la réponse au navigateur.

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

```

## Comment lancer un lot sans atteindre le rate limit ?

Lancez un nombre fixe de requêtes à la fois. Le petit helper `mapLimit` ci-dessous maintient quatre requêtes en vol et renvoie les résultats dans l'ordre ; aucun package supplémentaire n'est nécessaire. Chaque compte a une limite de requêtes et de tokens par minute, affichée dans le dashboard ; demandez au support, elle peut être augmentée.

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

```

## Comment streamer la réponse ?

Passez `stream: true` et utilisez `for await` sur le résultat. Chaque chunk contient un morceau de texte dans `choices[0].delta.content` ; avec `stream_options: { include_usage: true }`, le dernier chunk contient le nombre 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`);
}

```

## Comment lire les crédits restants ?

L'endpoint credits ne fait pas partie du SDK OpenAI, appelez-le donc avec `fetch`. Il est gratuit ; appelez-le avant un gros lot pour vérifier que le solde de crédits suffira.

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

```

## Comment gérer les erreurs ?

Le SDK lève une `OpenAI.APIError` pour chaque erreur HTTP, avec le statut dans `err.status` et le `code` du corps dans `err.code`. Testez le code, pas le message : `insufficient_balance` signifie recharger, `model_not_found` signifie un id erroné, `rate_limit_exceeded` signifie attendre et réessayer.

Le SDK réessaie déjà certaines erreurs deux fois avec une pause (`maxRetries`). Pour les longs lots, gardez ce comportement par défaut, plafonnez la concurrence comme ci-dessus et journalisez les échecs que vous abandonnez. La [page des erreurs](https://llmwithcrypto.com/fr/docs/errors/) liste chaque statut et ceux qui valent un nouvel essai. Les appels échoués ne coûtent rien : Vous payez au token depuis votre solde : les tokens d'entrée et de sortie sont comptés par le tokenizer du modèle lui-même et facturés au prix de ce modèle par 1M de tokens. Un appel qui se termine par une erreur ne coûte rien.

## Comment migrer une application OpenAI existante ?

Changez les options du client, `baseURL` et `apiKey`, et remplacez chaque nom de modèle `gpt-…` par un id de la [page des modèles](https://llmwithcrypto.com/fr/models/). Les prompts, le code de streaming et l'analyse des `choices` et `usage` restent inchangés. Lancez vos tests sur le nouveau modèle avant de basculer le trafic : le tool calling et la sortie JSON suivent ce que chaque modèle prend en charge.

## Node.js : questions fréquentes

### Puis-je appeler l'API depuis le navigateur ?

Techniquement oui, mais jamais avec votre clé dans la page. Appelez-la depuis votre serveur, ou depuis une fonction serverless qui détient la clé.

### Le SDK Vercel AI fonctionne-t-il ?

Toute bibliothèque qui accepte une base URL compatible OpenAI fonctionne. L'API parle le format chat completions d'OpenAI : pointez le SDK OpenAI, LangChain ou tout outil compatible OpenAI vers notre URL de base avec votre clé, et changez le nom du modèle.

### Que se passe-t-il quand les crédits sont épuisés ?

Les appels renvoient `402 insufficient_balance` et ne coûtent rien. La [page des erreurs](https://llmwithcrypto.com/fr/docs/errors/) indique comment réagir.

---

LLMwithCrypto: LLMwithCrypto est une API LLM compatible OpenAI pour les modèles 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 — facturés au token depuis un solde crypto prépayé, à 5 % en dessous du prix médian des hébergeurs publics. Sans KYC : pas de pièce d'identité, pas de selfie, pas de documents. Les prompts et les sorties ne sont pas stockés.