Model Penagihan Cursor

​

Bagaimana Cursor Menagih

4. Enterprise dan Business: Tim menggunakan pemakaian bersama di mana seluruh organisasi berbagi satu wadah kredit. Ini menyederhanakan pengelolaan dan memastikan pengguna berat tidak mencapai batas individu sementara yang lain memiliki kapasitas yang tidak terpakai.

​

Apa yang Membuatnya Unik

• Abstraksi Penyedia: Satu langganan membungkus beberapa penyedia LLM seperti OpenAI dan Anthropic, menangani harga kompleks dan kunci API di balik layar.
• Penarikan Berbobot: Biaya selaras dengan nilai dengan mengenakan lebih banyak untuk model yang kuat, membuat harga terasa adil dan transparan bagi semua pengguna.
• Degradasi yang Halus: Antrean “Slow” mencegah pemutusan mendadak, menjaga pengguna tetap berada di produk dan mendorong peningkatan tanpa bersikap hukuman.
• Kredit Gabungan: Wadah tingkat tim mengurangi gesekan bagi pelanggan perusahaan dengan memungkinkan berbagi sumber daya secara efisien di seluruh organisasi.

​

Bangun Ini dengan Dodo Payments

import DodoPayments from 'dodopayments';

/**
 * Determines the credit cost for a given request type and model.
 * This logic lives in your application and can be updated without
 * changing your billing configuration.
 */
function getCreditCost(requestType: string, model: string): number {
  const costs: Record<string, Record<string, number>> = {
    'tab_completion': { 'default': 0 },
    'chat': { 'gpt-4o-mini': 1, 'gpt-4o': 1, 'claude-sonnet': 1 },
    'composer': { 'gpt-4o-mini': 2, 'gpt-4o': 5, 'claude-sonnet': 5 },
    'agent': { 'gpt-4o': 10, 'claude-sonnet': 10, 'o1': 25 }
  };
  
  // Default to 1 credit if the combination isn't found
  return costs[requestType]?.[model] ?? 1;
}

/**
 * Ingests usage events into Dodo Payments.
 * For weighted requests, we send multiple events or use a sum aggregation.
 */
async function trackRequest(customerId: string, requestType: string, model: string) {
  const creditCost = getCreditCost(requestType, model);
  
  // Tab completions are free, so we don't need to track them for billing
  if (creditCost === 0) return;
  
  const client = new DodoPayments({
    bearerToken: process.env.DODO_PAYMENTS_API_KEY,
  });
  
  await client.usageEvents.ingest({
    events: [{
      event_id: `req_${Date.now()}_${Math.random().toString(36).slice(2)}`,
      customer_id: customerId,
      event_name: 'ai.request',
      timestamp: new Date().toISOString(),
      metadata: {
        request_type: requestType,
        model: model,
        credit_cost: creditCost
      }
    }]
  });
}

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 customerId = event.data.customer_id;
      await updateUserTier(customerId, 'slow');
      await notifyUser(customerId, 'You have used most of your premium requests. Switching to standard models.');
    }
    
    res.json({ received: true });
  } catch (error) {
    res.status(401).json({ error: 'Invalid signature' });
  }
});

/**
 * Routes a request based on the user's current tier.
 * This function is called before every AI request to determine the model and queue.
 */
async function routeRequest(customerId: string, requestType: string) {
  const tier = await getUserTier(customerId);
  
  if (tier === 'slow') {
    // Route to a cheaper model and a lower priority queue
    // This saves costs while keeping the user active in the product
    return { model: 'gpt-4o-mini', queue: 'standard' };
  }
  
  // Premium routing for users with remaining credits
  // This provides the best possible performance and model quality
  return { model: 'claude-sonnet', queue: 'priority' };
}

import DodoPayments from 'dodopayments';

const client = new DodoPayments({
  bearerToken: process.env.DODO_PAYMENTS_API_KEY,
});

/**
 * Creates a checkout session for a new subscription.
 * This is typically called when a user clicks an "Upgrade" button.
 */
const session = await client.checkoutSessions.create({
  product_cart: [
    { product_id: 'prod_cursor_pro', quantity: 1 }
  ],
  customer: { email: 'developer@example.com' },
  return_url: 'https://yourapp.com/dashboard'
});

​

Percepat dengan LLM Ingestion Blueprint

npm install @dodopayments/ingestion-blueprints

import { createLLMTracker } from '@dodopayments/ingestion-blueprints';
import OpenAI from 'openai';
import Anthropic from '@anthropic-ai/sdk';

// Track raw token usage for analytics alongside credit-weighted billing
const openaiTracker = createLLMTracker({
  apiKey: process.env.DODO_PAYMENTS_API_KEY,
  environment: 'live_mode',
  eventName: 'analytics.openai_tokens',
});

