Cursor बिलिंग मॉडल

​

करसर कैसे बिल करता है

4. एंटरप्राइज़ और बिज़नेस: टीमें पूल्ड उपयोग का उपयोग करती हैं जहां पूरी संस्था एकल क्रेडिट बकेट साझा करती है। यह प्रबंधन को सरल बनाता है और सुनिश्चित करता है कि भारी उपयोगकर्ता व्यक्तिगत सीमाओं को पार न करें जबकि अन्य के पास अप्रयुक्त क्षमता बनी रहे।

​

यह क्या खास बनाता है

• प्रदाता अमूर्तन: एक ही सब्सक्रिप्शन OpenAI और Anthropic जैसे कई LLM प्रदाताओं को कवर करता है, पीछे की जटिल प्राइसिंग और API कीज़ को संभालता है।
• वेटेड डिप्लेशन: लागत मूल्य के अनुसार संरेखित होती है, शक्तिशाली मॉडलों के लिए अधिक चार्ज करके, जिससे सभी उपयोगकर्ताओं के लिए प्राइसिंग निष्पक्ष और पारदर्शी महसूस होती है।
• नरम डिग्रेडेशन: “Slow” कतार कठोर कटऑफ़ को रोकती है, जिससे उपयोगकर्ता उत्पाद में बने रहते हैं और बिना दंडात्मक तरीके से अपग्रेड करने के लिए प्रोत्साहित होते हैं।
• पूल्ड क्रेडिट्स: टीम-स्तर के बकेट एंटरप्राइज़ ग्राहकों के लिए घर्षण कम करते हैं, जिससे पूरे संगठन में कुशल संसाधन साझा करना संभव होता है।

​

इसे 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'
});

​

LLM इनजेशन ब्लूप्रिंट के साथ गति बढ़ाएं

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

​

पूल्ड टीम क्रेडिट (एंटरप्राइज़)

​

कार्यान्वयन रणनीति

1. संगठन-स्तर ग्राहक: पूरे संगठन के लिए Dodo में एक एकल customer_id बनाएँ। यह ग्राहक टीम के बिलिंग एंटिटी का प्रतिनिधित्व करता है और साझा क्रेडिट पूल रखता है। सभी चालान और क्रेडिट आवंटन इस ID से जुड़े होते हैं।
2. सीट-आधारित बिलिंग: प्रति-उपयोगकर्ता प्लेटफ़ॉर्म शुल्क के लिए Dodo के ऐड-ऑन का उपयोग करें। जब कोई टीम नया सदस्य जोड़ती है, तो आप “Seat” ऐड-ऑन की मात्रा अपडेट करते हैं। यह सुनिश्चित करता है कि उपयोगकर्ताओं की संख्या के साथ आपकी राजस्व वृद्धि होती है, जबकि क्रेडिट पूल अलग रहता है। यह बहु-आयामी बिलिंग को संभालने का एक स्वच्छ तरीका है।
3. साझा उपयोग ट्रैकिंग: सभी टीम सदस्यों के अनुरोध संगठन के customer_id का उपयोग करके इनजेस्ट किए जाते हैं। यह सुनिश्चित करता है कि किसी भी टीम सदस्य से कोई भी अनुरोध उसी केंद्रीय क्रेडिट पूल को घटाता है। आप आंतरिक रिपोर्टिंग और विश्लेषण के लिए इवेंट मेटाडेटा में user_id शामिल करके व्यक्तिगत उपयोग ट्रैक कर सकते हैं।

​

पारंपरिक SaaS बिलिंग के साथ तुलना

