OpenAI Billing Model

​

Why OpenAI’s Model is the Standard

1. Ingresos predecibles y bajo riesgo: Como el uso de la API se paga por adelantado, los usuarios no pueden acumular facturas que no puedan pagar. OpenAI recibe el dinero por adelantado y el usuario lo consume a medida que utiliza el servicio.
2. Escalabilidad para desarrolladores: Una recarga de $5 ofrece una barrera de entrada baja. A medida que crece una aplicación, los desarrolladores pueden automatizar las recargas o comprar paquetes más grandes. Empezar es económico y el uso puede crecer sin cambiar de plan.
3. Psicología del usuario: Los créditos denominados en dólares estadounidenses, en lugar de “tokens” o “puntos” abstractos, dejan claro el valor. El saldo funciona como una cuenta prepaga para servicios de IA, lo que facilita la elaboración de presupuestos para las empresas.

​

How OpenAI Bills

1. API (Pay-as-you-go): La API utiliza créditos prepagados denominados en dólares. Los usuarios recargan sus cuentas con $5, $10, $50 o más. Los créditos muestran un valor en dólares, pero no pueden utilizarse fuera de OpenAI. OpenAI factura por token, con diferentes tarifas para los tokens de entrada y de salida. Los créditos comprados caducan un año después de la compra y no son reembolsables (Centro de ayuda de OpenAI). Cuando el saldo llega a $0, las llamadas a la API fallan.
2. ChatGPT Plus, Business y Enterprise: Son suscripciones de tarifa fija. ChatGPT Plus cuesta $20 al mes, y el plan Business (anteriormente Team) cuesta $25 por usuario al mes cuando se factura mensualmente. Tienen límites de uso flexibles: los usuarios intensivos pasan a un modelo más pequeño en lugar de ser bloqueados.
3. Niveles de tarifas basados en el gasto: A medida que el gasto total aumenta con el tiempo, la cuenta desbloquea límites de frecuencia de la API más altos. El acceso aumenta según el historial de facturación.

​

Qué lo hace único

• Créditos denominados en moneda fiduciaria: Los créditos están en dólares estadounidenses, por lo que se perciben como dinero. Los desarrolladores pueden consultar directamente el precio de una solicitud.
• Caducidad prolongada: Los créditos comprados duran un año, lo que reduce la presión de «úsalo o piérdelo». Los usuarios se sienten cómodos recargando cantidades mayores.
• Medición multidimensional: Los tokens de entrada y de salida se registran por separado, pero se descuentan del mismo saldo. OpenAI puede establecer un precio más alto para los tokens de salida, que son más costosos que los de entrada.
• Niveles de confianza: Los límites de frecuencia que aumentan con el gasto total recompensan a los clientes a largo plazo y los animan a permanecer.

​

Ventajas estratégicas

​

Crea esto con Dodo Payments

import DodoPayments from 'dodopayments';

const client = new DodoPayments({
  bearerToken: process.env.DODO_PAYMENTS_API_KEY,
});

const session = await client.checkoutSessions.create({
  product_cart: [
    { product_id: 'pdt_credit_pack_50', quantity: 1 }
  ],
  customer: { email: 'developer@example.com' },
  return_url: 'https://yourapp.com/dashboard'
});

// requestId and customerId come from your application's request context.
await client.usageEvents.ingest({
  events: [{
    event_id: `req_${requestId}`,
    customer_id: customerId,
    event_name: 'llm.input_tokens',
    timestamp: new Date().toISOString(),
    metadata: {
      model: 'gpt-4o',
      tokens: 1500
    }
  }, {
    event_id: `req_${requestId}_out`,
    customer_id: customerId,
    event_name: 'llm.output_tokens',
    timestamp: new Date().toISOString(),
    metadata: {
      model: 'gpt-4o',
      tokens: 800
    }
  }]
});

async function checkCreditsBeforeRequest(customerId: string) {
  const balance = await client.creditEntitlements.balances.retrieve(customerId, {
    credit_entitlement_id: 'cde_your_credit_entitlement_id',
  });

  if (Number(balance.balance) <= 0) {
    throw new Error('Insufficient credits. Please top up your account.');
  }
}

import DodoPayments from 'dodopayments';
import express from 'express';

const app = express();
app.use(express.raw({ type: 'application/json' }));

const client = new DodoPayments({
  bearerToken: process.env.DODO_PAYMENTS_API_KEY,
  webhookKey: process.env.DODO_PAYMENTS_WEBHOOK_KEY,
});

// sendLowBalanceEmail is your application's own function.
app.post('/webhooks/dodo', async (req, res) => {
  try {
    const event = client.webhooks.unwrap(req.body.toString(), {
      headers: {
        'webhook-id': req.headers['webhook-id'] as string,
        'webhook-signature': req.headers['webhook-signature'] as string,
        'webhook-timestamp': req.headers['webhook-timestamp'] as string,
      },
    });

    if (event.type === 'credit.balance_low') {
      const { customer_id, available_balance } = event.data;
      await sendLowBalanceEmail(customer_id, available_balance);
    }

    res.json({ received: true });
  } catch (error) {
    res.status(401).json({ error: 'Invalid signature' });
  }
});

