Cursor faktureringsmodell

​

Hur Cursor fakturerar

4. Enterprise och Business: Team använder poolad användning där hela organisationen delar på en gemensam kreditbalja. Det förenklar hantering och säkerställer att tunga användare inte når individuella gränser medan andra har outnyttjad kapacitet.

​

Vad som gör det unikt

• Leverantörsabstraktion: En enda prenumeration omsluter flera LLM-leverantörer som OpenAI och Anthropic, och hanterar komplex prissättning samt API-nycklar bakom kulisserna.
• Viktad uttömning: Kostnaderna överensstämmer med värdet genom att debiteras mer för kraftfulla modeller, vilket gör att prissättningen känns rättvis och transparent för alla användare.
• Graceful degradation: Den “långsamma” kön förhindrar hårda avbrott, håller användarna i produkten och uppmuntrar uppgraderingar utan att vara straffande.
• Poolade krediter: Teamnivåbaljor minskar friktionen för företagskunder genom att möjliggöra effektiv resursdelning över hela organisationen.

​

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

​

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

​

Poolade teamkrediter (Enterprise)

​

Implementeringsstrategi

1. Organisationsnivåkund: Skapa en enda customer_id i Dodo för hela organisationen. Denna kund representerar faktureringsenheten för teamet och håller den delade kreditpoolen. Alla fakturor och kreditallokeringar knyts till detta ID.
2. Sätebaserad fakturering: Använd Dodos tillägg för att ta ut en plattformavgift per användare. När ett team lägger till en ny medlem uppdaterar du kvantiteten för “Seat”-tillägget. Detta säkerställer att din intäkt skalar med antalet användare samtidigt som kreditpoolen hålls separat. Det är ett rent sätt att hantera multidimensionell fakturering.
3. Delad användningsspårning: Alla teammedlemmars förfrågningar inges med organisationens customer_id. Detta säkerställer att varje förfrågan från någon teammedlem tömmer samma centrala kreditpool. Du kan fortfarande spåra individuell användaranvändning genom att inkludera ett user_id i händelsemetadata för intern rapportering och analys.

​

Jämförelse med traditionell SaaS-fakturering

• Inga “klippkants”-effekter: Användare behöver inte uppgradera bara för att de nått en gräns. De kan betala för övertrasseringar eller acceptera långsammare prestanda. Detta håller dem i produkten och minskar friktionen, vilket leder till högre kundnöjdhet och lägre churn.
• Kostnadsanpassning: Dina intäkter ökar i takt med dina infrastrukturkostnader. Om en användare använder dyra modeller betalar de mer (antingen via krediter eller övertrasseringar). Detta skyddar dina marginaler och låter dig erbjuda högkostnadsfunktioner hållbart utan att riskera affärsmodellen.
• Bättre retention: Genom att inte stänga av användare håller du dem engagerade i din produkt även när de nått sin gräns. De kan fortsätta arbeta, vilket bygger långsiktig lojalitet och ökar kundens livstidsvärde. Det är en win-win för både användare och leverantör.

​

Hantering av modelluppdateringar och utveckling

​

Användarnotifieringar och transparens

​

Säkerhet och bedrägeriförebyggande

• Idempotens: Använd alltid unika event_id när du matar in användningshändelser för att undvika dubbelräkning. Dodos ingestion API hanterar idempotens automatiskt om du tillhandahåller ett unikt ID, vilket säkerställer att ett nätverksomförsök inte debiterar användaren två gånger.
• Hastighetsbegränsning: Implementera hastighetsbegränsning på applikationsnivå för att förhindra att en enda användare tömmer sina krediter (eller din API-budget) för snabbt. Detta skyddar din infrastruktur och användarens plånbok.
• Övervakning: Övervaka användningsmönster för avvikelser som kan indikera kontodelning eller automatiserat missbruk. Dodos analysverktyg kan hjälpa dig identifiera dessa mönster så att du kan agera innan de blir ett större problem.

​

Bästa praxis för kreditsystem

1. Håll det enkelt: Gör inte ditt kreditsystem för komplicerat. Användare bör enkelt kunna förstå hur mycket en förfrågan kostar och hur många krediter de har kvar.
2. Ge verkligt värde: Säkerställ att krediterna ger verkligt värde för användaren. Om kostnaden för en förfrågan är för hög kommer användarna att känna att de blir nickel-and-dimed.
3. Var transparent: Visa alltid användaren deras nuvarande kreditbalans och användningshistorik. Detta bygger förtroende och minskar förvirring.
4. Automatisera allt: Använd Dodos webhooks och API:er för att automatisera så mycket av faktureringsprocessen som möjligt. Det minskar manuellt arbete och säkerställer att din fakturering alltid är korrekt.

​

Viktiga Dodo-funktioner som används