Tutorial: Billing Automatico para AI com Vercel AI SDK em 5 Minutos

Passo a passo para adicionar usage-based billing ao seu agente de IA usando Vercel AI SDK e Infinitum Pulse. Com codigo completo.

Neste tutorial, vamos sair do zero ate billing automatico funcionando em menos de 5 minutos. Voce vai precisar de: um projeto com Vercel AI SDK e uma conta no Infinitum Pulse.

Pre-requisitos

Node.js 18+
Um projeto usando ai package (Vercel AI SDK)
Conta no Infinitum Pulse (gratis durante beta)

Step 1: Instalar o SDK

npm install @beinfi/pulse-sdk

O pacote exporta duas coisas:

@beinfi/pulse-sdk — client principal para tracking e customer management
@beinfi/pulse-sdk/ai — middleware para Vercel AI SDK

Step 2: Criar Produto e Meters

No dashboard do Pulse, crie:

Produto: “Meu AI Agent”
Meter 1: input_tokens — Display: “Input Tokens” — Unit: “tokens” — Preco: $0.003/1K
Meter 2: output_tokens — Display: “Output Tokens” — Unit: “tokens” — Preco: $0.008/1K

Anote o Product ID e a API Key (comeca com sk_live_ ou sk_test_).

Step 3: Configurar Variaveis de Ambiente

# .env
PULSE_API_KEY=sk_test_xxxxxxxxxxxxx
PULSE_PRODUCT_ID=prod_xxxxxxxxxxxxx
OPENAI_API_KEY=sk-xxxxxxxxxxxxx

Step 4: Adicionar o Middleware

Aqui e onde a magica acontece. O middleware intercepta todas as chamadas ao modelo e rastreia tokens automaticamente.

// lib/ai.ts
import { Pulse } from '@beinfi/pulse-sdk'
import { pulseMiddleware } from '@beinfi/pulse-sdk/ai'
import { wrapLanguageModel } from 'ai'
import { openai } from '@ai-sdk/openai'

const pulse = new Pulse(process.env.PULSE_API_KEY!)

export function createBilledModel(customerId: string) {
  return wrapLanguageModel({
    model: openai('gpt-4o'),
    middleware: pulseMiddleware({
      pulse,
      customerId,
      meters: {
        input: 'input_tokens',
        output: 'output_tokens',
      },
    }),
  })
}

Step 5: Usar o Modelo no seu App

Com generateText (chamada unica)

import { generateText } from 'ai'
import { createBilledModel } from '@/lib/ai'

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

  const model = createBilledModel(userId)

  const { text } = await generateText({
    model,
    prompt,
  })

  return Response.json({ text })
}

Com streamText (streaming)

import { streamText } from 'ai'
import { createBilledModel } from '@/lib/ai'

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

  const model = createBilledModel(userId)

  const result = streamText({
    model,
    messages,
  })

  // Tokens sao rastreados quando o stream finaliza
  return result.toDataStreamResponse()
}

Com generateObject (structured output)

import { generateObject } from 'ai'
import { createBilledModel } from '@/lib/ai'
import { z } from 'zod'

const model = createBilledModel(userId)

const { object } = await generateObject({
  model,
  schema: z.object({
    summary: z.string(),
    sentiment: z.enum(['positive', 'negative', 'neutral']),
    topics: z.array(z.string()),
  }),
  prompt: `Analyze this review: "${reviewText}"`,
})

// Tokens rastreados automaticamente, incluindo os
// tokens extras do schema enforcement

Step 6: Registrar Clientes

Quando um usuario se cadastra no seu app, registre-o como customer:

// lib/pulse.ts
import { Pulse } from '@beinfi/pulse-sdk'

const pulse = new Pulse(process.env.PULSE_API_KEY!)

export async function registerCustomer(user: {
  id: string
  name: string
  email: string
}) {
  await pulse.metering.createCustomer(process.env.PULSE_PRODUCT_ID!, {
    externalId: user.id,
    name: user.name,
    email: user.email,
    metadata: {
      plan: 'free',
      source: 'signup',
    },
  })
}

Step 7: Consultar Uso (Opcional)

Se voce quer mostrar consumo no seu dashboard:

// api/usage/route.ts
import { Pulse } from '@beinfi/pulse-sdk'

const pulse = new Pulse(process.env.PULSE_API_KEY!)

