Modelo de Cobrança do Cursor

​

Como o Cursor Cobra

4. Enterprise e Business: Equipes usam utilização agrupada em que toda a organização compartilha um único bucket de créditos. Isso simplifica o gerenciamento e garante que usuários intensos não atinjam limites individuais enquanto outros têm capacidade ociosa.

​

O que o torna único

• Abstração de Provedores: Uma única assinatura engloba vários provedores de LLM como OpenAI e Anthropic, lidando com preços complexos e chaves de API nos bastidores.
• Esgotamento Ponderado: Os custos se alinham ao valor ao cobrar mais por modelos poderosos, fazendo o preço parecer justo e transparente para todos os usuários.
• Degradação Suave: A fila “Lenta” evita cortes abruptos, mantendo os usuários no produto e incentivando upgrades sem punições.
• Créditos Compartilhados: Buckets em nível de equipe reduzem atrito para clientes empresariais permitindo compartilhamento eficiente de recursos em toda a organização.

​

Recrie isso com o 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'
});

​

Acelere com o Blueprint de Ingestão de 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éditos Compartilhados por Equipe (Enterprise)

​

Estratégia de Implementação

1. Cliente em Nível Organizacional: Crie um único customer_id no Dodo para toda a organização. Esse cliente representa a entidade de cobrança da equipe e detém o pool compartilhado de créditos. Todas as faturas e alocações de crédito estão vinculadas a esse ID.
2. Cobrança por Assento: Use complementos do Dodo para cobrar uma taxa por usuário da plataforma. Quando uma equipe adiciona um novo membro, você atualiza a quantidade do complemento “Assento”. Isso garante que sua receita escale com o número de usuários, mantendo o pool de créditos separado. É uma maneira organizada de lidar com cobrança multidimensional.
3. Rastreamento de Uso Compartilhado: Todas as solicitações dos membros da equipe são ingeridas usando o customer_id da organização. Isso garante que cada solicitação de qualquer membro da equipe reduza o mesmo pool central de créditos. Você ainda pode rastrear o uso individual incluindo um user_id nos metadados do evento para relatórios e análises internas.

​

Comparação com Cobrança SaaS Tradicional

• Sem Efeitos de “Penhasco”: Os usuários não precisam fazer upgrade apenas porque atingiram um limite. Eles podem pagar por excedentes ou aceitar desempenho mais lento. Isso os mantém no produto e reduz atrito, levando a maior satisfação do cliente e menor churn.
• Alinhamento de Custos: Sua receita escala diretamente com seus custos de infraestrutura. Se um usuário usa modelos caros, ele paga mais (seja por créditos ou excedentes). Isso protege suas margens e permite oferecer recursos de alto custo de forma sustentável sem comprometer seu modelo de negócios.
• Melhor Retenção: Ao não cortar o acesso dos usuários, você os mantém engajados com seu produto mesmo após atingirem o limite. Eles podem continuar trabalhando, o que constrói fidelidade a longo prazo e aumenta o valor vitalício do cliente. É um ganha-ganha para o usuário e para o provedor.

​

Lidando com Atualizações e Evolução de Modelos

​

Notificações ao Usuário e Transparência

​

Segurança e Prevenção de Fraudes

• Idempotência: Use sempre event_ids únicos ao ingerir eventos de uso para evitar contagem dupla. A API de ingestão do Dodo lida automaticamente com idempotência se você fornecer um ID único, garantindo que uma nova tentativa de rede não cobre o usuário duas vezes.
• Limitação de Taxa: Implemente limitação de taxa no nível da aplicação para evitar que um único usuário esgote os créditos (ou seu orçamento de API) muito rapidamente. Isso protege sua infraestrutura e o bolso do usuário.
• Monitoramento: Monitore padrões de uso em busca de anomalias que possam indicar compartilhamento de conta ou abuso automatizado. As análises do Dodo podem ajudá-lo a identificar esses padrões, permitindo que você tome medidas antes que se tornem um problema maior.

​

Melhores Práticas para Sistemas de Créditos

1. Mantenha Simples: Não torne seu sistema de créditos muito complexo. Os usuários devem conseguir entender facilmente quanto custa uma solicitação e quantos créditos lhes restam.
2. Ofereça Valor: Garanta que os créditos ofereçam valor real ao usuário. Se o custo de uma solicitação for muito alto, os usuários sentirão que estão sendo explorados.
3. Seja Transparente: Mostre sempre ao usuário seu saldo atual de créditos e o histórico de uso. Isso constrói confiança e reduz confusão.
4. Automatize Tudo: Use os webhooks e APIs do Dodo para automatizar ao máximo o processo de cobrança. Isso reduz trabalho manual e garante que sua cobrança esteja sempre precisa.

​

Principais Recursos do Dodo Utilizados