AI/LLM Billing Setup

If you ship an AI feature, your costs scale with every prompt — but your revenue usually doesn’t. This guide closes that gap. You’ll wire up a meter that counts tokens for you, attach it to a product, and let Macropay turn raw usage into invoices automatically. As your Merchant of Record, Macropay also collects and remits sales tax and VAT on every charge and absorbs PCI scope, so the only thing left for you to build is the AI itself. By the end you’ll have:

Automatic token metering — no manual counting, no usage cron jobs.
Usage-based invoices — customers pay for exactly what they consume.
Live margin visibility — billed revenue vs. upstream model cost, per customer.

Before you start

You’ll need:

A Macropay account with an organization.
An Organization Access Token for API calls.
A model provider key (OpenAI, Anthropic, etc.).

Build against the Sandbox first. It mirrors production but never moves real money, so you can replay token events freely while you tune pricing.

How the pieces fit together

Three objects do the work. Once they exist, your app only emits events:

Object	Role
Meter	Aggregates ingested events into a billable number per customer per period.
Metered price	Maps that number to money (e.g. `$0.02` per 1k tokens).
Product	The subscription customers sign up for; carries the metered price.

Install the SDK

npm install @macropayments/ingestion @macropayments/sdk ai @ai-sdk/openai

pnpm add @macropayments/ingestion @macropayments/sdk ai @ai-sdk/openai

pip install macropay pydantic-ai

Create a meter

In the dashboard, open Usage Based Billing → Meters and click Create Meter. For a support copilot that bills on tokens:

Name: copilot-tokens
Filter: events named copilot-tokens
Aggregation: sum over the totalTokens property

The meter now tallies every matching event, grouped by customer and billing period.

Attach a metered price

Go to Products, create a new subscription product (or edit one), and add a Metered Price:

Meter: copilot-tokens
Unit price: the price of one metered unit — here, one token
Billing interval: Monthly

Unit price is per single unit, not per thousand. The meter sums raw totalTokens, so if you want to charge

0.02 per 1,000 tokens the unit price is `

0.02 / 1000 = $0.00002. Entering 0.02` bills a thousand times too much.Macropay sums the exact fractional amounts and rounds once, at invoice time — so sub-cent unit prices are safe and do not lose precision.

Anyone subscribed to this product is now billed on real consumption, settled at period end.

Wrap your model

