OpenAI Billing Model

​

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

1. Predictable Revenue and Low Risk: क्योंकि API usage prepaid है, users ऐसे bills नहीं बना सकते जिन्हें वे चुका न सकें। OpenAI को पैसे पहले ही मिल जाते हैं और user service इस्तेमाल करते समय उसे खर्च करता है।
2. Scalability for Developers: $5 का top-up entry barrier को कम रखता है। Application बढ़ने पर developers top-ups automate कर सकते हैं या बड़े packs खरीद सकते हैं। शुरुआत सस्ती है और plan बदले बिना usage बढ़ाया जा सकता है।
3. User Psychology: अमूर्त “tokens” या “points” के बजाय US dollars में credits value को स्पष्ट बनाते हैं। Balance AI services के लिए prepaid account की तरह काम करता है, जिससे companies के लिए budgeting आसान होती है।

​

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

1. API (Pay-as-you-go): API prepaid, dollar-denominated credits का उपयोग करता है। Users अपने accounts में $5, $10, $50 या उससे अधिक राशि से top up करते हैं। Credits में dollar value दिखाई देती है, लेकिन उनका उपयोग OpenAI के बाहर नहीं किया जा सकता। OpenAI प्रति token billing करता है, जिसमें input और output tokens के लिए अलग-अलग rates होते हैं। खरीदे गए credits purchase के एक वर्ष बाद expire हो जाते हैं और non-refundable होते हैं (OpenAI Help Center)। जब balance $0 तक पहुंच जाता है, तो API calls fail हो जाती हैं।
2. ChatGPT Plus, Business, and Enterprise: ये flat-rate subscriptions हैं। ChatGPT Plus की कीमत $20 प्रति माह है, और Business plan (जिसे पहले Team कहा जाता था) की कीमत monthly billing पर $25 प्रति user प्रति माह है। इनमें soft usage caps होते हैं: heavy users को block करने के बजाय छोटे model पर भेज दिया जाता है।
3. Spend-based rate tiers: समय के साथ total spend बढ़ने पर account higher API rate limits unlock करता है। Access billing history के साथ बढ़ता है।

​

इसे विशिष्ट क्या बनाता है

• Fiat-denominated credits: Credits US dollars में होते हैं, इसलिए वे पैसे जैसे महसूस होते हैं। Developers किसी request की कीमत सीधे पढ़ सकते हैं।
• Long expiry: खरीदे गए credits एक वर्ष तक valid रहते हैं, जिससे “use it or lose it” का दबाव कम होता है। Users बड़ी amounts से top up करने में सहज रहते हैं।
• Multi-dimensional metering: Input और output tokens को अलग-अलग track किया जाता है, लेकिन deduction एक ही balance से होती है। OpenAI महंगे output tokens की कीमत input tokens से अधिक रख सकता है।
• Trust tiers: Total spend के साथ बढ़ने वाली rate limits long-term customers को reward करती हैं और उन्हें जुड़े रहने के लिए प्रोत्साहित करती हैं।

​

रणनीतिक लाभ

​

इसे 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';
}

​

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

​

Spend-Based Rate Tiers लागू करना

1. Track Lifetime Spend: payment.succeeded webhooks को listen करें और payment amount को अपने database में उस customer के लिए total_spend field में जोड़ें। Amounts smallest currency unit में होती हैं, इसलिए 5000 का अर्थ $50.00 है।
2. Define Tiers: Spend amounts को rate limits से map करें:
   • 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 lookup करें और उसकी rate limit apply करें।

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

​

Edge Cases को संभालना

​

Race Conditions

​

Event Ingestion Latency

​

Refund Handling

​

Multi-Model Support

1. Separate Meters: प्रत्येक model के लिए meters का एक set बनाएं, उदाहरण के लिए gpt-4o.input_tokens और gpt-4o-mini.input_tokens, जिनमें प्रत्येक का अपना Meter units per credit हो।
2. Weighted Events: एक meter का उपयोग करें और event भेजने से पहले tokens को एक weight से multiply करें। उदाहरण के लिए, यदि GPT-4o की कीमत GPT-4o-mini से 10 गुना अधिक है, तो GPT-4o requests के लिए tokens की संख्या 10 गुना भेजें।

​

Architecture Overview

​

निष्कर्ष

​

उपयोग की गई प्रमुख Dodo सुविधाएं