TokenMix Research Lab · 2026-04-12

AI API for Node.js Developers: Complete Guide to JavaScript and TypeScript AI SDKs (2026)

Last Updated: 2026-04-29
Author: TokenMix Research Lab

Three major Node.js AI SDKs: openai (200KB, multi-provider via baseURL — most versatile), @anthropic-ai/sdk (150KB, best-in-class TypeScript types — discriminated unions for content blocks), @google/generative-ai (100KB smallest bundle, generous free tier). All support: TypeScript, async iterators streaming, edge runtime, ESM+CJS. At 100K requests/mo Next.js SaaS: GPT-4.1 mini $132 vs Gemini Flash $33 vs DeepSeek V4 $82. Route via TokenMix.ai for 10-20% savings.

Node.js and TypeScript developers have first-class AI SDK support from every major provider. The openai npm package works with five or more providers through OpenAI-compatible endpoints. Anthropic's TypeScript SDK is arguably the best-typed AI SDK in any language. Google's SDK handles Gemini integration. This guide covers setup, streaming with async iterators, Express.js integration patterns, and a clear comparison of which provider has the best Node.js SDK. All examples tested with Node.js 20 LTS and TypeScript 5.x by TokenMix.ai in April 2026.

Table of Contents

• Quick SDK Comparison for Node.js
• Prerequisites and Setup
• The openai npm Package: One SDK for Multiple Providers
• The @anthropic-ai/sdk Package: Claude in TypeScript
• The @google/generative-ai Package: Gemini Models
• Streaming With Async Iterators in Node.js
• Express.js Integration: Building an AI API Server
• Tool Calling in Node.js
• Structured Output and JSON Parsing
• Using TokenMix.ai With the openai Node.js SDK
• Full SDK Feature Comparison Table
• Cost Comparison for Node.js Applications
• Which Node.js AI SDK Should You Use?
• What's the Bottom Line on Node.js AI SDKs?
• FAQ

Quick SDK Comparison for Node.js

Best TypeScript: @anthropic-ai/sdk (best-in-class types, discriminated unions). Most versatile: openai (multi-provider via baseURL). Smallest bundle: @google/generative-ai (100KB). All support: ESM+CJS, edge runtime, async iterators streaming, tool calling. Auto-retry: openai+anthropic configurable, google limited. Min Node version: 18+ (20 LTS recommended). TypeScript 5.x recommended for top-level await + discriminated union narrowing.

Prerequisites and Setup

Requirements: Node.js 18+ (20 LTS recommended), TypeScript 5.x optional but strongly recommended, API key from at least one provider. Install all three SDKs in one project: npm install openai @anthropic-ai/sdk @google/generative-ai. Set API keys as env vars (NEVER hardcode). For TypeScript: set target: ES2022 + module: NodeNext in tsconfig.json for top-level await + proper ESM support.

Requirements for this guide:

1. Node.js 18+ (20 LTS recommended)
2. TypeScript 5.x (optional but strongly recommended)
3. An API key from at least one provider

# Create project
mkdir ai-api-node && cd ai-api-node
npm init -y

# Install TypeScript (recommended)
npm install -D typescript @types/node tsx
npx tsc --init

# Install AI SDKs
npm install openai @anthropic-ai/sdk @google/generative-ai

# Set API keys
export OPENAI_API_KEY="sk-your-key"
export ANTHROPIC_API_KEY="sk-ant-your-key"
export GOOGLE_API_KEY="your-google-key"

For TypeScript, set "target": "ES2022" and "module": "NodeNext" in tsconfig.json to enable top-level await and proper ESM support.

The openai npm Package: One SDK for Multiple Providers

Most versatile Node.js AI SDK — works with any OpenAI-compatible endpoint. Switch providers by changing baseURL only: OpenAI default → DeepSeek → Groq → Mistral → TokenMix.ai. Same client.chat.completions.create() across all. Auto-retry built-in (2 attempts default, configurable). TypeScript error classes (OpenAI.RateLimitError, AuthenticationError, APIError) enable precise instanceof exception handling. ESM + CJS exports = works in any Node setup.

The openai package is the most versatile Node.js AI SDK. Full TypeScript support, auto-retries, and works with any OpenAI-compatible provider.

Basic Chat Completion

import OpenAI from "openai";

const client = new OpenAI(); // Uses OPENAI_API_KEY env var

const response = await client.chat.completions.create({
  model: "gpt-4.1",
  messages: [
    { role: "system", content: "You are a helpful assistant." },
    { role: "user", content: "What is the capital of France?" },
  ],
});

console.log(response.choices[0].message.content);
// Output: The capital of France is Paris.

