Cursor Billing Model

​

Wie Cursor abrechnet

4. Enterprise und Business: Teams verwenden gemeinsam genutzte Nutzungen, bei denen die gesamte Organisation einen einzigen Credit-Pool teilt. Das vereinfacht das Management und stellt sicher, dass starke Nutzer nicht auf individuelle Limits stoßen, während andere noch ungenutzte Kapazität haben.

​

Was es besonders macht

• Anbieterabstraktion: Ein einziges Abonnement fasst mehrere LLM-Anbieter wie OpenAI und Anthropic zusammen und kümmert sich im Hintergrund um komplexe Preise und API-Schlüssel.
• Gewichtete Erschöpfung: Die Kosten orientieren sich am Wert, indem für leistungsstarke Modelle mehr berechnet wird. So wirkt die Preisgestaltung für alle Nutzer fair und transparent.
• Sanfter Abfall: Die „Slow“-Warteschlange verhindert harte Abschaltungen, hält Nutzer im Produkt und fördert Upgrades, ohne bestrafend zu wirken.
• Geteilte Credits: Teamweite Pools reduzieren Reibungsverluste für Unternehmenskunden, indem sie eine effiziente Ressourcenteilung über die gesamte Organisation erlauben.

​

So bauen Sie das mit Dodo Payments auf

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

​

Beschleunigen Sie mit der LLM-Ingestionsvorlage

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

​

Geteilte Team-Credits (Enterprise)

​

Implementierungsstrategie

1. Organisationsebene-Kunde: Erstellen Sie einen einzigen customer_id in Dodo für die gesamte Organisation. Dieser Kunde repräsentiert die abrechnende Einheit für das Team und hält den gemeinsamen Credit-Pool. Alle Rechnungen und Credit-Zuweisungen sind an diese ID gebunden.
2. Seat-basierte Abrechnung: Verwenden Sie Dodos Add-ons, um eine Plattformgebühr pro Nutzer zu berechnen. Wenn ein Team ein neues Mitglied hinzufügt, passen Sie die Menge des „Seat“-Add-ons an. So wächst Ihr Umsatz mit der Nutzerzahl, während der Credit-Pool getrennt bleibt. Das ist ein sauberer Weg, mehrdimensionale Abrechnung zu handhaben.
3. Gemeinsame Nutzungsverfolgung: Die Anfragen aller Teammitglieder werden über den ORGANISATIONS_customer_id ingestiert. Dadurch wird sichergestellt, dass jede Anfrage eines Teammitglieds denselben zentralen Credit-Pool belastet. Sie können weiterhin die individuelle Nutzung verfolgen, indem Sie user_id in den Event-Metadaten für interne Berichte und Analysen aufnehmen.

​

Vergleich mit traditioneller SaaS-Abrechnung

• Keine „Cliff“-Effekte: Nutzer müssen nicht aufrüsten, nur weil sie ein Limit erreicht haben. Sie können für Überziehungen bezahlen oder langsamere Leistung akzeptieren. Das hält sie im Produkt und reduziert Reibungsverluste, was zu höherer Kundenzufriedenheit und geringerem Churn führt.
• Kostenabgleich: Ihr Umsatz skaliert direkt mit Ihren Infrastrukturkosten. Wenn ein Nutzer teure Modelle nutzt, zahlt er mehr (entweder über Credits oder Überziehungen). Das schützt Ihre Margen und erlaubt es Ihnen, hochpreisige Features nachhaltig anzubieten, ohne Ihr Geschäftsmodell zu gefährden.
• Bessere Bindung: Indem Sie Nutzer nicht komplett abschneiden, halten Sie sie auch nach Erreichen ihres Limits im Produkt. Sie können weiterarbeiten, was langfristige Loyalität aufbaut und den Customer Lifetime Value erhöht. Ein Gewinn für Nutzer und Anbieter.

​

Umgang mit Modell-Updates und Weiterentwicklung

​

Nutzerbenachrichtigungen und Transparenz

​

Sicherheit und Betrugsprävention

• Idempotenz: Verwenden Sie beim Ingestieren von Nutzungsereignissen immer eindeutige event_ids, um Doppelzählungen zu vermeiden. Dodos Ingestion-API übernimmt die Idempotenz automatisch, wenn Sie eine eindeutige ID bereitstellen, sodass ein Netzwerkwiederholungsversuch den Nutzer nicht doppelt belastet.
• Rate-Limiting: Implementieren Sie auf Anwendungsebene Rate-Limits, um zu verhindern, dass ein einzelner Nutzer seine Credits (oder Ihr API-Budget) zu schnell verbraucht. Das schützt Ihre Infrastruktur und die Brieftasche des Nutzers.
• Monitoring: Überwachen Sie Nutzungsmuster auf Anomalien, die auf Account-Sharing oder automatisierten Missbrauch hindeuten könnten. Dodos Analysefunktionen helfen Ihnen, solche Muster zu erkennen und Gegenmaßnahmen zu ergreifen, bevor sie zu einem größeren Problem werden.

​

Best Practices für Credit-Systeme

1. Halten Sie es einfach: Machen Sie Ihr Credit-System nicht zu kompliziert. Nutzer sollten leicht verstehen können, was eine Anfrage kostet und wie viele Credits noch übrig sind.
2. Bieten Sie Mehrwert: Stellen Sie sicher, dass die Credits für den Nutzer echten Wert haben. Wenn eine Anfrage zu teuer ist, entsteht das Gefühl, dass man „für jede Kleinigkeit bezahlen muss“.
3. Seien Sie transparent: Zeigen Sie dem Nutzer stets sein aktuelles Credit-Guthaben und die Nutzungshistorie. Das schafft Vertrauen und reduziert Verwirrung.
4. Automatisieren Sie alles: Nutzen Sie Dodos Webhooks und APIs, um so viel wie möglich vom Abrechnungsprozess zu automatisieren. Das minimiert manuelle Arbeit und stellt sicher, dass Ihre Abrechnung stets korrekt ist.

​

Zentrale Dodo-Funktionen im Einsatz