LLM API Keys, Billing, and Security for Web Developers

import type Anthropic from "@anthropic-ai/sdk";
 
// USD per million tokens at the time of writing. Keep this in one place and update it with the pricing page.
const PRICES = {
  "claude-opus-5-5": { input: 4, output: 20, cacheRead: 0.2 },
  "claude-sonnet-5-5": { input: 2, output: 10, cacheRead: 0.2 },
  "claude-haiku-4-5": { input: 1, output: 5, cacheRead: 0.1 },
} as const;
 
export type PricedModel = keyof typeof PRICES;
 
const CACHE_WRITE_MULTIPLIER = 1.25; // 5-minute cache writes cost 1.25x the input price
 
/** Dollar cost of one response. `input_tokens` already excludes cached tokens. */
export function costUSD(model: PricedModel, usage: Anthropic.Usage): number {
  const price = PRICES[model];
  const cacheWrite = usage.cache_creation_input_tokens ?? 0;
  const cacheRead = usage.cache_read_input_tokens ?? 0;
  return (
    (usage.input_tokens * price.input +
      cacheWrite * price.input * CACHE_WRITE_MULTIPLIER +
      cacheRead * price.cacheRead +
      usage.output_tokens * price.output) /
    1_000_000
  );
}

import { Redis } from "ioredis";
 
const redis = new Redis(process.env.REDIS_URL ?? "redis://localhost:6379");
 
export class BudgetExceededError extends Error {}
 
const key = (userId: string) => `spend:${userId}:${new Date().toISOString().slice(0, 10)}`; // one key per UTC day
 
export async function assertWithinBudget(userId: string, dailyLimitUSD: number) {
  const spentMicros = Number((await redis.get(key(userId))) ?? 0);
  if (spentMicros / 1_000_000 >= dailyLimitUSD) {
    throw new BudgetExceededError(`Daily budget of $${dailyLimitUSD} reached`);
  }
}
 
export async function recordSpend(userId: string, usd: number) {
  const k = key(userId);
  await redis
    .multi()
    .incrby(k, Math.round(usd * 1_000_000))
    .expire(k, 2 * 24 * 60 * 60)
    .exec();
}

import Anthropic from "@anthropic-ai/sdk";
import { assertWithinBudget, recordSpend } from "./budget";
import { costUSD, type PricedModel } from "./cost";
 
// Reads ANTHROPIC_API_KEY from the server environment. One client per process.
export const anthropic = new Anthropic({
  timeout: 60_000, // milliseconds; generous for long answers, finite so requests cannot hang forever
  maxRetries: 2, // automatic retries with backoff on 408, 409, 429, 5xx, and connection errors
});
 
const DAILY_LIMIT_USD = 2;
 
export async function createForUser(
  userId: string,
  params: Anthropic.MessageCreateParamsNonStreaming & { model: PricedModel },
): Promise<Anthropic.Message> {
  await assertWithinBudget(userId, DAILY_LIMIT_USD);
 
  const message = await anthropic.messages.create(params);
 
  const usd = costUSD(params.model, message.usage);
  await recordSpend(userId, usd);
  console.info(
    JSON.stringify({
      event: "llm_call",
      userId,
      model: params.model,
      inputTokens: message.usage.input_tokens,
      outputTokens: message.usage.output_tokens,
      cacheReadTokens: message.usage.cache_read_input_tokens ?? 0,
      usd: Number(usd.toFixed(6)),
      stopReason: message.stop_reason,
    }),
  );
  return message;
}

import Anthropic from "@anthropic-ai/sdk";
import { BudgetExceededError } from "../../../lib/budget";
import { createForUser } from "../../../lib/llm";
 
export async function POST(request: Request) {
  // Stand-in to keep the example self-contained. NEVER trust a client-supplied header in a real app:
  // use getUserId() from your session helper (see "APIs and authentication").
  const userId = request.headers.get("x-user-id");
  if (!userId) return Response.json({ error: "Not signed in" }, { status: 401 });
  const { text } = (await request.json()) as { text: string };
 
  try {
    const message = await createForUser(userId, {
      model: "claude-sonnet-5-5",
      max_tokens: 1024,
      output_config: { effort: "low" },
      messages: [{ role: "user", content: `Summarize in two sentences:\n\n${text}` }],
    });
    const summary = message.content.flatMap((b) => (b.type === "text" ? [b.text] : [])).join("");
    return Response.json({ summary });
  } catch (error) {
    if (error instanceof BudgetExceededError) {
      return Response.json({ error: "You have reached today's limit. Try again tomorrow." }, { status: 429 });
    }
    if (error instanceof Anthropic.RateLimitError) {
      return Response.json({ error: "The assistant is busy. Please retry shortly." }, { status: 503 });
    }
    if (error instanceof Anthropic.APIError) {
      console.error("model call failed", error.status, error.message);
      return Response.json({ error: "The assistant is unavailable right now." }, { status: 502 });
    }
    throw error;
  }
}