const anthropicTracker = createLLMTracker({
  apiKey: process.env.DODO_PAYMENTS_API_KEY,
  environment: 'live_mode',
  eventName: 'analytics.anthropic_tokens',
});

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
const anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });

// Wrap each provider separately
const trackedOpenAI = openaiTracker.wrap({ client: openai, customerId: 'customer_123' });
const trackedAnthropic = anthropicTracker.wrap({ client: anthropic, customerId: 'customer_123' });

// Token tracking is automatic, credit deduction still uses your weighted system
const response = await trackedOpenAI.chat.completions.create({
  model: 'gpt-4o',
  messages: [{ role: 'user', content: 'Hello!' }],
});

​

Kredit Tim Terpadu (Enterprise)

​

Strategi Implementasi

1. Pelanggan Tingkat Organisasi: Buat satu customer_id di Dodo untuk seluruh organisasi. Pelanggan ini mewakili entitas penagihan untuk tim dan memegang kumpulan kredit bersama. Semua faktur dan alokasi kredit terkait dengan ID ini.
2. Penagihan Berdasarkan Kursi: Gunakan add-on Dodo untuk mengenakan biaya platform per pengguna. Ketika tim menambahkan anggota baru, Anda memperbarui kuantitas add-on “Seat”. Ini memastikan pendapatan Anda skala seiring jumlah pengguna sambil menjaga kumpulan kredit tetap terpisah. Ini cara bersih untuk menangani penagihan multidimensi.
3. Pelacakan Pemakaian Bersama: Semua permintaan anggota tim diunggah menggunakan customer_id organisasi. Ini memastikan setiap permintaan dari anggota tim mana pun mengurangi kumpulan kredit pusat yang sama. Anda masih dapat melacak pemakaian pengguna individu dengan menyertakan user_id dalam metadata event untuk pelaporan internal dan analitik.

​

Perbandingan dengan Penagihan SaaS Tradisional

• Tidak Ada Efek “Jurang”: Pengguna tidak harus naik tingkat hanya karena mencapai batas. Mereka dapat membayar biaya tambahan atau menerima performa yang lebih lambat. Ini menjaga mereka tetap berada di produk dan mengurangi gesekan, menghasilkan kepuasan pelanggan lebih tinggi dan churn lebih rendah.
• Keselarasan Biaya: Pendapatan Anda meningkat seiring biaya infrastruktur. Jika pengguna menggunakan model yang mahal, mereka membayar lebih (baik melalui kredit atau biaya tambahan). Ini melindungi margin Anda dan memungkinkan Anda menawarkan fitur berbiaya tinggi secara berkelanjutan tanpa membahayakan model bisnis Anda.
• Retensi Lebih Baik: Dengan tidak memutus pengguna, Anda menjaga mereka tetap terlibat dengan produk bahkan ketika mereka mencapai batasnya. Mereka dapat terus bekerja, yang membangun loyalitas jangka panjang dan meningkatkan nilai seumur hidup pelanggan. Ini situasi menang-menang bagi pengguna dan penyedia.

​

Menangani Pembaruan dan Evolusi Model

​

Notifikasi Pengguna dan Transparansi

​

Keamanan dan Pencegahan Penipuan

• Idempoten: Selalu gunakan event_id unik saat mengunggah event penggunaan untuk mencegah perhitungan ganda. API ingest Dodo menangani idempoten secara otomatis jika Anda menyediakan ID unik, memastikan retry jaringan tidak membebani pengguna dua kali.
• Pembatasan Laju: Terapkan pembatasan laju di tingkat aplikasi untuk mencegah satu pengguna menghabiskan kredit mereka (atau anggaran API Anda) terlalu cepat. Ini melindungi infrastruktur Anda dan dompet pengguna.
• Pemantauan: Pantau pola pemakaian untuk anomali yang mungkin menunjukkan pembagian akun atau penyalahgunaan otomatis. Analitik Dodo dapat membantu Anda mengidentifikasi pola ini, memungkinkan Anda mengambil tindakan sebelum menjadi masalah besar.

​

Praktik Terbaik untuk Sistem Kredit

1. Jaga agar Tetap Sederhana: Jangan membuat sistem kredit Anda terlalu kompleks. Pengguna harus dapat dengan mudah memahami berapa biaya sebuah permintaan dan berapa kredit yang tersisa.
2. Berikan Nilai: Pastikan kredit memberikan nilai nyata kepada pengguna. Jika biaya permintaan terlalu tinggi, pengguna akan merasa seperti sedang diperas.
3. Bersikap Transparan: Selalu tunjukkan saldo kredit dan riwayat pemakaian pengguna. Ini membangun kepercayaan dan mengurangi kebingungan.
4. Otomatisasi Segalanya: Gunakan webhook dan API Dodo untuk mengotomatisasi sebanyak mungkin proses penagihan. Ini mengurangi pekerjaan manual dan memastikan penagihan Anda selalu akurat.

​

Fitur Utama Dodo yang Digunakan