AI Billing

Middleware for the Vercel AI SDK that captures LLM usage, calculates exact costs, and sends normalized billing events directly to your billing platforms. Whether you’re using OpenAI, Anthropic, OpenRouter, or local models, @ai-billing ensures that every token—including prompt caching and reasoning tokens—is precisely measured and billed to the correct user.

Provider-aware metrics

Understands provider-specific metrics like reasoning tokens, prompt caching, and web search costs so you don’t miss a cent.

Flexible cost calculation

Use native provider pricing (like OpenRouter), hardcoded price maps, or real-time cost resolution via Narev.

Multiple destinations

Format and forward usage seamlessly to Stripe, Polar, OpenMeter, Lago, or your own endpoint — all at once.

Drop-in middleware

Works with wrapLanguageModel — no changes to your existing streamText / generateText calls.

Install

npm install @ai-billing/core

pnpm add @ai-billing/core

yarn add @ai-billing/core

Then, install the package for your specific AI provider (e.g., @ai-billing/openai) and your billing destination (e.g., @ai-billing/stripe). See Provider middleware below.

Quick start

1. Initialize the destination

Set up the destination where your billing events will be sent. The destination knows exactly how to format the data (e.g., converting to nano-dollars) and map your tags to the correct customer identity for that platform.

import { createStripeDestination } from '@ai-billing/stripe';

const stripeDestination = createStripeDestination({
  apiKey: process.env.STRIPE_SECRET_KEY,
  meterName: 'llm_usage',
});

2. Set up the middleware & price resolution

Initialize the provider middleware. If your provider doesn’t supply costs natively in the API response (like OpenAI or Anthropic), attach a PriceResolver to calculate the cost of the tokens.

import { createOpenAIMiddleware } from '@ai-billing/openai';
import { createNarevPriceResolver } from '@ai-billing/narev';

// Automatically fetch up-to-date model pricing
const priceResolver = createNarevPriceResolver({
  apiKey: process.env.NAREV_API_KEY,
});

const billingMiddleware = createOpenAIMiddleware({
  destinations: [stripeDestination],
  priceResolver,
});

3. Wrap your model

Apply the middleware to your language model using the Vercel AI SDK’s wrapLanguageModel.

import { wrapLanguageModel } from 'ai';
import { createOpenAI } from '@ai-sdk/openai';

const openai = createOpenAI({ apiKey: process.env.OPENAI_API_KEY });

const model = wrapLanguageModel({
  model: openai('gpt-4o'),
  middleware: billingMiddleware,
});

4. Pass tags during generation

Generate text exactly as you normally would. Use providerOptions to pass ai-billing-tags so the destination knows which customer to bill.

import { streamText } from 'ai';

const { textStream } = await streamText({
  model,
  messages: [{ role: 'user', content: 'Quantify the value of metadata.' }],
  providerOptions: {
    'ai-billing-tags': { 
      stripe_customer_id: 'cus_123', // Used by Stripe to identify the user
      org_name: 'Acme Corp',         // Attached as metadata to the meter event
    },
  },
});

Every completed request now automatically calculates the cost (including caches and reasoning) and emits a formatted event directly to Stripe.

Architecture

The library is built on three composable primitives:

Provider middlewares

Specialized middleware for each AI SDK provider (e.g., @ai-billing/openai, @ai-billing/anthropic). These understand provider-specific metadata shapes, extracting standard tokens alongside advanced metrics like inputCacheReadTokens, internalReasoningTokens, and webSearch.

Price resolvers

Functions that turn token metrics into precise financial costs. Use createNarevPriceResolver from @ai-billing/narev for live Narev rates, createObjectPriceResolver from @ai-billing/core for custom mappings, or skip this entirely if your provider (like OpenRouter or Vercel AI Gateway) reports costs natively.

Destinations

Functions that receive a normalized BillingEvent and handle the API call to an external billing service (e.g., @ai-billing/stripe, @ai-billing/polar). Destinations ensure that identity mapping, metadata constraints, and cost formatting (like cost_nanos) comply perfectly with each platform’s rules.

Packages

Every published @ai-billing package has generated TypeDoc reference docs under /sdk/ai-billing/reference/<package>/typedoc/index.

Core and integrations