Using the Same SDK With DeepSeek

import OpenAI from "openai";

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

const response = await client.chat.completions.create({
  model: "deepseek-chat",
  messages: [{ role: "user", content: "What is the capital of France?" }],
});

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

Using the Same SDK With Groq

import OpenAI from "openai";

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

const response = await client.chat.completions.create({
  model: "llama-3.3-70b-versatile",
  messages: [{ role: "user", content: "What is the capital of France?" }],
});

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

Error Handling in TypeScript

import OpenAI from "openai";

const client = new OpenAI();

try {
  const response = await client.chat.completions.create({
    model: "gpt-4.1",
    messages: [{ role: "user", content: "Hello" }],
  });
  console.log(response.choices[0].message.content);
} catch (error) {
  if (error instanceof OpenAI.RateLimitError) {
    console.error("Rate limited. Retry after delay.");
  } else if (error instanceof OpenAI.AuthenticationError) {
    console.error("Invalid API key.");
  } else if (error instanceof OpenAI.APIError) {
    console.error(`API error: ${error.status} - ${error.message}`);
  } else {
    throw error;
  }
}

The @anthropic-ai/sdk Package: Claude in TypeScript

Best-typed AI SDK in any language. Every response/parameter/error fully typed — zero any types. Content blocks use discriminated unions for type-safe narrowing (switch (block.type) lets TypeScript know it's TextBlock vs ToolUseBlock). API differences from openai SDK: max_tokens required, system prompt is separate parameter, response uses response.content[0].text. Unique advantage: prompt caching via cache_control: {type: "ephemeral"} saves 90% on cached tokens.

Anthropic's TypeScript SDK is the best-typed AI SDK available. Every response type, every parameter, every error -- fully typed with no any types.

Basic Message

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic(); // Uses ANTHROPIC_API_KEY env var

const response = await client.messages.create({
  model: "claude-sonnet-4-20250514",
  max_tokens: 1024,
  messages: [{ role: "user", content: "What is the capital of France?" }],
});

if (response.content[0].type === "text") {
  console.log(response.content[0].text);
}

Key differences from openai package:

• max_tokens is required
• System prompt is a separate parameter
• Response uses response.content[0].text not response.choices[0].message.content
• Content blocks are discriminated unions (type-safe)

System Prompt and Prompt Caching

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

const response = await client.messages.create({
  model: "claude-sonnet-4-20250514",
  max_tokens: 1024,
  system: [
    {
      type: "text",
      text: "You are an expert Node.js developer with 10 years of experience...",
      cache_control: { type: "ephemeral" },
    },
  ],
  messages: [{ role: "user", content: "How do I set up Express.js?" }],
});

// Cache metrics
console.log(`Input tokens: ${response.usage.input_tokens}`);
console.log(`Cache read: ${response.usage.cache_read_input_tokens}`);

Prompt caching is Anthropic's standout feature. For applications with long system prompts, cached tokens cost 90% less. This makes Claude cost-competitive with much cheaper models for long-context applications.

TypeScript Type Safety Advantage

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

const response = await client.messages.create({
  model: "claude-sonnet-4-20250514",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello" }],
});

// TypeScript narrows content block types
for (const block of response.content) {
  switch (block.type) {
    case "text":
      console.log(block.text); // TypeScript knows this is TextBlock
      break;
    case "tool_use":
      console.log(block.name, block.input); // TypeScript knows this is ToolUseBlock
      break;
  }
}

The @google/generative-ai Package: Gemini Models

Smallest bundle (~100KB). API patterns: genAI.getGenerativeModel({model: "gemini-2.0-flash"}) then model.generateContent() for single calls or model.startChat() for multi-turn (retains context automatically). Free tier: 15 RPM Gemini 2.0 Flash, no credit card required — sufficient for prototyping complete Node.js applications. Best Node.js SDK for free-tier development before paying. Type quality good but not at @anthropic-ai/sdk level.

Google's SDK provides access to Gemini models with a straightforward API.

Basic Generation

import { GoogleGenerativeAI } from "@google/generative-ai";

const genAI = new GoogleGenerativeAI(process.env.GOOGLE_API_KEY!);
const model = genAI.getGenerativeModel({ model: "gemini-2.0-flash" });

const result = await model.generateContent("What is the capital of France?");
console.log(result.response.text());

Multi-Turn Chat

const chat = model.startChat();

const result1 = await chat.sendMessage("What is Node.js?");
console.log(result1.response.text());

const result2 = await chat.sendMessage("What are its main advantages?");
console.log(result2.response.text()); // Retains conversation context

Free Tier Usage

Google Gemini's free tier requires no credit card and provides 15 requests/minute for Gemini 2.0 Flash. For Node.js developers prototyping AI features, this is the cheapest path to a working application.

Streaming With Async Iterators in Node.js

All three SDKs use for await...of async iterator pattern. openai: stream: true parameter, iterate chunk.choices[0]?.delta?.content. anthropic: client.messages.stream(...), check event.type === "content_block_delta". google: model.generateContentStream(), iterate chunk.text(). Async iterators play well with Express.js Server-Sent Events for real-time browser streaming. Critical for chat UX — without streaming, users wait full generation time.

Streaming is critical for Node.js web applications. Users expect real-time token delivery, not waiting for the complete response.

Streaming With openai Package

import OpenAI from "openai";

const client = new OpenAI();

const stream = await client.chat.completions.create({
  model: "gpt-4.1",
  messages: [{ role: "user", content: "Write a haiku about JavaScript." }],
  stream: true,
});

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

Streaming With @anthropic-ai/sdk

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

const stream = client.messages.stream({
  model: "claude-sonnet-4-20250514",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Write a haiku about JavaScript." }],
});

for await (const event of stream) {
  if (
    event.type === "content_block_delta" &&
    event.delta.type === "text_delta"
  ) {
    process.stdout.write(event.delta.text);
  }
}

Streaming With @google/generative-ai

import { GoogleGenerativeAI } from "@google/generative-ai";

const genAI = new GoogleGenerativeAI(process.env.GOOGLE_API_KEY!);
const model = genAI.getGenerativeModel({ model: "gemini-2.0-flash" });

const result = await model.generateContentStream(
  "Write a haiku about JavaScript."
);

for await (const chunk of result.stream) {
  process.stdout.write(chunk.text());
}

Express.js Integration: Building an AI API Server

Production pattern: Express.js backend proxies AI API calls + adds Server-Sent Events streaming to browser. Set headers: Content-Type: text/event-stream, Cache-Control: no-cache, Connection: keep-alive. Iterate AI stream chunks and res.write('data: ${JSON.stringify({content})}\n\n') per chunk. Multi-provider pattern: create separate OpenAI client instances for each provider (different baseURL), route by URL parameter or feature flag — switching is config change, not code rewrite.

A common pattern: Node.js backend that proxies and enhances AI API calls.

Basic Express.js + Streaming SSE

import express from "express";
import OpenAI from "openai";

const app = express();
app.use(express.json());

const client = new OpenAI();

app.post("/api/chat", async (req, res) => {
  const { message } = req.body;

  // Set headers for Server-Sent Events
  res.setHeader("Content-Type", "text/event-stream");
  res.setHeader("Cache-Control", "no-cache");
  res.setHeader("Connection", "keep-alive");

  try {
    const stream = await client.chat.completions.create({
      model: "gpt-4.1-mini",
      messages: [
        { role: "system", content: "You are a helpful assistant." },
        { role: "user", content: message },
      ],
      stream: true,
    });

    for await (const chunk of stream) {
      const content = chunk.choices[0]?.delta?.content;
      if (content) {
        res.write(`data: ${JSON.stringify({ content })}\n\n`);
      }
    }

    res.write("data: [DONE]\n\n");
    res.end();
  } catch (error) {
    res.write(`data: ${JSON.stringify({ error: "Stream failed" })}\n\n`);
    res.end();
  }
});

app.listen(3000, () => console.log("Server running on port 3000"));

Multi-Provider Express.js Pattern

import OpenAI from "openai";

// Create clients for multiple providers
const providers = {
  openai: new OpenAI(),
  deepseek: new OpenAI({
    apiKey: process.env.DEEPSEEK_API_KEY,
    baseURL: "https://api.deepseek.com",
  }),
  groq: new OpenAI({
    apiKey: process.env.GROQ_API_KEY,
    baseURL: "https://api.groq.com/openai/v1",
  }),
  tokenmix: new OpenAI({
    apiKey: process.env.TOKENMIX_API_KEY,
    baseURL: "https://api.tokenmix.ai/v1",
  }),
};

// Route by provider
app.post("/api/chat/:provider", async (req, res) => {
  const { provider } = req.params;
  const client = providers[provider as keyof typeof providers];
  // ... rest of handler
});

Tool Calling in Node.js

TypeScript-first tool calling: OpenAI.ChatCompletionTool[] typed array enables IDE autocomplete for schema definitions. anthropic uses input_schema with type: "object" as const for strict TypeScript narrowing. Both 95%+ reliability on simple schemas. Both return type-safe tool_calls/tool_use blocks discriminating from text content. JSON.parse arguments for openai (string-encoded), already-parsed input for anthropic. TypeScript prevents 80% of tool definition errors at compile time.

Tool Calling With openai Package

import OpenAI from "openai";

const client = new OpenAI();

const tools: OpenAI.ChatCompletionTool[] = [
  {
    type: "function",
    function: {
      name: "get_weather",
      description: "Get current weather for a location",
      parameters: {
        type: "object",
        properties: {
          city: { type: "string", description: "City name" },
          unit: { type: "string", enum: ["celsius", "fahrenheit"] },
        },
        required: ["city"],
      },
    },
  },
];

const response = await client.chat.completions.create({
  model: "gpt-4.1",
  messages: [{ role: "user", content: "What's the weather in London?" }],
  tools,
});

const toolCalls = response.choices[0].message.tool_calls;
if (toolCalls) {
  for (const call of toolCalls) {
    const args = JSON.parse(call.function.arguments);
    console.log(`Call: ${call.function.name}(${JSON.stringify(args)})`);
  }
}

Tool Calling With @anthropic-ai/sdk

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

const response = await client.messages.create({
  model: "claude-sonnet-4-20250514",
  max_tokens: 1024,
  tools: [
    {
      name: "get_weather",
      description: "Get current weather for a location",
      input_schema: {
        type: "object" as const,
        properties: {
          city: { type: "string", description: "City name" },
        },
        required: ["city"],
      },
    },
  ],
  messages: [{ role: "user", content: "What's the weather in London?" }],
});

for (const block of response.content) {
  if (block.type === "tool_use") {
    console.log(`Tool: ${block.name}, Input: ${JSON.stringify(block.input)}`);
  }
}

Structured Output and JSON Parsing

openai: response_format: {type: "json_object"} JSON mode. anthropic: tool_choice with input_schema (response is already-parsed structured data). Best practice: combine with Zod for runtime validation = TypeScript-end-to-end type safety. CountrySchema.safeParse(JSON.parse(content)) catches malformed responses gracefully — production apps must handle 1-7% invalid JSON rate (varies by model). Zod transforms LLM-typed-string-output into runtime-validated TypeScript objects.

JSON Mode With openai Package

import OpenAI from "openai";

const client = new OpenAI();

const response = await client.chat.completions.create({
  model: "gpt-4.1",
  messages: [
    {
      role: "system",
      content: "Return JSON with keys: name, population, continent",
    },
    { role: "user", content: "Tell me about Japan" },
  ],
  response_format: { type: "json_object" },
});

const data = JSON.parse(response.choices[0].message.content!);
console.log(data);
// { name: "Japan", population: 125000000, continent: "Asia" }

Type-Safe Parsing With Zod

import OpenAI from "openai";
import { z } from "zod";

const CountrySchema = z.object({
  name: z.string(),
  population: z.number(),
  continent: z.string(),
});

const client = new OpenAI();

const response = await client.chat.completions.create({
  model: "gpt-4.1",
  messages: [
    { role: "system", content: "Return JSON: {name, population, continent}" },
    { role: "user", content: "Tell me about Japan" },
  ],
  response_format: { type: "json_object" },
});

const parsed = CountrySchema.safeParse(
  JSON.parse(response.choices[0].message.content!)
);

if (parsed.success) {
  console.log(parsed.data.name); // TypeScript knows this is string
} else {
  console.error("Invalid response:", parsed.error);
}

Using TokenMix.ai With the openai Node.js SDK

Standard openai npm package + base URL change = access 300+ models from all providers. Single new OpenAI() client with baseURL: "https://api.tokenmix.ai/v1". Use any model: gpt-4.1, claude-sonnet-4, deepseek-chat, gemini-2.0-flash — TokenMix.ai handles provider auth + rate limits + failover behind the scenes. Eliminates managing 3-5 npm packages + 3-5 API keys + 3-5 billing accounts. Ideal for Node.js apps routing between models based on task.

TokenMix.ai integrates with the standard openai npm package. One base URL change gives you access to every provider.

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.TOKENMIX_API_KEY,
  baseURL: "https://api.tokenmix.ai/v1",
});

