How to integrate the OpenAI API in a Next.js SaaS without blowing up costs

~
// lib/ai/client.ts
import OpenAI from "openai";

const openai = new OpenAI({
apiKey: process.env.OPENAI_API_KEY,
baseURL: "https://oai.helicone.ai/v1",
defaultHeaders: {
  "Helicone-Auth": `Bearer ${process.env.HELICONE_API_KEY}`,
},
});

// Prices per 1M tokens (input / output). Update when OpenAI changes them.
const PRICING: Record<string, { input: number; output: number }> = {
"gpt-4o":        { input: 2.50,  output: 10.00 },
"gpt-4o-mini":   { input: 0.15,  output: 0.60 },
"o3-mini":       { input: 1.10,  output: 4.40 },
};

export async function callLLM(opts: {
tenantId: string;
model: keyof typeof PRICING;
messages: OpenAI.ChatCompletionMessageParam[];
temperature?: number;
}) {
const start = Date.now();
const res = await openai.chat.completions.create({
  model: opts.model,
  messages: opts.messages,
  temperature: opts.temperature ?? 0.2,
}, {
  headers: { "Helicone-User-Id": opts.tenantId },
});
const latencyMs = Date.now() - start;

const u = res.usage!;
const pricing = PRICING[opts.model];
const costUsd =
  (u.prompt_tokens / 1_000_000) * pricing.input +
  (u.completion_tokens / 1_000_000) * pricing.output;

// Local log — Helicone also stores, this is redundancy for the internal dashboard
await logAiCall({
  tenantId: opts.tenantId,
  model: opts.model,
  promptTokens: u.prompt_tokens,
  completionTokens: u.completion_tokens,
  costUsd,
  latencyMs,
});

return { content: res.choices[0].message.content, usage: u, costUsd };
}

~
// lib/ai/routing.ts
type TaskType = "classify" | "extract" | "summarize" | "generate" | "reason";

const MODEL_FOR_TASK: Record<TaskType, "gpt-4o" | "gpt-4o-mini" | "o3-mini"> = {
classify:  "gpt-4o-mini",
extract:   "gpt-4o-mini",
summarize: "gpt-4o-mini",
generate:  "gpt-4o",
reason:    "o3-mini",
};

export function modelFor(task: TaskType) {
return MODEL_FOR_TASK[task];
}

~
await callLLM({
tenantId,
model: modelFor("classify"),
messages: [...]
});

~
// lib/ai/cache.ts
import { Redis } from "@upstash/redis";
import crypto from "node:crypto";

const redis = Redis.fromEnv();

function cacheKey(input: { model: string; messages: any[]; temperature: number }) {
const hash = crypto.createHash("sha256").update(JSON.stringify(input)).digest("hex");
return `ai:cache:${hash}`;
}

export async function cachedCallLLM(opts: Parameters<typeof callLLM>[0]) {
// Cache only when the response is deterministic
const isDeterministic = (opts.temperature ?? 0.2) === 0 || opts.temperature === 0.2;
if (!isDeterministic) return callLLM(opts);

const key = cacheKey({ model: opts.model, messages: opts.messages, temperature: opts.temperature ?? 0.2 });
const cached = await redis.get<string>(key);
if (cached) {
  // Hit — cost = 0, latency = <10ms
  return { content: cached, usage: { prompt_tokens: 0, completion_tokens: 0 }, costUsd: 0, cached: true };
}

const result = await callLLM(opts);
await redis.set(key, result.content, { ex: 60 * 60 * 24 * 7 }); // TTL 7 days
return { ...result, cached: false };
}

~
// app/api/chat/route.ts
import { openai } from "@/lib/ai/client";

export async function POST(req: Request) {
const { messages, tenantId } = await req.json();

const stream = await openai.chat.completions.create({
  model: "gpt-4o-mini",
  messages,
  stream: true,
}, { headers: { "Helicone-User-Id": tenantId } });

const encoder = new TextEncoder();
const readable = new ReadableStream({
  async start(controller) {
    for await (const chunk of stream) {
      const content = chunk.choices[0]?.delta?.content;
      if (content) controller.enqueue(encoder.encode(content));
    }
    controller.close();
  },
});

return new Response(readable, {
  headers: { "Content-Type": "text/event-stream" },
});
}

~
const res = await fetch("/api/chat", { method: "POST", body: JSON.stringify({ messages, tenantId }) });
const reader = res.body!.getReader();
const decoder = new TextDecoder();

while (true) {
const { done, value } = await reader.read();
if (done) break;
const chunk = decoder.decode(value);
setOutput((prev) => prev + chunk);
}

~
// lib/ai/rate-limit.ts
import { Ratelimit } from "@upstash/ratelimit";
import { Redis } from "@upstash/redis";

const redis = Redis.fromEnv();

export const aiLimiter = new Ratelimit({
redis,
limiter: Ratelimit.slidingWindow(60, "1 m"), // 60 requests/min per tenant
analytics: true,
prefix: "rl:ai",
});

export async function assertAiLimit(tenantId: string) {
const { success, limit, reset, remaining } = await aiLimiter.limit(tenantId);
if (!success) {
  const error: any = new Error("Rate limit exceeded");
  error.status = 429;
  error.headers = {
    "X-RateLimit-Limit": String(limit),
    "X-RateLimit-Remaining": String(remaining),
    "Retry-After": String(Math.ceil((reset - Date.now()) / 1000)),
  };
  throw error;
}
}

~
await assertAiLimit(tenantId);
const result = await cachedCallLLM({...});

~
// lib/ai/budget.ts
async function tenantMonthSpend(tenantId: string): Promise<number> {
const month = new Date().toISOString().slice(0, 7); // YYYY-MM
const key = `spend:${tenantId}:${month}`;
const v = await redis.get<number>(key);
return v ?? 0;
}

async function addSpend(tenantId: string, usd: number) {
const month = new Date().toISOString().slice(0, 7);
const key = `spend:${tenantId}:${month}`;
await redis.incrbyfloat(key, usd);
await redis.expire(key, 60 * 60 * 24 * 40); // expire after 40 days
}

const TENANT_MONTHLY_CAP_USD = 50; // configurable per plan

export async function assertBudget(tenantId: string) {
const spend = await tenantMonthSpend(tenantId);
if (spend >= TENANT_MONTHLY_CAP_USD) {
  const error: any = new Error("Monthly AI budget exceeded");
  error.status = 402; // Payment Required
  throw error;
}
}

export async function recordSpend(tenantId: string, costUsd: number) {
await addSpend(tenantId, costUsd);
if ((await tenantMonthSpend(tenantId)) > TENANT_MONTHLY_CAP_USD * 0.8) {
  // Notify slack/email when a tenant hits 80% of the cap
  await notifyApproachingCap(tenantId);
}
}

~
await assertAiLimit(tenantId);
await assertBudget(tenantId);

const result = await cachedCallLLM({...});

await recordSpend(tenantId, result.costUsd);