The @macropayments/ingestion library tracks token counts off any @ai-sdk/* model and ships them to the meter for you — no manual event payloads.

import { Ingestion } from "@macropayments/ingestion";
import { LLMStrategy } from "@macropayments/ingestion/strategies/LLM";
import { openai } from "@ai-sdk/openai";

export const llmIngestion = Ingestion({
  accessToken: process.env.MACROPAY_ACCESS_TOKEN!,
})
  .strategy(new LLMStrategy(openai("gpt-4o")))
  .ingest("copilot-tokens");

import os
from macropay.ingestion import Ingestion
from macropay.ingestion.strategies import PydanticAIStrategy

ingestion = Ingestion(os.environ["MACROPAY_ACCESS_TOKEN"])
strategy = ingestion.strategy(PydanticAIStrategy, "copilot-tokens")

Call it from your route

Pass customerId so usage lands on the right account. Every generateText / streamText call emits an event automatically.

import { generateText } from "ai";
import { llmIngestion } from "@/lib/llm";

export async function POST(req: Request) {
  const { prompt, customerId }: { prompt: string; customerId: string } =
    await req.json();

  // Attribute every token to this customer's meter
  const model = llmIngestion.client({ customerId });

  const { text } = await generateText({
    model,
    system: "You are a customer-support copilot.",
    prompt,
  });

  return Response.json({ text });
}

from fastapi import FastAPI
from pydantic import BaseModel
from pydantic_ai import Agent
from llm import strategy

app = FastAPI()
agent = Agent("gpt-4o")

class ChatRequest(BaseModel):
    prompt: str
    customer_id: str

@app.post("/api/chat")
async def chat(req: ChatRequest):
    result = agent.run_sync(req.prompt)

    # Forward token usage to the meter for billing
    strategy.ingest(req.customer_id, result)

    return {"text": result.output}

Watch it land

Events show up within seconds. Open Usage Based Billing → Meters, pick copilot-tokens, and you’ll see per-customer totals and the running aggregate for the current period. Customers see their own projected charges in the customer portal — no support ticket required.

Billing runs itself

At the close of each period, Macropay:

Reads each customer’s aggregated meter value.
Multiplies it by your metered price.
Charges the payment method on file.
Issues a tax-compliant invoice as Merchant of Record.

That last step matters: because Macropay is the seller of record, the correct sales tax or VAT is calculated, collected, and remitted for you, and it’s our name on the customer’s statement — not yours. No billing cron, no tax engine to maintain.

Protect your margin

Token revenue only helps if it beats token cost. Record your upstream spend in a _cost block on the event, and Macropay tracks it next to the billed amount:

src/lib/llm.ts

import { Macropay } from "@macropayments/sdk";

const macropay = new Macropay({
  accessToken: process.env.MACROPAY_ACCESS_TOKEN!,
});

// gpt-4o list price: $2.50 / 1M input, $10.00 / 1M output.
// _cost.amount is in CENTS, so $2.50 per million = 250¢ per million
// = 0.00025¢ per input token, and 1000¢ per million = 0.001¢ per output token.
const amount =
  usage.prompt_tokens * 0.00025 + usage.completion_tokens * 0.001;

await macropay.events.ingest({
  events: [
    {
      name: "copilot-tokens",
      externalCustomerId: customerId,
      metadata: {
        totalTokens: usage.total_tokens,
        _cost: { amount, currency: "usd" },
      },
    },
  ],
});

Do not round or Math.ceil the amount. _cost.amount accepts decimals down to 12 places precisely so sub-cent costs stay exact — a typical completion costs a fraction of a cent, and rounding each event up to 1¢ inflates a high-volume month by 100× or more. Macropay sums the exact values and rounds once.

Routing through the AI Proxy instead? Then skip all of this — the proxy writes _cost for you, with the provider cost and your margin already separated.

Open Cost Insights to see margin per customer at a glance, and catch the power user who’s quietly running you into the red.

Selling an autonomous agent rather than a chat box? Bill on outcomes — a resolved ticket, a booked meeting, a closed deal — instead of raw tokens. The Signals API ingests activity and outcome signals and emits value receipts that certify the ROI behind each charge.

Option B: let the AI Proxy meter for you

Everything above assumes you count tokens yourself and ingest your own events. If you route model calls through the AI Proxy instead, metering is automatic — and you should not hand-roll a meter, because the proxy emits its own event shape and a meter filtered on anything else will silently match nothing and bill zero. The contract. Every completion writes one event:

Field	Value
`name`	`ai.completion` — exactly this, always
`source`	`user` (system events are excluded from billing)
properties	`model`, `provider`, `prompt_tokens`, `completion_tokens`, `cached_tokens`, `cache_creation_tokens`, `reasoning_tokens`, `total_tokens`, `estimated`
`_cost`	`amount_cents` (exact fractional cents billed), `base` (provider cost), `margin` (your markup), `amount` (same as `base + margin`, in microcents), `currency`

Property names are snake_case. totalTokens will not match anything. You get two meters for free. The first time you add a model config, Macropay creates both of these for the organization:

AI Usage — sums _cost.amount_cents, i.e. what the call cost including your margin. Attach a metered price with a unit price of $0.01** for exact pass-through (1 unit = 1¢ of spend), or **$ 0.012 to take a further 20% on top of the margin already configured per model.
AI Token Usage — sums total_tokens. Attach this instead if you’d rather price per token and ignore what the model actually cost you.

Attach a price to one of those rather than creating a third meter.

Configuring a model records your upstream cost (what the provider charges you), not the price your customer pays. The customer-facing amount is base + ceil(base × margin_pct / 100). So a model entered at

2.50/1M with the default 20% margin bills your customer

3.00/1M. If you meant $2.50 to be the customer price, set the rate to your real provider cost and let the margin do the rest.

Where to go next

Usage-based billing

The full model behind meters, events, and aggregation.

Ingestion strategies

Stream, S3, delta-time, and custom event sources.

Prepaid credits

Grant credits and draw them down against any meter.

Cost insights

Track upstream model spend and per-customer margin.

Bootup

Features

Integrate

Merchant of Record (MoR)

AI/LLM Billing Setup

Before you start

How the pieces fit together

Watch it land

Billing runs itself

Protect your margin

Option B: let the AI Proxy meter for you

Where to go next

Usage-based billing

Ingestion strategies

Prepaid credits

Cost insights

​Before you start

​How the pieces fit together

​Watch it land

​Billing runs itself

​Protect your margin

​Option B: let the AI Proxy meter for you

​Where to go next

Usage-based billing

Ingestion strategies

Prepaid credits

Cost insights

Before you start

How the pieces fit together

Watch it land

Billing runs itself

Protect your margin

Option B: let the AI Proxy meter for you

Where to go next