Cursor Billing Model

​

How Cursor Bills

4. Enterprise and Business: Teams use pooled usage where the entire organization shares a single credit bucket. This simplifies management and ensures heavy users don’t hit individual limits while others have unused capacity.

​

What Makes It Unique

• Provider Abstraction: A single subscription wraps multiple LLM providers like OpenAI and Anthropic, handling complex pricing and API keys behind the scenes.
• Weighted Depletion: Costs align with value by charging more for powerful models, making the pricing feel fair and transparent for all users.
• Graceful Degradation: The “Slow” queue prevents hard cutoffs, keeping users in the product and encouraging upgrades without being punitive.
• Pooled Credits: Team-level buckets reduce friction for enterprise customers by allowing efficient resource sharing across the entire organization.

​

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

​

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

​

Pooled Team Credits (Enterprise)

​

Implementation Strategy

1. Organization-Level Customer: Create a single customer_id in Dodo for the entire organization. This customer represents the billing entity for the team and holds the shared credit pool. All invoices and credit allocations are tied to this ID.
2. Seat-Based Billing: Use Dodo’s add-ons to charge a per-user platform fee. When a team adds a new member, you update the quantity of the “Seat” add-on. This ensures your revenue scales with the number of users while keeping the credit pool separate. It’s a clean way to handle multi-dimensional billing.
3. Shared Usage Tracking: All team members’ requests are ingested using the organization’s customer_id. This ensures that every request from any team member depletes the same central credit pool. You can still track individual user usage by including a user_id in the event metadata for internal reporting and analytics.

​

Comparison with Traditional SaaS Billing

• No “Cliff” Effects: Users don’t have to upgrade just because they hit a limit. They can pay for overages or accept slower performance. This keeps them in the product and reduces friction, leading to higher customer satisfaction and lower churn.
• Cost Alignment: Your revenue scales directly with your infrastructure costs. If a user uses expensive models, they pay more (either through credits or overages). This protects your margins and allows you to offer high-cost features sustainably without risking your business model.
• Better Retention: By not cutting users off, you keep them engaged with your product even when they’ve reached their limit. They can continue to work, which builds long-term loyalty and increases the lifetime value of the customer. It’s a win-win for both the user and the provider.

​

Handling Model Updates and Evolution

​

User Notifications and Transparency

​

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