OpenAI Billing Model

​

Why OpenAI’s Model is the Standard

1. Doanh thu có thể dự đoán và rủi ro thấp: Vì việc sử dụng API được trả trước, người dùng không thể phát sinh các hóa đơn mà họ không có khả năng thanh toán. OpenAI nhận tiền trước, còn người dùng chi tiêu khi sử dụng dịch vụ.
2. Khả năng mở rộng cho developer: Khoản nạp thêm $5 là rào cản gia nhập thấp. Khi ứng dụng phát triển, developer có thể tự động hóa việc nạp thêm hoặc mua các gói lớn hơn. Chi phí bắt đầu thấp và mức sử dụng có thể tăng mà không cần đổi gói.
3. Tâm lý người dùng: Credit được định danh bằng đô la Mỹ, thay vì các “token” hoặc “point” trừu tượng, giúp giá trị trở nên rõ ràng. Số dư hoạt động như một tài khoản trả trước cho dịch vụ AI, giúp doanh nghiệp lập ngân sách dễ dàng hơn.

​

How OpenAI Bills

1. API (Pay-as-you-go): API sử dụng các khoản credit trả trước được định danh bằng dollar. Người dùng nạp thêm $5, $10, $50 hoặc nhiều hơn vào tài khoản. Các credit hiển thị giá trị bằng dollar nhưng không thể sử dụng bên ngoài OpenAI. OpenAI tính phí theo token, với các mức giá khác nhau cho token đầu vào và đầu ra. Credit đã mua sẽ hết hạn sau một năm kể từ ngày mua và không được hoàn tiền (OpenAI Help Center). Khi số dư đạt $0, các lệnh gọi API sẽ thất bại.
2. ChatGPT Plus, Business, and Enterprise: Đây là các gói subscription có mức phí cố định. ChatGPT Plus có giá $20 mỗi tháng, còn gói Business (trước đây là Team) có giá $25 mỗi user mỗi tháng khi thanh toán theo tháng. Các gói này có giới hạn sử dụng mềm: user sử dụng nhiều sẽ được chuyển sang model nhỏ hơn thay vì bị chặn.
3. Spend-based rate tiers: Khi tổng chi tiêu tăng theo thời gian, tài khoản sẽ mở khóa các giới hạn tốc độ API cao hơn. Quyền truy cập tăng theo lịch sử thanh toán.

​

Điều gì tạo nên sự độc đáo

• Credit định danh bằng fiat: Credit được tính bằng dollar Mỹ nên tạo cảm giác như tiền thật. Developer có thể đọc trực tiếp giá của một request.
• Thời hạn dài: Credit đã mua có hiệu lực trong một năm, giúp giảm áp lực “dùng hoặc mất”. User sẽ thoải mái nạp các khoản lớn hơn.
• Đo lường đa chiều: Token đầu vào và đầu ra được theo dõi riêng nhưng cùng khấu trừ từ một số dư. OpenAI có thể định giá token đầu ra tốn kém cao hơn token đầu vào.
• Trust tier: Giới hạn tốc độ tăng theo tổng chi tiêu, vừa tưởng thưởng khách hàng lâu năm vừa khuyến khích họ tiếp tục sử dụng.

​

Lợi thế chiến lược

​

Xây dựng mô hình này với 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';
}

​

Tăng tốc với 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);

​

Triển khai Spend-Based Rate Tiers

1. Theo dõi tổng chi tiêu: Lắng nghe webhook payment.succeeded và cộng số tiền thanh toán vào một field total_spend của customer đó trong database. Số tiền được tính bằng đơn vị tiền tệ nhỏ nhất, vì vậy 5000 tương đương $50.00.
2. Xác định tier: Ánh xạ các mức chi tiêu với rate limit:
   • Tier 1: Chi tiêu $0 - $50 -> 3 RPM
   • Tier 2: Chi tiêu $50 - $250 -> 10 RPM
   • Tier 3: Chi tiêu từ $250 trở lên -> 50 RPM
3. Áp dụng giới hạn: Trong API middleware, tra cứu tier của customer và áp dụng rate limit tương ứng.

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

​

Ví dụ triển khai đầy đủ: 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' });
  }
}

​

Xử lý các trường hợp đặc biệt

​

Race Condition

​

Độ trễ khi tiếp nhận event

​

Xử lý hoàn tiền

​

Hỗ trợ nhiều model

1. Separate Meters: Tạo một bộ meter cho mỗi model, chẳng hạn gpt-4o.input_tokens và gpt-4o-mini.input_tokens, mỗi meter có Meter units per credit riêng.
2. Weighted Events: Sử dụng một meter và nhân tokens với một weight trước khi gửi event. Ví dụ, nếu GPT-4o có giá cao gấp 10 lần GPT-4o-mini, hãy gửi số token gấp 10 lần cho các request GPT-4o.

​

Tổng quan kiến trúc

​

Kết luận

​

Các tính năng chính của Dodo được sử dụng