OpenAI Billing Model

​

Por qué el modelo de OpenAI es el estándar

1. Ingresos predecibles y bajo riesgo: Al exigir créditos prepago para el uso de la API, OpenAI elimina el riesgo de que los usuarios acumulen facturas enormes que no pueden pagar. Obtienes el dinero por adelantado y el usuario obtiene el servicio conforme lo usa.
2. Escalabilidad para desarrolladores: Una recarga de $5 es una barrera de entrada baja. A medida que su aplicación crece, los desarrolladores pueden automatizar recargas o comprar paquetes más grandes. La fricción para empezar es casi nula, pero el potencial de crecimiento es ilimitado.
3. Psicología del usuario: Denominar los créditos en moneda fiduciaria (USD) en lugar de conceptos abstractos como “tokens” o “puntos” deja claro el valor. Se siente como una cuenta bancaria para servicios de IA, lo que genera confianza y facilita la planificación presupuestaria para las empresas.

​

Cómo factura OpenAI

1. API (pago por uso): La API usa créditos prepago denominados en moneda fiduciaria. Los usuarios recargan sus cuentas con $5, $10, $50 o más. Estos créditos muestran un valor en dólares, pero no tienen valor monetario fuera de OpenAI. OpenAI factura por token con tarifas diferentes para los tokens de entrada y de salida. Los créditos nunca expiran, y cuando el saldo de un usuario llega a $0, sus llamadas a la API fallan inmediatamente.
2. ChatGPT Plus, Team y Enterprise: Son suscripciones de tarifa plana. ChatGPT Plus cuesta $20 al mes, mientras que el plan Team es $25 por usuario al mes. Estos planes tienen límites suaves de uso donde los usuarios se degradan a un modelo más pequeño en lugar de ser bloqueados.
3. Niveles de tarifa basados en gasto: A medida que gastas más dinero en total con el tiempo, desbloqueas límites de tasa más altos para la API. Este es un sistema de escalado basado en la confianza vinculado directamente a tu historial de facturación.

​

Qué lo hace único

• Créditos denominados en moneda fiduciaria: Los créditos se sienten como dinero porque están denominados en USD. Esto hace que los precios sean transparentes y fáciles de entender para los desarrolladores.
• Sin vencimiento: Los saldos que nunca expiran reducen la presión de “úsalo o piérdelo”. Los usuarios se sienten cómodos recargando cantidades mayores porque saben que el valor no desaparecerá.
• Medición multidimensional: Los tokens de entrada y de salida se rastrean por separado pero se deducen del mismo saldo de crédito. Esto permite que OpenAI fije precios distintos para los tokens de salida costosos frente a los tokens de entrada más baratos.
• Niveles de confianza: Vincular los límites de tasa al gasto total anima a los usuarios a permanecer en la plataforma y recompensa a los clientes a largo plazo con mejor rendimiento.

​

Ventajas estratégicas

​

Construye 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: 'prod_credit_pack_50', quantity: 1 }
  ],
  customer: { email: 'developer@example.com' },
  return_url: 'https://yourapp.com/dashboard'
});

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: 'credit_entitlement_id',
  });

  if (balance.available <= 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,
});

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: 'prod_plus_subscription', quantity: 1 }
  ],
  customer: { email: 'user@example.com' },
  return_url: 'https://yourapp.com/billing'
});

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 plano de ingestión de LLM

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',
});

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 tarifa basados en gasto

1. Rastrea el gasto de por vida: Escucha los webhooks payment.succeeded y actualiza un campo total_spend en tu base de datos para ese cliente.
2. Define niveles: Crea una asignación de montos gastados a límites de tasa.
   • Nivel 1: $0 - $50 gastados -> 3 RPM
   • Nivel 2: $50 - $250 gastados -> 10 RPM
   • Nivel 3: $250+ gastados -> 50 RPM
3. Aplica los límites: En el middleware de tu API, verifica el nivel del cliente y aplica el límite de tasa correspondiente.

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 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: 'credit_entitlement_id',
    });

    if (balance.available <= 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' });
  }
}

​

Manejo de casos extremos

​

Condiciones de carrera

​

Latencia en la ingestión de eventos

​

Manejo de reembolsos

​

Compatibilidad con múltiples modelos

1. Medidores separados: Crea medidores separados para cada modelo (por ejemplo, gpt-4o.input_tokens, gpt-4o-mini.input_tokens).
2. Eventos ponderados: Usa un único medidor pero multiplica el valor tokens por un peso antes de enviarlo a Dodo. Por ejemplo, si GPT-4o es 10 veces más caro que GPT-4o-mini, podrías enviar 10 veces los tokens para las solicitudes de GPT-4o.

​

Visión general de la arquitectura

​

Conclusión

​

Funciones clave de Dodo utilizadas