OpenAI Billing Model

​

Why OpenAI’s Model is the Standard

1. Predictable Revenue and Low Risk: Because API usage is prepaid, users can’t run up bills they can’t pay. OpenAI receives the money up front, and the user spends it as they use the service.
2. Scalability for Developers: A $5 top-up is a low barrier to entry. As an application grows, developers can automate top-ups or buy larger packs. Starting is cheap, and usage can grow without a plan change.
3. User Psychology: Credits denominated in US dollars, instead of abstract “tokens” or “points”, make the value clear. The balance works like a prepaid account for AI services, which makes budgeting easier for companies.

​

How OpenAI Bills

1. API (Pay-as-you-go): The API uses prepaid, dollar-denominated credits. Users top up their accounts with $5, $10, $50, or more. The credits show a dollar value but can’t be used outside OpenAI. OpenAI bills per token, with different rates for input and output tokens. Purchased credits expire one year after purchase and are non-refundable (OpenAI Help Center). When a balance reaches $0, API calls fail.
2. ChatGPT Plus, Business, and Enterprise: These are flat-rate subscriptions. ChatGPT Plus costs $20 per month, and the Business plan (formerly Team) costs $25 per user per month when billed monthly. They have soft usage caps: heavy users move to a smaller model instead of being blocked.
3. Spend-based rate tiers: As total spend grows over time, the account unlocks higher API rate limits. Access grows with billing history.

​

What Makes It Unique

• Fiat-denominated credits: Credits are in US dollars, so they feel like money. Developers can read the price of a request directly.
• Long expiry: Purchased credits last a year, which reduces “use it or lose it” pressure. Users are comfortable topping up larger amounts.
• Multi-dimensional metering: Input and output tokens are tracked separately but deduct from the same balance. OpenAI can price expensive output tokens higher than input tokens.
• Trust tiers: Rate limits that rise with total spend reward long-term customers and encourage them to stay.

​

Strategic Advantages

​

Build This with 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';
}

​

Accelerate with the 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);

​

Implementing Spend-Based Rate Tiers

1. Track Lifetime Spend: Listen for payment.succeeded webhooks and add the payment amount to a total_spend field for that customer in your database. Amounts are in the smallest currency unit, so 5000 is $50.00.
2. Define Tiers: Map spend amounts to rate limits:
   • Tier 1: $0 - $50 spend -> 3 RPM
   • Tier 2: $50 - $250 spend -> 10 RPM
   • Tier 3: $250+ spend -> 50 RPM
3. Enforce Limits: In your API middleware, look up the customer’s tier and apply its rate limit.

// 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;
}

​

Full Implementation Example: The API Proxy

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

​

Handling Edge Cases

​

Race Conditions

​

Event Ingestion Latency

​

Refund Handling

​

Multi-Model Support

1. Separate Meters: Create one set of meters per model, for example gpt-4o.input_tokens and gpt-4o-mini.input_tokens, each with its own Meter units per credit.
2. Weighted Events: Use one meter and multiply tokens by a weight before sending the event. For example, if GPT-4o costs 10 times as much as GPT-4o-mini, send 10 times the tokens for GPT-4o requests.

​

Architecture Overview

​

Conclusion

​

Key Dodo Features Used