OpenAI Billing Model

​

Tại sao mô hình của OpenAI là tiêu chuẩn

1. Doanh thu dự đoán và rủi ro thấp: Bằng cách yêu cầu tín dụng trả trước cho việc sử dụng API, OpenAI loại bỏ rủi ro người dùng tạo ra hóa đơn khổng lồ mà không thể trả. Bạn nhận được tiền trước, và người dùng dùng dịch vụ khi họ sử dụng.
2. Khả năng mở rộng cho nhà phát triển: Việc nạp lại $5 là rào cản thấp để bắt đầu. Khi ứng dụng phát triển, nhà phát triển có thể tự động nạp lại hoặc mua gói lớn hơn. Các bước bắt đầu gần như bằng không, nhưng giới hạn để mở rộng thì không giới hạn.
3. Tâm lý người dùng: Việc quy đổi tín dụng theo tiền tệ (USD) thay vì các “token” hay “điểm” trừu tượng khiến giá trị trở nên rõ ràng. Nó giống như một tài khoản ngân hàng dành cho dịch vụ AI, giúp xây dựng niềm tin và dễ lập ngân sách hơn cho các công ty.

​

Cách OpenAI lập hóa đơn

1. API (Trả tiền theo mức sử dụng): API sử dụng tín dụng trả trước quy đổi theo tiền tệ fiat. Người dùng nạp tiền vào tài khoản với các mức $5, $10, $50 hoặc lớn hơn. Những tín dụng này hiển thị giá trị bằng đô la nhưng không có giá trị tiền tệ bên ngoài OpenAI. OpenAI lập hóa đơn theo token với các mức giá khác nhau cho token đầu vào và đầu ra. Tín dụng không bao giờ hết hạn, và khi số dư người dùng về $0, các cuộc gọi API sẽ thất bại ngay lập tức.
2. ChatGPT Plus, Team và Enterprise: Đây là các gói đăng ký với mức phí cố định. ChatGPT Plus có giá $20 mỗi tháng, trong khi gói Team là $25 cho mỗi người dùng mỗi tháng. Các gói này có ngưỡng sử dụng mềm, nơi người dùng bị giảm cấp xuống mô hình nhỏ hơn thay vì bị chặn hoàn toàn.
3. Các tầng mức giới hạn dựa trên chi tiêu: Khi bạn chi nhiều tiền hơn theo thời gian, bạn mở khóa giới hạn tỷ lệ API cao hơn. Đây là hệ thống mở rộng truy cập dựa trên niềm tin gắn trực tiếp với lịch sử thanh toán của bạn.

​

Những điểm độc đáo

• Tín dụng quy đổi theo tiền tệ: Tín dụng cảm giác giống tiền vì được quy đổi theo USD. Điều này khiến giá cả minh bạch và dễ hiểu đối với các nhà phát triển.
• Không hết hạn: Số dư không bao giờ hết hạn giảm áp lực “dùng ngay hoặc mất”. Người dùng cảm thấy thoải mái khi nạp số tiền lớn hơn vì biết giá trị không biến mất.
• Đo lường đa chiều: Token đầu vào và đầu ra được theo dõi riêng nhưng trừ vào cùng một số dư tín dụng. Điều này cho phép OpenAI định giá token đầu ra đắt hơn khác với token đầu vào rẻ hơn.
• Các tầng mức tin cậy: Liên kết giới hạn tỷ lệ với tổng chi tiêu khuyến khích người dùng ở lại nền tảng và thưởng cho khách hàng dài hạn bằng hiệu suất tốt hơn.

​

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

​

Xây dựng điều 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: '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 (balance.available <= 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';
}

​

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

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 các tầng giới hạn dựa trên chi tiêu

1. Theo dõi chi tiêu suốt đời: Lắng nghe webhook payment.succeeded và cập nhật trường total_spend trong cơ sở dữ liệu cho khách hàng đó.
2. Định nghĩa các tầng: Tạo ánh xạ từ mức chi tiêu đến giới hạn tỷ lệ.
   • Tầng 1: chi tiêu $0 - $50 -> 3 RPM
   • Tầng 2: chi tiêu $50 - $250 -> 10 RPM
   • Tầng 3: chi tiêu $250+ -> 50 RPM
3. Thực thi giới hạn: Trong middleware API của bạn, kiểm tra tầng của khách hàng và áp dụng giới hạn tỷ lệ tương ứng.

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 đủ: Proxy API

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 (balance.available <= 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 ngoại lệ

​

Điều kiện đua

​

Độ trễ hập dữ liệu sự kiện

​

Xử lý hoàn tiền

​

Hỗ trợ đa mô hình

1. Các bộ đo riêng biệt: Tạo các bộ đo riêng cho từng mô hình (ví dụ: gpt-4o.input_tokens, gpt-4o-mini.input_tokens).
2. Sự kiện cân bằng: Dùng một bộ đo duy nhất nhưng nhân giá trị tokens với trọng số trước khi gửi đến Dodo. Ví dụ, nếu GPT-4o đắt gấp 10 lần GPT-4o-mini, bạn có thể gửi 10 lần số token cho các yêu cầu GPT-4o.

​

Tổng quan kiến trúc

​

Kết luận

​

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

​

Key Dodo Features Used