Cursor Billing Model

​

Come Fattura Cursor

4. Enterprise e Business: I team utilizzano l’uso condiviso dove l’intera organizzazione condivide un unico bucket di crediti. Questo semplifica la gestione e garantisce che gli utenti con elevato consumo non raggiungano i limiti individuali mentre altri hanno capacità inutilizzata.

​

Cosa lo Rende Unico

• Astrazione dei Provider: Un singolo abbonamento racchiude più provider LLM come OpenAI e Anthropic, gestendo complessi prezzi e chiavi API in background.
• Esaurimento Ponderato: I costi corrispondono al valore addebitando di più per modelli potenti, rendendo la tariffazione equa e trasparente per tutti gli utenti.
• Degradazione Graduale: La coda “Lenta” evita interruzioni nette, mantenendo gli utenti nel prodotto e incoraggiandoli ad effettuare l’upgrade senza essere penalizzati.
• Crediti Condivisi: I bucket a livello di team riducono l’attrito per i clienti enterprise permettendo la condivisione efficiente delle risorse all’interno dell’intera organizzazione.

​

Ricrea Questo con 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'
});

​

Accelerare con il Blueprint di Ingestione 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!' }],
});

​

Crediti Team Condivisi (Enterprise)

​

Strategia di Implementazione

1. Cliente a Livello di Organizzazione: Crea un singolo customer_id in Dodo per l’intera organizzazione. Questo cliente rappresenta l’entità di fatturazione per il team e detiene il pool di crediti condiviso. Tutte le fatture e le allocazioni di crediti sono legate a questo ID.
2. Fatturazione basata sui Posti: Usa gli add-on di Dodo per addebitare una tariffa piattaforma per utente. Quando un team aggiunge un nuovo membro, aggiorni la quantità dell’add-on “Posto”. Questo garantisce che le entrate aumentino proporzionalmente al numero di utenti mantenendo separato il pool di crediti. È un modo pulito per gestire una fatturazione multidimensionale.
3. Monitoraggio dell’Uso Condiviso: Tutte le richieste dei membri del team vengono ingerite utilizzando l’customer_id dell’organizzazione. Ciò garantisce che ogni richiesta da qualsiasi membro del team consumi lo stesso pool centrale di crediti. Puoi ancora monitorare l’utilizzo individuale includendo un user_id nei metadati dell’evento per reportistica interna e analisi. Questo approccio ti offre il meglio di entrambi i mondi: una tariffa prevedibile per utente per la piattaforma e un pool condiviso di crediti per le risorse IA costose. Semplifica anche l’esperienza utente dei membri del team, poiché non devono gestire i propri limiti individuali.

​

Confronto con la Fatturazione SaaS Tradizionale

• Nessun Effetto a “Precipizio”: Gli utenti non devono effettuare l’upgrade solo perché hanno raggiunto un limite. Possono pagare per gli overage o accettare prestazioni più lente. Questo li mantiene nel prodotto e riduce l’attrito, portando a maggiore soddisfazione del cliente e minor churn.
• Allineamento dei Costi: Le tue entrate crescono direttamente con i costi infrastrutturali. Se un utente utilizza modelli costosi, paga di più (tramite crediti o overage). Questo protegge i margini e ti permette di offrire funzionalità ad alto costo in modo sostenibile senza compromettere il tuo modello di business.
• Migliore Fidelizzazione: Non tagliando gli utenti fuori, li mantieni impegnati con il prodotto anche quando hanno raggiunto il limite. Possono continuare a lavorare, fidelizzandosi nel lungo termine e aumentando il valore del cliente nel tempo. È una situazione vantaggiosa per utente e provider.

​

Gestire Aggiornamenti ed Evoluzione dei Modelli

​

Notifiche e Trasparenza per l’Utente

​

Sicurezza e Prevenzione delle Frodi

• Idempotenza: Usa sempre event_id unici quando ingerisci eventi di utilizzo per evitare doppi conteggi. L’API di ingestione di Dodo gestisce l’idempotenza automaticamente se fornisci un ID univoco, assicurando che un retry di rete non addebiti due volte l’utente.
• Limitazione della Frequenza: Implementa limiti di velocità a livello applicativo per impedire a un singolo utente di esaurire i propri crediti (o il tuo budget API) troppo rapidamente. Questo protegge la tua infrastruttura e il portafoglio dell’utente.
• Monitoraggio: Monitora i pattern di utilizzo per individuare anomalie che potrebbero indicare condivisione dell’account o abusi automatizzati. Gli analytics di Dodo possono aiutarti a identificare questi pattern, permettendoti di intervenire prima che diventino un problema serio.

​

Best Practice per i Sistemi di Crediti

1. Mantienilo Semplice: Non rendere il sistema di crediti troppo complesso. Gli utenti dovrebbero comprendere facilmente quanto costa una richiesta e quanti crediti rimangono.
2. Fornisci Valore: Assicurati che i crediti offrano un valore reale all’utente. Se il costo di una richiesta è troppo alto, gli utenti percepiranno di essere “spillati”.
3. Sii Trasparente: Mostra sempre all’utente il saldo attuale dei crediti e lo storico di utilizzo. Questo costruisce fiducia e riduce la confusione.
4. Automatizza Tutto: Usa i webhook e le API di Dodo per automatizzare quanto più possibile il processo di fatturazione. Questo riduce il lavoro manuale e garantisce che la fatturazione sia sempre accurata.

​

Principali Funzionalità Dodo Utilizzate

​

Security and Fraud Prevention

• Idempotency: Always use unique event_ids when ingesting usage events to prevent double-counting. Dodo’s ingestion API handles idempotency automatically if you provide a unique ID, ensuring that a network retry doesn’t charge the user twice.
• Rate Limiting: Implement rate limiting at the application level to prevent a single user from exhausting their credits (or your API budget) too quickly. This protects your infrastructure and the user’s wallet.
• Monitoring: Monitor usage patterns for anomalies that might indicate account sharing or automated abuse. Dodo’s analytics can help you identify these patterns, allowing you to take action before they become a major problem.

​

Best Practices for Credit Systems

1. Keep it Simple: Don’t make your credit system too complex. Users should be able to easily understand how much a request costs and how many credits they have left.
2. Provide Value: Ensure that the credits provide real value to the user. If the cost of a request is too high, users will feel like they’re being nickel-and-dimed.
3. Be Transparent: Always show the user their current credit balance and usage history. This builds trust and reduces confusion.
4. Automate Everything: Use Dodo’s webhooks and APIs to automate as much of the billing process as possible. This reduces manual work and ensures that your billing is always accurate.

​

Key Dodo Features Used