Model Penagihan OpenAI

​

Mengapa Model OpenAI adalah Standar

1. Pendapatan yang Dapat Diprediksi dan Risiko Rendah: Dengan mewajibkan kredit prabayar untuk penggunaan API, OpenAI menghilangkan risiko pengguna menumpuk tagihan besar yang tidak bisa mereka bayar. Anda memperoleh uang di muka, dan pengguna mendapatkan layanan saat mereka menggunakannya.
2. Skalabilitas untuk Pengembang: Isi ulang $5 adalah hambatan masuk yang rendah. Saat aplikasi mereka tumbuh, pengembang bisa mengotomatisasi isi ulang atau membeli paket yang lebih besar. Friksi untuk memulai hampir nol, tetapi batas atas untuk pertumbuhan tidak terbatas.
3. Psikologi Pengguna: Menyatakan kredit dalam mata uang fiat (USD) alih-alih “token” atau “poin” abstrak membuat nilainya jelas. Rasanya seperti rekening bank untuk layanan AI, yang membangun kepercayaan dan memudahkan perusahaan merencanakan anggaran.

​

Cara OpenAI Menagih

1. API (Bayar sesuai penggunaan): API menggunakan kredit prabayar yang dinyatakan dalam fiat. Pengguna mengisi ulang akun mereka dengan $5, $10, $50, atau lebih. Kredit ini menunjukkan nilai dolar tetapi tidak memiliki nilai moneter di luar OpenAI. OpenAI menagih per-token dengan tarif berbeda antara token input dan output. Kredit tidak pernah kedaluwarsa, dan ketika saldo pengguna mencapai $0, panggilan API mereka langsung gagal.
2. ChatGPT Plus, Team, dan Enterprise: Ini adalah langganan tarif tetap. ChatGPT Plus harganya $20 per bulan, sedangkan paket Team adalah $25 per pengguna per bulan. Paket ini memiliki batas penggunaan lunak di mana pengguna diturunkan ke model yang lebih kecil daripada diblokir.
3. Tingkatan tarif berbasis pengeluaran: Saat Anda menghabiskan lebih banyak uang total dari waktu ke waktu, Anda membuka batas tarif API yang lebih tinggi. Ini adalah sistem penskalaan akses berbasis kepercayaan yang terikat langsung pada riwayat penagihan Anda.

​

Apa yang Membuatnya Unik

• Kredit bernilai fiat: Kredit terasa seperti uang karena dinyatakan dalam USD. Ini membuat harga transparan dan mudah dipahami oleh pengembang.
• Tidak ada kedaluwarsa: Saldo yang tidak pernah kedaluwarsa mengurangi tekanan “gunakan atau hilang”. Pengguna merasa nyaman mengisi ulang jumlah besar karena mereka tahu nilainya tidak akan hilang.
• Meter multi-dimensi: Token input dan output dilacak secara terpisah tetapi dikurangi dari saldo kredit yang sama. Ini memungkinkan OpenAI memberikan harga berbeda untuk token output yang mahal dibanding token input yang lebih murah.
• Tingkatan kepercayaan: Mengaitkan batas tarif dengan total pengeluaran mendorong pengguna tetap berada di platform dan memberi penghargaan kepada pelanggan jangka panjang dengan performa yang lebih baik.

​

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

​

Percepat dengan Blueprint Ingesti LLM

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

​

Menerapkan Tingkatan Tarif Berbasis Pengeluaran

1. Lacak Pengeluaran Seumur Hidup: Dengarkan webhook payment.succeeded dan perbarui field total_spend di basis data Anda untuk pelanggan tersebut.
2. Tentukan Tingkatan: Buat pemetaan jumlah pengeluaran ke batas tarif.
   • Tingkat 1: Pengeluaran $0 - $50 -> 3 RPM
   • Tingkat 2: Pengeluaran $50 - $250 -> 10 RPM
   • Tingkat 3: Pengeluaran $250+ -> 50 RPM
3. Terapkan Batas: Dalam middleware API Anda, periksa tingkat pelanggan dan terapkan batas tarif yang sesuai.

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

​

Menangani Kasus Tepi

​

Kondisi Perlombaan

​

Latensi Ingesti Event

​

Penanganan Pengembalian Dana

​

Dukungan Multi-Model

1. Meter Terpisah: Buat meter terpisah untuk setiap model (misalnya gpt-4o.input_tokens, gpt-4o-mini.input_tokens).
2. Event Berbobot: Gunakan satu meter tetapi kalikan nilai tokens dengan bobot sebelum mengirimkannya ke Dodo. Misalnya, jika GPT-4o 10x lebih mahal daripada GPT-4o-mini, Anda bisa mengirim 10x token untuk permintaan GPT-4o. OpenAI menggunakan pendekatan meter terpisah secara internal untuk mempertahankan catatan penggunaan per model yang jelas.

​

Ikhtisar Arsitektur

​

Kesimpulan

​

Fitur Kunci Dodo yang Digunakan