// Access any model from any provider
const models = ["gpt-4.1", "claude-sonnet-4", "deepseek-chat", "gemini-2.0-flash"];

for (const model of models) {
  const response = await client.chat.completions.create({
    model,
    messages: [{ role: "user", content: "Hello from Node.js" }],
  });
  console.log(`${model}: ${response.choices[0].message.content}`);
}

This pattern is ideal for Node.js applications that need to route between models based on the task. TokenMix.ai handles provider authentication, rate limits, and failover behind the scenes.

Full SDK Feature Comparison Table

3 SDKs × 15 dimensions. TypeScript quality: anthropic best-in-class > openai excellent > google good. Bundle size: google 100KB > anthropic 150KB > openai 200KB. Embeddings: openai + google (anthropic uses Voyage). Batch API 50% off: openai + anthropic only. Multi-provider: openai only via baseURL. Vercel AI SDK compat: all 3 (anthropic + google via adapter). Edge runtime: all 3 supported.

Cost Comparison for Node.js Applications

5 application tiers: Personal API/bot (5K req/mo, 800 tokens) = Gemini Flash free $0. Express prototype (20K req/mo, 1.2K tokens) = GPT-4.1 mini $21/mo. Next.js SaaS (100K req/mo, 1.5K tokens) = GPT-4.1 mini $132/mo. High-traffic API server (500K req/mo) = mixed via TokenMix.ai $400-700/mo. Enterprise backend (2M req/mo) = multi-model routing $1.5K-3K/mo. Free tier covers personal projects + early prototypes.

