Anthropic TypeScript SDK

It's @anthropic-ai/sdk on npm. Anthropic's official TypeScript client for talking to Claude without pulling your hair out. About 2 million weekly downloads because apparently other people also got tired of janky wrappers.

Switched to this after LangChain decided to break our chat app again. LangChain has this fun habit of fucking up function calling every few weeks with zero warning. Watching production chat return 400s to paying customers gets old real fast.

Why It Doesn't Suck Like Everything Else

Streaming doesn't randomly shit the bed - Uses Server Sent Events like a normal person. Third-party wrappers buffer everything then vomit it all at once. This one actually streams like you'd expect.

Had OpenAI's SDK drop connections mid-response on our customer support chat. Spent 4 hours debugging only to find out their SSE implementation is hot garbage. This one hasn't pulled that shit yet.

TypeScript types don't lie to your face - Sounds basic but you'd be shocked how many SDKs get this wrong. Vercel's AI SDK swore max_tokens was optional. Spoiler alert: it fucking wasn't. API kept spitting out 400s.

The official types for model names and parameters actually work in IntelliSense without making you want to rage quit.

Function calling doesn't require a computer science degree - Got database integration working in 30 minutes instead of the 2 days I wasted on LangChain's agent clusterfuck. The tool use examples actually copy-paste and work. Imagine that.

Error messages aren't complete garbage - When stuff breaks, you get BadRequestError or RateLimitError with actual request IDs for support tickets. No more "oops something went wrong" bullshit.

Runtime Support (What Actually Works)

Runs on Node 18+, Bun, Deno, and Cloudflare Workers. Browser support exists with dangerouslyAllowBrowser: true but please don't be the asshole who commits API keys to git and ends up on r/badcode.

Cloudflare Workers has a 10MB memory limit that Claude can blow past with large responses. Everything else works fine though.

How It's Built (For The Curious)

Built on fetch API with retry logic and exponential backoff. Sometimes retries 400 errors way longer than it should but whatever, it mostly works.

Has auto-pagination for batch endpoints and timeout scaling for large token requests. The examples directory has working code you can copy.

Getting Started (The Easy Part)

npm install @anthropic-ai/sdk

Grab your API key from console.anthropic.com and stuff it in an environment variable. Seriously, don't be the dev who commits secrets to git and gets their company on HackerNews.

export ANTHROPIC_API_KEY=\"sk-ant-api03-...\"

If you're using dotenv, call config() before importing the SDK or your env vars won't load. This dumb mistake cost me 3 hours at 2am because I'm an idiot:

// Do this or hate yourself
require('dotenv').config();
import Anthropic from '@anthropic-ai/sdk';

// This will fuck you over
import Anthropic from '@anthropic-ai/sdk';
require('dotenv').config(); // Too fucking late

Basic Usage

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

const client = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
  maxRetries: 3,
  timeout: 60000, // 60 seconds
});

const message = await client.messages.create({
  max_tokens: 1024,
  messages: [{ role: 'user', content: 'Hello, Claude' }],
  model: 'claude-3-5-sonnet-20240620',
});

Short responses take a few seconds. Long ones can take forever. If you're handling web requests, use streaming or users will think your app died and leave angry reviews.

Streaming Setup

const stream = client.messages
  .stream({
    model: 'claude-3-5-sonnet-20240620',
    max_tokens: 2048,
    messages: [{ role: 'user', content: 'Write something long' }],
  })
  .on('text', (text) => {
    console.log(text);
  })
  .on('error', (error) => {
    console.error('Stream died:', error);
  });

const finalMessage = await stream.finalMessage();

Platform gotchas that'll bite you in the ass:

• Vercel Edge Functions timeout after 25 seconds (learned this the hard way)
• Railway kills long streams without warning (cost us 2 hours of debugging)
• Lambda runs out of memory with large responses (500MB+ easily)

Error handling for network blips:

stream.on('error', async (error) => {
  if (error.code === 'ECONNRESET') {
    console.log('Stream reset, retrying...');
    // Add retry logic here
  } else {
    throw error;
  }
});

Production Config

const client = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
  maxRetries: 5,
  timeout: 300000, // 5 minutes
  defaultHeaders: {
    'User-Agent': 'your-app/1.0.0'
  }
});

Shit that will break in production and ruin your day:

• Rate limits start at 50 requests/minute for new accounts (fucking brutal)
• Memory usage spikes to 500MB+ during large token processing
• Function calling hits character limits for tool descriptions (no error, just fails)
• Model names occasionally change without notice (because of course they do)

Error Handling

import { RateLimitError, APIError } from '@anthropic-ai/sdk';

try {
  const message = await client.messages.create(params);
} catch (error) {
  if (error instanceof RateLimitError) {
    const retryAfter = error.headers['retry-after'] || 60;
    console.log(`Rate limited, waiting ${retryAfter}s`);
    await new Promise(resolve => setTimeout(resolve, retryAfter * 1000));
  } else if (error instanceof APIError) {
    console.error(`API Error ${error.status}:`, error.message);
    console.error('Request ID:', error.headers['request-id']); // Save this for support
  }
}

Common errors:

• ENOTFOUND api.anthropic.com - DNS issues
• maximum tokens exceeded - even with max_tokens set
• model not found - they rename models sometimes
• Various 500 errors with request IDs for support

Track request IDs and response times. Tools like DataDog or Sentry help catch issues before users complain.