OpenAI Billing Model

​

Why OpenAI’s Model is the Standard

1. Pendapatan yang Dapat Diprediksi dan Risiko Rendah: Karena penggunaan API dibayar di muka, pengguna tidak dapat menumpuk tagihan yang tidak mampu mereka bayar. OpenAI menerima uang di muka, dan pengguna menghabiskannya saat menggunakan layanan.
2. Skalabilitas untuk Developer: Top-up sebesar $5 merupakan hambatan awal yang rendah. Saat aplikasi berkembang, developer dapat mengotomatiskan top-up atau membeli paket yang lebih besar. Memulai itu murah, dan penggunaan dapat berkembang tanpa perubahan plan.
3. Psikologi Pengguna: Kredit dalam denominasi dolar AS, bukan “token” atau “poin” abstrak, membuat nilainya jelas. Saldo tersebut berfungsi seperti akun prabayar untuk layanan AI, sehingga perusahaan lebih mudah menyusun anggaran.

​

How OpenAI Bills

1. API (Pay-as-you-go): API menggunakan kredit prabayar dalam denominasi dolar. Pengguna mengisi saldo akun mereka sebesar $5, $10, $50, atau lebih. Kredit menampilkan nilai dolar, tetapi tidak dapat digunakan di luar OpenAI. OpenAI mengenakan biaya per token, dengan tarif berbeda untuk token input dan output. Kredit yang dibeli kedaluwarsa satu tahun setelah pembelian dan tidak dapat dikembalikan (OpenAI Help Center). Saat saldo mencapai $0, panggilan API gagal.
2. ChatGPT Plus, Business, and Enterprise: Paket ini merupakan subscription dengan tarif tetap. ChatGPT Plus berharga $20 per bulan, sedangkan paket Business (sebelumnya Team) berharga $25 per pengguna per bulan jika ditagih bulanan. Paket-paket ini memiliki batas penggunaan lunak: pengguna dengan penggunaan tinggi akan dialihkan ke model yang lebih kecil, bukan diblokir.
3. Spend-based rate tiers: Seiring total pengeluaran bertambah, akun memperoleh rate limit API yang lebih tinggi. Akses meningkat berdasarkan riwayat penagihan.

​

Hal yang Membuatnya Unik

• Kredit dalam denominasi fiat: Kredit menggunakan dolar AS, sehingga terasa seperti uang. Developer dapat membaca harga sebuah request secara langsung.
• Masa kedaluwarsa panjang: Kredit yang dibeli berlaku selama satu tahun, sehingga mengurangi tekanan “gunakan atau hangus”. Pengguna merasa nyaman mengisi saldo dalam jumlah lebih besar.
• Metering multidimensi: Token input dan output dilacak secara terpisah, tetapi dikurangkan dari saldo yang sama. OpenAI dapat menetapkan harga token output yang lebih mahal daripada token input.
• Trust tier: Rate limit yang meningkat seiring total pengeluaran memberikan penghargaan kepada pelanggan jangka panjang dan mendorong mereka untuk tetap menggunakan layanan.

​

Keunggulan Strategis

​

Bangun Ini dengan 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';
}

​

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

​

Menerapkan Spend-Based Rate Tiers

1. Lacak Total Pengeluaran: Dengarkan webhook payment.succeeded dan tambahkan jumlah pembayaran ke field total_spend untuk pelanggan tersebut di database Anda. Jumlah menggunakan unit mata uang terkecil, sehingga 5000 berarti $50.00.
2. Tentukan Tier: Petakan jumlah pengeluaran ke rate limit:
   • Tier 1: pengeluaran $0 - $50 -> 3 RPM
   • Tier 2: pengeluaran $50 - $250 -> 10 RPM
   • Tier 3: pengeluaran $250+ -> 50 RPM
3. Terapkan Limit: Di middleware API Anda, cari tier pelanggan dan terapkan rate limit-nya.

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

​

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

​

Menangani Edge Case

​

Race Condition

​

Latensi Ingestion Event

​

Penanganan Refund

​

Dukungan Multi-Model

1. Meter Terpisah: Buat satu set meter per model, misalnya gpt-4o.input_tokens dan gpt-4o-mini.input_tokens, masing-masing dengan Meter units per credit sendiri.
2. Event Berbobot: Gunakan satu meter dan kalikan tokens dengan bobot sebelum mengirim event. Misalnya, jika GPT-4o berharga 10 kali lipat dari GPT-4o-mini, kirim 10 kali jumlah token untuk request GPT-4o.

​

Ikhtisar Arsitektur

​

Kesimpulan

​

Fitur Utama Dodo yang Digunakan