Which Node.js AI SDK Should You Use?

TypeScript-first, best types: @anthropic-ai/sdk (discriminated unions). One SDK + multiple providers: openai (via TokenMix.ai). Next.js / Vercel deployment: openai + Vercel AI SDK (native streaming React). Free tier prototyping: @google/generative-ai. Fastest time to first call: openai (best docs). Need prompt caching: @anthropic-ai/sdk (90% off cached). Multi-provider production: openai + TokenMix.ai = one SDK + 300+ models + auto failover.

What's the Bottom Line on Node.js AI SDKs?

Best Node.js AI architecture in 2026: openai SDK as universal layer + provider-specific SDKs for specialized features. TokenMix.ai endpoint provides one OpenAI-format interface to all providers — eliminates managing 3-5 npm packages. Add @anthropic-ai/sdk only when you need prompt caching for long system prompts. Add @google/generative-ai only for free-tier development. JavaScript ecosystem is mature — start with openai SDK, add others as needs grow.

The JavaScript AI API ecosystem is mature. All three major SDKs support TypeScript, streaming with async iterators, and edge runtime deployment.

For most Node.js developers, start with the openai package pointed at TokenMix.ai. You get instant access to every model through one SDK, one API key, and the familiar OpenAI interface. Add the Anthropic SDK when you need prompt caching. Add the Google SDK for free-tier development.

