How to Bill for LLM Inference: The Complete Guide

┌─────────────┐    ┌──────────────┐    ┌─────────────┐
│  Your App    │───>│  LLM API     │───>│  Response    │
│  (prompt)    │    │  (OpenAI,    │    │  (tokens,    │
│              │    │   Anthropic) │    │   usage)     │
└─────────────┘    └──────────────┘    └──────┬──────┘
                                              │
                                    ┌─────────▼─────────┐
                                    │  Usage Database     │
                                    │  (customer_id,      │
                                    │   tokens, model,    │
                                    │   cost, timestamp)  │
                                    └─────────┬──────────┘
                                              │
                                    ┌─────────▼──────────┐
                                    │  Billing Engine      │
                                    │  (aggregate, price,  │
                                    │   invoice, collect)   │
                                    └──────────────────────┘

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

// One ingestion pipeline, reused across requests
const search = Ingestion({
  accessToken: process.env.MACROPAY_ACCESS_TOKEN,
})
  .strategy(new LLMStrategy(openai("gpt-4o")))
  .cost((ctx) => ({
    amount: ctx.metadata.totalTokens * 0.25, // your cost, in cents
    currency: "usd",
  }))
  .ingest("research-query");

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

  // A wrapped model that meters every call to this customer
  const model = search.client({ customerId });

  const { text } = await generateText({
    model,
    system: "You answer questions with cited sources.",
    prompt: question,
  });

  return Response.json({ text });
}

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

ingestion = Ingestion(os.getenv("MACROPAY_ACCESS_TOKEN"))
strategy = ingestion.strategy(PydanticAIStrategy, "research-query")

agent = Agent("gpt-4.1-nano")

result = agent.run_sync("Summarize the latest filing for ACME Corp...")
strategy.ingest("customer_123", result)

1 credit = 1,000 tokens
Starter:    10,000 credits / month  ($29/mo)
Pro:       100,000 credits / month  ($199/mo)
Enterprise: unlimited               ($999/mo)

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

const writer = Ingestion({
  accessToken: process.env.MACROPAY_ACCESS_TOKEN,
})
  .strategy(new LLMStrategy(openai("gpt-4o")))
  .cost((ctx) => ({
    // Track real cost so margin stays visible
    amount: Math.ceil(
      ctx.metadata.inputTokens * 0.00025 +
      ctx.metadata.outputTokens * 0.001
    ),
    currency: "usd",
  }))
  .ingest("writing-assistant");

export async function generateDraft(
  customerId: string,
  type: "blog" | "email" | "copy",
  brief: string,
) {
  const model = writer.client({ customerId });

  const systemPrompts = {
    blog: "You are an expert blog writer...",
    email: "You are a professional email copywriter...",
    copy: "You are a conversion-focused marketing writer...",
  };

  const { text } = await generateText({
    model,
    system: systemPrompts[type],
    prompt: brief,
  });

  return text;
}