Modèle de facturation Cursor

​

Comment Cursor facture

4. Enterprise et Business : Les équipes utilisent une consommation mutualisée où toute l’organisation partage un seul bucket de crédits. Cela simplifie la gestion et garantit que les gros consommateurs n’atteignent pas les limites individuelles pendant que d’autres ont de la capacité inutilisée.

​

Ce qui le rend unique

• Abstraction des fournisseurs : Un seul abonnement englobe plusieurs fournisseurs de LLM comme OpenAI et Anthropic, gérant en coulisses la tarification complexe et les clés API.
• Déplétion pondérée : Les coûts correspondent à la valeur en facturant davantage les modèles puissants, rendant la tarification juste et transparente pour tous les utilisateurs.
• Dégradation progressive : La file d’attente « lente » évite les coupures brutales, gardant les utilisateurs dans le produit et les incitant à passer à un niveau supérieur sans pénalité.
• Crédits mutualisés : Les buckets au niveau équipe réduisent les frictions pour les clients enterprise en permettant un partage efficace des ressources au sein de l’organisation.

​

Recréez cela avec 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'
});

​

Accélérez avec le blueprint d’ingestion 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!' }],
});

​

Crédits mutualisés pour les équipes (Enterprise)

​

Stratégie de mise en œuvre

1. Client au niveau organisationnel : Créez un seul customer_id dans Dodo pour l’ensemble de l’organisation. Ce client représente l’entité facturante de l’équipe et détient le pool de crédits partagé. Toutes les factures et attributions de crédits sont liées à cet ID.
2. Facturation par siège : Utilisez les modules complémentaires de Dodo pour facturer un frais par utilisateur. Lorsqu’une équipe ajoute un nouveau membre, vous mettez à jour la quantité de l’add-on « Seat ». Cela garantit que vos revenus évoluent avec le nombre d’utilisateurs tout en gardant le pool de crédits séparé. C’est une manière propre de gérer une facturation multidimensionnelle.
3. Suivi de l’usage partagé : Toutes les requêtes des membres de l’équipe sont ingestées en utilisant l’customer_id de l’organisation. Cela garantit que chaque requête de n’importe quel membre dégrade le même pool de crédits central. Vous pouvez toujours suivre l’usage individuel en incluant un user_id dans les métadonnées de l’événement pour les rapports internes et l’analytique.

​

Comparaison avec la facturation SaaS traditionnelle

• Pas d’effets de « falaise » : Les utilisateurs n’ont pas à passer à un niveau supérieur simplement parce qu’ils ont atteint une limite. Ils peuvent payer des dépassements ou accepter des performances plus lentes. Cela les maintient dans le produit et réduit les frictions, conduisant à une satisfaction client plus élevée et à un taux de désabonnement plus faible.
• Alignement des coûts : Vos revenus évoluent directement avec vos coûts d’infrastructure. Si un utilisateur utilise des modèles coûteux, il paye plus (via les crédits ou les dépassements). Cela protège vos marges et vous permet d’offrir durablement des fonctionnalités à fort coût sans mettre en péril votre modèle économique.
• Meilleure rétention : En ne coupant pas les utilisateurs, vous les gardez engagés avec votre produit même lorsqu’ils ont atteint leur limite. Ils peuvent continuer à travailler, ce qui renforce la fidélité sur le long terme et augmente la valeur vie client. C’est gagnant-gagnant pour l’utilisateur et le fournisseur.

​

Gérer les mises à jour et l’évolution des modèles

​

Notifications utilisateur et transparence

​

Sécurité et prévention de la fraude

• Idempotence : Utilisez toujours des event_id uniques lorsque vous ingestiez des événements d’usage pour éviter les doubles comptages. L’API d’ingestion de Dodo gère l’idempotence automatiquement si vous fournissez un ID unique, garantissant qu’une nouvelle tentative réseau ne facture pas deux fois l’utilisateur.
• Limitation de débit : Mettez en place une limitation de débit au niveau de l’application pour empêcher un seul utilisateur d’épuiser trop rapidement ses crédits (ou votre budget API). Cela protège votre infrastructure et le portefeuille de l’utilisateur.
• Surveillance : Surveillez les schémas d’usage pour détecter des anomalies pouvant indiquer un partage de compte ou un abus automatisé. Les analyses de Dodo peuvent vous aider à identifier ces schémas, vous permettant d’agir avant qu’ils ne deviennent un problème majeur.

​

Bonnes pratiques pour les systèmes de crédits

1. Restez simple : Ne rendez pas votre système de crédits trop complexe. Les utilisateurs doivent pouvoir comprendre facilement combien coûte une requête et combien de crédits il leur reste.
2. Apportez de la valeur : Assurez-vous que les crédits offrent une vraie valeur à l’utilisateur. Si le coût d’une requête est trop élevé, les utilisateurs auront l’impression de se faire arnaquer.
3. Soyez transparent : Affichez toujours à l’utilisateur son solde actuel et l’historique d’usage des crédits. Cela instaure la confiance et réduit la confusion.
4. Automatisez tout : Utilisez les webhooks et API de Dodo pour automatiser autant que possible le processus de facturation. Cela réduit le travail manuel et garantit que votre facturation est toujours précise.

​

Fonctionnalités clés de Dodo utilisées