OpenAI Billing Model

​

OpenAI का Model Standard क्यों है

1. Predictable Revenue और Low Risk: API usage के लिए prepaid credits आवश्यक करके OpenAI उन users के massive bills बढ़ाने का risk समाप्त करता है जिन्हें वे चुका नहीं सकते। आपको पैसे पहले मिल जाते हैं और user service का उपयोग करते हुए भुगतान करता है।
2. Developers के लिए Scalability: $5 का top-up प्रवेश की कम बाधा है। जैसे-जैसे उनका application बढ़ता है, developers top-ups automate कर सकते हैं या बड़े packs खरीद सकते हैं। शुरुआत का friction लगभग शून्य है, लेकिन growth की सीमा असीमित है।
3. User Psychology: Abstract “tokens” या “points” के बजाय credits को fiat currency (USD) में व्यक्त करने से value स्पष्ट रहती है। यह AI services के लिए bank account जैसा महसूस होता है, जिससे trust बनता है और companies के लिए budgeting आसान हो जाती है।

​

OpenAI Billing कैसे करता है

1. API (Pay-as-you-go): API prepaid fiat-denominated credits का उपयोग करता है। Users अपने accounts में $5, $10, $50 या उससे अधिक का top-up करते हैं। इन credits में dollar value दिखाई देती है, लेकिन OpenAI के बाहर इनका कोई monetary value नहीं होता। OpenAI input और output tokens के लिए अलग-अलग rates के साथ per-token billing करता है। Credits कभी expire नहीं होते और जब user का balance $0 तक पहुंच जाता है, तो उसकी API calls तुरंत fail हो जाती हैं।
2. ChatGPT Plus, Team और Enterprise: ये flat-rate subscriptions हैं। ChatGPT Plus की कीमत $20 प्रति माह है, जबकि Team plan की कीमत $25 प्रति user प्रति माह है। इन plans में soft usage caps होते हैं, जहां users को block करने के बजाय छोटे model पर downgrade कर दिया जाता है।
3. Spend-based rate tiers: समय के साथ कुल अधिक money spend करने पर आप higher API rate limits unlock करते हैं। यह trust-based access scaling system है, जो सीधे आपके billing history से जुड़ा है।

​

इसे Unique क्या बनाता है

• Fiat-denominated credits: Credits USD में denominated होने के कारण money जैसे महसूस होते हैं। इससे developers के लिए pricing transparent और समझने में आसान होती है।
• No expiry: कभी expire न होने वाले balances “use it or lose it” के pressure को कम करते हैं। Users बड़े amounts का top-up करने में सहज महसूस करते हैं क्योंकि उन्हें पता होता है कि value गायब नहीं होगी।
• Multi-dimensional metering: Input और output tokens को अलग-अलग track किया जाता है, लेकिन deduction एक ही credit balance से होती है। इससे OpenAI महंगे output tokens की pricing सस्ते input tokens से अलग रख सकता है।
• Trust tiers: Rate limits को total spend से जोड़ने पर users platform पर बने रहने के लिए प्रोत्साहित होते हैं और long-term customers को बेहतर performance मिलती है।

​

Strategic Advantages

​

इसे 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 (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,
});

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

​

LLM Ingestion Blueprint के साथ Accelerate करें

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

​

Spend-Based Rate Tiers को Implement करना

1. Track Lifetime Spend: payment.succeeded webhooks को listen करें और उस customer के लिए अपने database में total_spend field update करें।
2. Define Tiers: Spend amounts और rate limits की mapping बनाएं।
   • Tier 1: $0 - $50 spend -> 3 RPM
   • Tier 2: $50 - $250 spend -> 10 RPM
   • Tier 3: $250+ spend -> 50 RPM
3. Enforce Limits: अपने API middleware में customer का tier check करें और corresponding rate limit लागू करें।

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

​

Edge Cases को Handle करना

​

Race Conditions

​

Event Ingestion Latency

​

Refund Handling

​

Multi-Model Support

1. Separate Meters: प्रत्येक model के लिए अलग meters बनाएं (जैसे, gpt-4o.input_tokens, gpt-4o-mini.input_tokens)।
2. Weighted Events: एक single meter का उपयोग करें, लेकिन tokens value को Dodo पर भेजने से पहले weight से multiply करें। उदाहरण के लिए, यदि GPT-4o, GPT-4o-mini से 10x अधिक महंगा है, तो आप GPT-4o requests के लिए tokens की संख्या 10x भेज सकते हैं।

​

Architecture Overview

​

Conclusion

​

उपयोग की गई Dodo की मुख्य Features