const session = await client.checkoutSessions.create({
  product_cart: [
    { product_id: 'pdt_plus_subscription', quantity: 1 }
  ],
  customer: { email: 'user@example.com' },
  return_url: 'https://yourapp.com/billing'
});

// getUsageForCurrentPeriod and SOFT_CAP_THRESHOLD are defined in your application.
async function checkSubscriptionUsage(customerId: string) {
  const usage = await getUsageForCurrentPeriod(customerId);
  
  if (usage > SOFT_CAP_THRESHOLD) {
    // Route to a smaller model instead of blocking
    return 'gpt-4o-mini';
  }
  
  return 'gpt-4o';
}

​

Acelera con el LLM Ingestion Blueprint

npm install @dodopayments/ingestion-blueprints

import { createLLMTracker } from '@dodopayments/ingestion-blueprints';
import OpenAI from 'openai';

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

const tracker = createLLMTracker({
  apiKey: process.env.DODO_PAYMENTS_API_KEY,
  environment: 'live_mode',
  eventName: 'llm.chat_completion',
});

// customerId and prompt come from your application.
const trackedClient = tracker.wrap({
  client: openai,
  customerId: customerId,
});

// Every API call now automatically tracks token usage
const response = await trackedClient.chat.completions.create({
  model: 'gpt-4o',
  messages: [{ role: 'user', content: prompt }],
});

// inputTokens, outputTokens, and totalTokens are sent automatically
console.log('Tokens used:', response.usage);

​

Implementación de niveles de tarifas basados en el gasto

1. Registra el gasto acumulado: Escucha los webhooks payment.succeeded y añade el importe del pago a un campo total_spend para ese cliente en tu base de datos. Los importes están en la unidad monetaria más pequeña, por lo que 5000 equivalen a $50,00.
2. Define los niveles: Asocia los importes de gasto con límites de frecuencia:
   • Nivel 1: gasto de $0 a $50 -> 3 RPM
   • Nivel 2: gasto de $50 a $250 -> 10 RPM
   • Nivel 3: gasto de más de $250 -> 50 RPM
3. Aplica los límites: En tu middleware de la API, consulta el nivel del cliente y aplica su límite de frecuencia.

// db and the TIER_*_LIMITS constants are defined in your application.
async function getRateLimitForCustomer(customerId: string) {
  const customer = await db.customers.findUnique({ where: { id: customerId } });
  const totalSpend = customer.total_spend;

  if (totalSpend >= 25000) return TIER_3_LIMITS; // $250.00
  if (totalSpend >= 5000) return TIER_2_LIMITS;  // $50.00
  return TIER_1_LIMITS;
}

​

Ejemplo completo de implementación: el proxy de la API

import DodoPayments from 'dodopayments';
import OpenAI from 'openai';

const client = new DodoPayments({
  bearerToken: process.env.DODO_PAYMENTS_API_KEY,
});
const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

export async function handleApiRequest(req, res) {
  const { customerId, prompt, model } = req.body;

  try {
    // 1. Check credit balance
    const balance = await client.creditEntitlements.balances.retrieve(customerId, {
      credit_entitlement_id: 'cde_your_credit_entitlement_id',
    });

    if (Number(balance.balance) <= 0) {
      return res.status(402).json({ error: 'Insufficient credits. Please top up.' });
    }

    // 2. Call OpenAI
    const completion = await openai.chat.completions.create({
      model: model,
      messages: [{ role: 'user', content: prompt }],
    });

    const { prompt_tokens, completion_tokens } = completion.usage;

    // 3. Ingest usage events to Dodo
    await client.usageEvents.ingest({
      events: [
        {
          event_id: `req_${completion.id}_in`,
          customer_id: customerId,
          event_name: 'llm.input_tokens',
          timestamp: new Date().toISOString(),
          metadata: { model, tokens: prompt_tokens }
        },
        {
          event_id: `req_${completion.id}_out`,
          customer_id: customerId,
          event_name: 'llm.output_tokens',
          timestamp: new Date().toISOString(),
          metadata: { model, tokens: completion_tokens }
        }
      ]
    });

    // 4. Return response to user
    res.json(completion);

  } catch (error) {
    console.error('API Error:', error);
    res.status(500).json({ error: 'Internal server error' });
  }
}

​

Gestión de casos extremos

​

Condiciones de carrera

​

Latencia de ingesta de eventos

​

Gestión de reembolsos

​

Compatibilidad con varios modelos

1. Medidores independientes: Crea un conjunto de medidores por modelo, por ejemplo gpt-4o.input_tokens y gpt-4o-mini.input_tokens, cada uno con sus propios Meter units per credit.
2. Eventos ponderados: Utiliza un medidor y multiplica tokens por un peso antes de enviar el evento. Por ejemplo, si GPT-4o cuesta 10 veces más que GPT-4o-mini, envía 10 veces más tokens para las solicitudes de GPT-4o.

​

Descripción general de la arquitectura

​

Conclusión

​

Funciones principales de Dodo utilizadas