Node.js

Utilisez le paquet npm officiel openai avec api14. Rien d'autre ne change : seuls baseURL et apiKey pointent vers api14, et tout identifiant de modèle fonctionne comme model.

Installation

npm install openai

Stockez votre clé dans une variable d'environnement :

export API14_API_KEY="sk-api14-..."

Configuration

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api14.com/api/v1",
  apiKey: process.env.API14_API_KEY,
});

Sans options, le SDK lit OPENAI_BASE_URL et OPENAI_API_KEY. Définir ces deux variables fait passer une application existante à api14 sans modifier le code :

export OPENAI_BASE_URL="https://api14.com/api/v1"
export OPENAI_API_KEY="sk-api14-..."

const client = new OpenAI(); // utilise les deux variables

Chat

const result = await client.chat.completions.create({
  model: "openai/gpt-5-mini",
  messages: [{ role: "user", content: "Explain vector databases in two sentences." }],
});

console.log(result.choices[0].message.content);

Streaming

const stream = await client.chat.completions.create({
  model: "anthropic/claude-sonnet-4.5",
  messages: [{ role: "user", content: "Write a haiku about APIs." }],
  stream: true,
});

for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}

Voir Streaming pour le format des événements.

Appel d'outils

Envoyez tools, exécutez les appels demandés par le modèle, ajoutez les résultats et rappelez jusqu'à ce qu'il réponde par du texte :

const tools = [{
  type: "function",
  function: {
    name: "get_weather",
    description: "Current weather for a city",
    parameters: {
      type: "object",
      properties: { city: { type: "string" } },
      required: ["city"],
    },
  },
}];

const messages = [{ role: "user", content: "What's the weather in Istanbul?" }];
let res = await client.chat.completions.create({ model: "openai/gpt-5-mini", messages, tools });

while (res.choices[0].finish_reason === "tool_calls") {
  const msg = res.choices[0].message;
  messages.push(msg);
  for (const call of msg.tool_calls) {
    const args = JSON.parse(call.function.arguments);
    const result = await getWeather(args.city); // votre fonction
    messages.push({ role: "tool", tool_call_id: call.id, content: JSON.stringify(result) });
  }
  res = await client.chat.completions.create({ model: "openai/gpt-5-mini", messages, tools });
}

console.log(res.choices[0].message.content);

Voir Appel d'outils.

Sortie structurée

Le helper parse transforme un schéma Zod en format de réponse json_schema et analyse la réponse (npm install zod) :

import { z } from "zod";
import { zodResponseFormat } from "openai/helpers/zod";

const Person = z.object({ name: z.string(), born: z.number().int(), city: z.string() });

const res = await client.chat.completions.parse({
  model: "openai/gpt-5-mini",
  messages: [{ role: "user", content: "Extract: Ada Lovelace, born 1815 in London." }],
  response_format: zodResponseFormat(Person, "person"),
});

console.log(res.choices[0].message.parsed); // { name: "Ada Lovelace", born: 1815, city: "London" }

Voir Sorties structurées.

Image en entrée

Passez content sous forme de tableau de parties. Utilisez une URL publique ou une URL data en base64 :

import { readFileSync } from "node:fs";

const image = readFileSync("photo.png").toString("base64");

const res = await client.chat.completions.create({
  model: "google/gemini-2.5-flash",
  messages: [{
    role: "user",
    content: [
      { type: "text", text: "What is in this picture?" },
      { type: "image_url", image_url: { url: `data:image/png;base64,${image}` } },
    ],
  }],
});

Voir Vision et fichiers pour les PDF, l'audio et la vidéo.

Embeddings

const result = await client.embeddings.create({
  model: "openai/text-embedding-3-small",
  input: ["The quick brown fox", "Lorem ipsum"],
});

console.log(result.data.map((d) => d.embedding.length));

Endpoints sans méthode de SDK

Les tâches vidéo et le rerank ne font pas partie de la surface du SDK OpenAI. Utilisez les helpers génériques post / get du client : ils réutilisent l'URL de base, la clé et les nouvelles tentatives :

const ranked = await client.post("/rerank", {
  body: {
    model: "cohere/rerank-v3.5",
    query: "What is the capital of France?",
    documents: ["Paris is the capital of France.", "Berlin is in Germany."],
    top_n: 1,
  },
});
console.log(ranked.results);

Erreurs

Les erreurs arrivent au format OpenAI et sont levées sous forme d'OpenAI.APIError. Aiguillez selon status et code :

try {
  await client.chat.completions.create({ model: "openai/gpt-5-mini", messages: [{ role: "user", content: "Hi" }] });
} catch (err) {
  if (err instanceof OpenAI.APIError) {
    if (err.status === 402) console.error("Balance too low, add funds:", err.code); // insufficient_balance
    else if (err.status === 429) console.error("Retry after", err.headers?.["retry-after"], "s:", err.code); // rate_limited
    else throw err;
  }
}

Voir Erreurs pour tous les codes.

Délais d'attente et nouvelles tentatives

Par défaut, le SDK réessaie deux fois les erreurs de connexion et les réponses 408, 409, 429 et 5xx, avec un backoff exponentiel qui respecte Retry-After. Le délai par défaut est de 10 minutes par tentative. Définissez les deux sur le client, ou remplacez-les par requête :

const client = new OpenAI({
  baseURL: "https://api14.com/api/v1",
  apiKey: process.env.API14_API_KEY,
  timeout: 60_000, // ms par tentative
  maxRetries: 4,
});

await client.chat.completions.create(params, { timeout: 300_000, maxRetries: 0 });

Une nouvelle tentative ne peut pas corriger daily_limit_reached ni insufficient_balance. Pour les longs traitements par lots, arrêtez-vous sur ces codes au lieu de réessayer. Voir Limites de débit.

Toutes les capacités

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api14.com/api/v1",
  apiKey: process.env.API14_API_KEY,
});

const result = await client.chat.completions.create({
  "model": "openai/gpt-5-mini",
  "messages": [
    {
      "role": "user",
      "content": "Explain vector databases in two sentences."
    }
  ]
});
console.log(result.choices[0].message.content);