The best Node.js AI architecture in 2026 uses the openai SDK as the universal layer, with provider-specific SDKs for specialized features. TokenMix.ai makes this architecture simple by providing one endpoint that speaks the OpenAI format to all providers.

FAQ

Which AI API has the best Node.js SDK?

Anthropic's @anthropic-ai/sdk has the best TypeScript types and the cleanest API design. OpenAI's openai package has the broadest compatibility, working with five or more providers through base URL configuration. For most projects, the openai package is the most practical choice because of its multi-provider support.

Can I use the openai npm package with DeepSeek or Groq?

Yes. Set the baseURL option to the provider's endpoint. DeepSeek: https://api.deepseek.com, Groq: https://api.groq.com/openai/v1. Your existing code works unchanged because these providers implement the same API format. Through TokenMix.ai, you can access 300+ models from all providers with a single openai client instance.

How do I stream AI responses in Express.js?

Set response headers for Server-Sent Events (Content-Type: text/event-stream), create a streaming completion with stream: true, iterate over chunks with for await, and write each chunk as an SSE data event. See the Express.js integration section above for complete working code.

What is the best way to handle AI API errors in Node.js?

Use try/catch with specific error types. The openai package exports RateLimitError, AuthenticationError, and APIError. Anthropic's SDK has similar error classes. Always implement retry logic for rate limit errors with exponential backoff. The SDKs include automatic retry (2 attempts by default), but add custom handling for your specific requirements.

Is the Vercel AI SDK better than using provider SDKs directly?

The Vercel AI SDK is a framework on top of provider SDKs, designed for React/Next.js streaming UI. It is excellent for frontend streaming but adds abstraction. For backend services, Express.js APIs, or non-Vercel deployments, using provider SDKs directly (especially through TokenMix.ai) gives you more control and flexibility.

How much does it cost to add AI features to a Node.js app?

For a prototype: $0 using Google Gemini's free tier. For a production app with 100K requests/month at 1,500 tokens each: $132/month with GPT-4.1 mini, $33/month with Gemini Flash, $82/month with DeepSeek V4. Route through TokenMix.ai for 10-20% automatic savings through optimized provider selection.

Author: TokenMix Research Lab | Last Updated: April 2026 | Data Source: openai npm package, Anthropic TypeScript SDK, Google AI Node.js SDK + TokenMix.ai