Package	Role
`@ai-billing/core`	V3/V4 billing middleware, destinations, price resolvers, and shared types
`@ai-billing/narev`	Narev pricing API client and `createNarevPriceResolver`
`@ai-billing/nextjs`	Next.js chat UI, Polar/Stripe credit components, and `create*WithBilling` server factories

Provider middleware

Text model support is the current priority. Each package ships V3 and V4 middleware.

Provider	Package	Features
Alibaba	`@ai-billing/alibaba`	Caching, Reasoning
Amazon Bedrock	`@ai-billing/amazon-bedrock`	Caching
Anthropic	`@ai-billing/anthropic`	Caching
Azure	`@ai-billing/azure`	Caching, Reasoning
Baseten	`@ai-billing/baseten`
Cerebras	`@ai-billing/cerebras`	Caching, Reasoning
Chutes	`@ai-billing/chutes`	Caching
Cohere	`@ai-billing/cohere`
DeepInfra	`@ai-billing/deepinfra`	Caching
DeepSeek	`@ai-billing/deepseek`	Caching, Reasoning
Fireworks	`@ai-billing/fireworks`	Caching, Reasoning
Vercel AI Gateway	`@ai-billing/gateway`	Native pricing
GMI Cloud	`@ai-billing/gmicloud`	Caching, Reasoning
Google	`@ai-billing/google`	Caching, Reasoning
Google Vertex AI	`@ai-billing/google-vertex`	Caching, Reasoning
Groq	`@ai-billing/groq`	Caching
Hugging Face	`@ai-billing/huggingface`	Caching, Reasoning
Minimax	`@ai-billing/minimax`	Reasoning
Mistral	`@ai-billing/mistral`	Caching
Moonshot AI	`@ai-billing/moonshotai`	Caching, Reasoning
OpenAI	`@ai-billing/openai`	Caching, Search
OpenAI Compatible	`@ai-billing/openai-compatible`	Caching, Reasoning
OpenRouter	`@ai-billing/openrouter`	Native pricing
Perplexity	`@ai-billing/perplexity`	Reasoning, Search fee
Together AI	`@ai-billing/togetherai`	Reasoning
xAI	`@ai-billing/xai`	Caching, Reasoning
Z.ai	`@ai-billing/zai`	Caching, Reasoning

Billing destinations

Destination	Package	Format
Stripe	`@ai-billing/stripe`	Meter events, nano-dollars
Polar.sh	`@ai-billing/polar`	Polar events, nano-dollars
OpenMeter	`@ai-billing/openmeter`	CloudEvents
Lago	`@ai-billing/lago`	Lago events, nano-dollars
Console	`@ai-billing/core`	`consoleDestination` debug logging

Roadmap

Note: We are prioritizing support for text models.

Active development

To prioritize a provider that is not listed above, open a GitHub issue.

Reference

Core primitives

Middleware, destinations, price resolvers, and shared types in @ai-billing/core.

Narev pricing client

createNarevClient, createNarevPriceResolver, and trace cost helpers in @ai-billing/narev.

Next.js components

Chat UI, credit usage widgets, and server factories in @ai-billing/nextjs.

Full API reference

Browse the sidebar for every provider, destination, and integration package.

Overview

@ai-billing SDK

narevai/thin-ops

Introduction

AI Billing

Provider-aware metrics

Flexible cost calculation

Multiple destinations

Drop-in middleware

Install

Quick start

1. Initialize the destination

2. Set up the middleware & price resolution

3. Wrap your model

4. Pass tags during generation

Architecture

Packages

Core and integrations

Provider middleware

Billing destinations

Roadmap

Reference

Core primitives

Narev pricing client

Next.js components

Full API reference

​AI Billing

Provider-aware metrics

Flexible cost calculation

Multiple destinations

Drop-in middleware

​Install

​Quick start

​1. Initialize the destination

​2. Set up the middleware & price resolution

​3. Wrap your model

​4. Pass tags during generation

​Architecture

​Packages

​Core and integrations

​Provider middleware

​Billing destinations

​Roadmap

​Reference

Core primitives

Narev pricing client

Next.js components

Full API reference

AI Billing

Install

Quick start

1. Initialize the destination

2. Set up the middleware & price resolution

3. Wrap your model

4. Pass tags during generation

Architecture

Packages

Core and integrations

Provider middleware

Billing destinations

Roadmap

Reference