• कोई “चौखट” प्रभाव नहीं: उपयोगकर्ताओं को सीमा पार करने पर केवल अपग्रेड करना आवश्यक नहीं होता। वे ओवरएज के लिए भुगतान कर सकते हैं या धीमी गति स्वीकार कर सकते हैं। यह उन्हें उत्पाद में बनाए रखता है और घर्षण कम करता है, जिससे ग्राहक संतुष्टि अधिक होती है और चर्न कम होता है।
• लागत संरेखण: आपकी राजस्व सीधे आपकी अवसंरचना लागतों के साथ स्केल करती है। यदि कोई उपयोगकर्ता महंगे मॉडलों का उपयोग करता है, तो वे अधिक भुगतान करते हैं (चाहे क्रेडिट के माध्यम से हो या ओवरएज के माध्यम से)। इससे आपके मार्जिन सुरक्षित रहते हैं और आप महंगे फीचर्स को सतत ढंग से प्रदान कर सकते हैं बिना अपने बिज़नेस मॉडल को जोखिम में डाले।
• बेहतर रिटेंशन: उपयोगकर्ताओं को काटने के बजाय, आप उन्हें उत्पाद के साथ जुड़े रखते हैं भले ही उन्होंने अपनी सीमा पार कर ली हो। वे काम जारी रख सकते हैं, जिससे दीर्घकालिक निष्ठा बनती है और ग्राहक का आजीवन मूल्य बढ़ता है। यह उपयोगकर्ता और प्रदाता दोनों के लिए एक जीत है।

​

मॉडल अपडेट और विकास को संभालना

​

उपयोगकर्ता नोटिफिकेशन और पारदर्शिता

​

सुरक्षा और धोखाधड़ी रोकथाम

• आइडेम्पोटेंसी: उपयोग घटनाओं को इनजेस्ट करते समय हमेशा अद्वितीय event_id का उपयोग करें ताकि दोहराव से बचा जा सके। यदि आप एक अद्वितीय ID प्रदान करते हैं तो Dodo का इनजेशन API आइडेम्पोटेंसी को स्वचालित रूप से संभालता है, यह सुनिश्चित करते हुए कि एक नेटवर्क पुन: प्रयास उपयोगकर्ता को दो बार चार्ज न करे।
• रेट लिमिटिंग: एकल उपयोगकर्ता को उनकी क्रेडिट (या आपके API बजट) को बहुत जल्दी समाप्त करने से रोकने के लिए ऐप्लिकेशन स्तर पर रेट लिमिटिंग लागू करें। यह आपकी अवसंरचना और उपयोगकर्ता की वॉलेट की सुरक्षा करता है।
• मोनीटरिंग: ऐसे उपयोग पैटर्न की निगरानी करें जो अकाउंट शेयरिंग या ऑटोमेटेड दुरुपयोग का संकेत दे सकते हैं। Dodo के एनालिटिक्स इन पैटर्न को पहचानने में आपकी मदद कर सकते हैं, जिससे आप उन्हें बड़ी समस्या बनने से पहले कार्रवाई कर सकें।

​

क्रेडिट सिस्टम के लिए सर्वोत्तम प्रथाएं

1. इसे सरल रखें: अपना क्रेडिट सिस्टम बहुत जटिल न बनाएं। उपयोगकर्ताओं को आसानी से समझ आना चाहिए कि एक अनुरोध की लागत कितनी है और उनके पास कितने क्रेडिट बचे हैं।
2. मूल्य प्रदान करें: सुनिश्चित करें कि क्रेडिट उपयोगकर्ता के लिए वास्तविक मूल्य प्रदान करते हैं। यदि एक अनुरोध की लागत बहुत अधिक है, तो उपयोगकर्ता महसूस करेंगे कि उन्हें बार-बार छोटा भुगतान कराया जा रहा है।
3. पारदर्शी रहें: हमेशा उपयोगकर्ता को उनका वर्तमान क्रेडिट बैलेंस और उपयोग इतिहास दिखाएं। यह विश्वास बनाता है और भ्रम को कम करता है।
4. सब कुछ ऑटोमेट करें: बिलिंग प्रक्रिया को अधिक से अधिक ऑटोमेट करने के लिए Dodo के वेबहुक्स और APIs का उपयोग करें। इससे मैन्युअल कार्य कम होता है और आपकी बिलिंग हमेशा सटीक रहती है।

​

उपयोग किए गए प्रमुख Dodo फीचर्स