How to Track AI Costs Per User with the Vercel AI SDK

What the Vercel AI SDK gives you, and what it does not

Every core call in the AI SDK returns a usage object with the token counts for that request. That is the raw material for cost. What it is missing is everything that turns tokens into a business number: no user dimension, no dollar conversion, no per-feature breakdown, and no idea what each customer pays you. The SDK is a great client. It is not a cost or margin tool, and it does not pretend to be.

So the per-user layer lives on your side of the wire, built from the usage the SDK already gives you. The good news is that the usage is right there on every call. You just have to catch it and tag it.

Get token usage from generateText and streamText

For a normal (non-streamed) call, the usage is on the result. Await the call and read it:

import { generateText } from 'ai'
import { openai } from '@ai-sdk/openai'

const { text, usage } = await generateText({
  model: openai('gpt-4o-mini'),
  messages,
})

// usage: { inputTokens, outputTokens, totalTokens }
// (older AI SDK versions call these promptTokens / completionTokens)

Streaming is where people get it wrong, and it matters because streaming is the default for chat UIs. A streamed response has no final token counts until it finishes, so reading usage too early misses every output token. The SDK solves this with the onFinish callback, which fires once the stream completes with the full usage:

import { streamText } from 'ai'
import { openai } from '@ai-sdk/openai'

const result = streamText({
  model: openai('gpt-4o-mini'),
  messages,
  onFinish: ({ usage }) => {
    // this is the ONLY reliable place to record a streamed call's cost
    recordUsage(usage)
  },
})

return result.toDataStreamResponse()

If you take one thing from this article: for streaming, record cost in onFinish, never before. This one gap is why so many teams think their streaming features are cheaper than they are. There is a whole deeper problem here covered in how to track AI costs per user.

Attribute the cost to a user

Usage on its own is an anonymous number. To make it useful, attach the user you already have in context and turn tokens into dollars. Grab the current rate from the provider pricing page and compute:

const PRICES = {
  'gpt-4o-mini': { in: 0.15, out: 0.60 },   // USD per 1M tokens
  'gpt-4o':      { in: 2.5,  out: 10 },
}

function costUsd(model, inputTokens, outputTokens) {
  const p = PRICES[model]
  return (inputTokens * p.in + outputTokens * p.out) / 1_000_000
}

// inside onFinish (or after generateText):
await db.aiUsage.insert({
  userId: session.user.id,       // you have this. The SDK does not.
  feature: 'chat',
  model: 'gpt-4o-mini',
  inputTokens: usage.inputTokens,
  outputTokens: usage.outputTokens,
  costUsd: costUsd('gpt-4o-mini', usage.inputTokens, usage.outputTokens),
  createdAt: new Date(),
})

Do that on every call and you can finally answer the real question with a group-by: sum costUsd per userId for the month, sort descending, and the top of that list is where your margin is going.

Why the do-it-yourself version quietly rots

The snippet above works for a week. Then reality sets in. Providers reprice every few months and your hardcoded table goes stale silently, so your reported cost drifts from your real bill. You add an anthropic model for one feature and a google model for another, and now you are maintaining three pricing tables with three different token accounting rules. Then you want margin per user, not just cost, so you join against subscriptions, prorate mid-month plan changes, and spend a Friday debugging why an upgraded customer shows the wrong revenue. This is the point where most teams give up and go back to staring at the account total.

Track per-user cost with Weckr

Weckr does that layer for you. Because the AI SDK abstracts the raw provider client away, the clean integration is to forward the usage event you already have in onFinish, tagged with your user and plan. Weckr recomputes the cost server side from current pricing (so it never drifts), stores it per user and per feature, and figures margin against the plan:

const result = streamText({
  model: openai('gpt-4o-mini'),
  messages,
  onFinish: async ({ usage }) => {
    await fetch('https://useweckr.com/api/v1/log', {
      method: 'POST',
      headers: {
        'content-type': 'application/json',
        'x-api-key': process.env.WECKR_API_KEY,
      },
      body: JSON.stringify({
        userId: session.user.id,
        feature: 'chat',
        model: 'gpt-4o-mini',
        provider: 'openai',
        inputTokens: usage.inputTokens,
        outputTokens: usage.outputTokens,
        planName: user.plan,
        planRevenueUsd: PLAN_PRICES[user.plan],
      }),
    })
  },
})

If instead you call a provider client directly anywhere in your app (not through the AI SDK model abstraction), you can wrap that call in two lines with wk.chat(openai, ...) and skip the manual log entirely. Either way you get cost and margin per user and per feature, model and pricing recommendations, and per-user spending caps that stop a heavy user from running your bill past what they pay. See it on seeded data, no signup, at useweckr.com/demo, and model your plan against real costs with the break-even calculator.

FAQ

Ship the feature, keep the margin

The Vercel AI SDK removed the friction of calling a model. The cost of that is how easy it is to ship an AI feature without ever seeing what it does to your unit economics. Catch the usage on every call, attribute it to a user, and you turn an anonymous monthly bill into a decision about who to price up, cap, or celebrate. This is one step in the complete guide to AI cost and margin management. See your own per-user numbers at useweckr.com/demo.