export async function GET(req: Request) {
  const url = new URL(req.url)
  const userId = url.searchParams.get('userId')!

  const usage = await pulse.metering.getUsage({
    customerId: userId,
  })

  return Response.json(usage)
}

Response:

{
  "data": [
    {
      "meterId": "input_tokens",
      "meterName": "Input Tokens",
      "totalValue": "1523400",
      "count": 342
    },
    {
      "meterId": "output_tokens",
      "meterName": "Output Tokens",
      "totalValue": "487200",
      "count": 342
    }
  ]
}

Step 8: Pronto! O Que Acontece Agora?

Com tudo configurado, o fluxo automatico e:

Dia a dia: Cada chamada ao modelo rastreia tokens via middleware
Final do mes: Infinitum agrega uso por customer
Fatura gerada: Line items detalhados (input tokens, output tokens)
Link de pagamento: Enviado automaticamente ao customer
Pagamento: Customer paga em USDC/USDT via link
Voce recebe: Funds na sua carteira, settlement instantaneo

Verificando que Funciona

Teste local

// test-billing.ts
import { createBilledModel } from './lib/ai'
import { generateText } from 'ai'

async function test() {
  const model = createBilledModel('test_user_123')

  const { text, usage } = await generateText({
    model,
    prompt: 'Explique quantum computing em 2 frases.',
  })

  console.log('Response:', text)
  console.log('Tokens:', usage)
  console.log('Check your Pulse dashboard for the tracked event!')
}

test()

No dashboard

Apos rodar o teste, va ao dashboard do Pulse e voce vera:

O evento de metering registrado
Tokens de input e output separados
Customer associado
Valor calculado com base nos precos definidos

Multi-Model Billing

Se seu agente usa modelos diferentes, configure middlewares separados:

import { Pulse } from '@beinfi/pulse-sdk'
import { pulseMiddleware } from '@beinfi/pulse-sdk/ai'
import { wrapLanguageModel } from 'ai'
import { openai } from '@ai-sdk/openai'
import { anthropic } from '@ai-sdk/anthropic'

const pulse = new Pulse(process.env.PULSE_API_KEY!)

// GPT-4o — mais caro
export const gpt4o = (customerId: string) =>
  wrapLanguageModel({
    model: openai('gpt-4o'),
    middleware: pulseMiddleware({
      pulse,
      customerId,
      meters: {
        input: 'gpt4o_input',   // $0.005/1K
        output: 'gpt4o_output', // $0.015/1K
      },
    }),
  })

// GPT-4o-mini — mais barato
export const gpt4oMini = (customerId: string) =>
  wrapLanguageModel({
    model: openai('gpt-4o-mini'),
    middleware: pulseMiddleware({
      pulse,
      customerId,
      meters: {
        input: 'gpt4o_mini_input',   // $0.00015/1K
        output: 'gpt4o_mini_output', // $0.0006/1K
      },
    }),
  })

// Claude Sonnet
export const claude = (customerId: string) =>
  wrapLanguageModel({
    model: anthropic('claude-sonnet-4-5-20250929'),
    middleware: pulseMiddleware({
      pulse,
      customerId,
      meters: {
        input: 'claude_input',   // $0.003/1K
        output: 'claude_output', // $0.015/1K
      },
    }),
  })

Session-Based Tracking

Para agentes que fazem multiplas chamadas por “sessao” (ex: agent loops):

import { Pulse } from '@beinfi/pulse-sdk'

const pulse = new Pulse(process.env.PULSE_API_KEY!)

async function runAgent(userId: string, task: string) {
  // Cria uma sessao que acumula eventos
  const session = pulse.metering.session(userId)

  // Loop do agente (multiplas chamadas)
  for (const step of agentPlan) {
    const result = await executeStep(step)
    session.track('input_tokens', result.inputTokens)
    session.track('output_tokens', result.outputTokens)
    session.track('tool_calls', result.toolCalls)
  }

  // Envia tudo de uma vez como batch
  await session.end()
}

Conclusao

Em menos de 5 minutos voce tem:

Tracking automatico de tokens por usuario
Billing que roda sozinho no final do mes
Pagamento via crypto com settlement instantaneo
Zero impacto na latencia do seu AI

O codigo completo esta disponivel no nosso GitHub. Qualquer duvida, entre no nosso Discord.