Modelo de facturación de Cursor

​

Cómo factura Cursor

4. Enterprise y Business: Los equipos usan el uso compartido donde toda la organización comparte un único depósito de créditos. Esto simplifica la gestión y evita que los usuarios intensivos alcancen límites individuales mientras otros tienen capacidad sin usar.

​

Qué lo hace único

• Abstracción de proveedores: Una sola suscripción engloba múltiples proveedores de LLM como OpenAI y Anthropic, gestionando precios complejos y claves de API en segundo plano.
• Agotamiento ponderado: Los costes se alinean con el valor al cobrar más por modelos potentes, haciendo que la tarificación parezca justa y transparente para todos los usuarios.
• Degradación gradual: La cola “lenta” evita cortes bruscos, manteniendo a los usuarios en el producto y fomentando actualizaciones sin ser punitivo.
• Créditos compartidos: Los depósitos a nivel de equipo reducen la fricción para clientes empresariales permitiendo compartir recursos de forma eficiente en toda la organización.

​

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

​

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

​

Créditos compartidos por equipo (Enterprise)

​

Estrategia de implementación

1. Cliente a nivel de organización: Crea un único customer_id en Dodo para toda la organización. Este cliente representa la entidad facturable del equipo y mantiene la reserva de créditos compartida. Todas las facturas y asignaciones de créditos están vinculadas a esta ID.
2. Facturación por asientos: Utiliza los complementos (add-ons) de Dodo para cobrar una tarifa por usuario en la plataforma. Cuando un equipo agrega un nuevo miembro, actualizas la cantidad del complemento “Asiento”. Esto asegura que tus ingresos escalen con el número de usuarios mientras mantienes el pool de créditos separado. Es una forma limpia de gestionar la facturación multidimensional.
3. Seguimiento de uso compartido: Todas las solicitudes de los miembros del equipo se ingieren usando la customer_id de la organización. Esto garantiza que cada solicitud de cualquier miembro agote el mismo pool central de créditos. Aun así puedes rastrear el uso individual incluyendo una user_id en los metadatos del evento para informes internos y análisis.

​

Comparación con la facturación SaaS tradicional

• Sin efectos de “acantilado”: Los usuarios no tienen que actualizar solo porque alcanzaron un límite. Pueden pagar sobrepasos o aceptar un rendimiento más lento. Esto los mantiene dentro del producto y reduce la fricción, lo que se traduce en mayor satisfacción del cliente y menor churn.
• Alineación de costes: Tus ingresos escalan directamente con tus costes de infraestructura. Si un usuario usa modelos costosos, paga más (ya sea mediante créditos o sobrepasos). Esto protege tus márgenes y te permite ofrecer características de alto coste de forma sostenible sin arriesgar tu modelo de negocio.
• Mejor retención: Al no cortar a los usuarios, los mantienes comprometidos con tu producto incluso cuando han alcanzado su límite. Pueden seguir trabajando, lo que genera lealtad a largo plazo y aumenta el valor de vida del cliente. Es un escenario beneficioso tanto para el usuario como para el proveedor.

​

Gestión de actualizaciones y evolución de modelos

​

Notificaciones al usuario y transparencia

​

Seguridad y prevención de fraudes

• Idempotencia: Siempre utiliza event_id únicos al ingerir eventos de uso para evitar contar dos veces. La API de ingestión de Dodo gestiona la idempotencia automáticamente si proporcionas un ID único, garantizando que una reintento en la red no cobre dos veces al usuario.
• Limitación de velocidad: Implementa limitación de velocidad a nivel de aplicación para evitar que un solo usuario agote sus créditos (o tu presupuesto de API) demasiado rápido. Esto protege tu infraestructura y la cartera del usuario.
• Monitorización: Supervisa los patrones de uso en busca de anomalías que puedan indicar compartición de cuentas o abuso automatizado. Los análisis de Dodo pueden ayudarte a identificar estos patrones, permitiéndote actuar antes de que se conviertan en un problema grave.

​

Mejores prácticas para sistemas de créditos

1. Mantenlo sencillo: No hagas que tu sistema de créditos sea demasiado complejo. Los usuarios deberían poder entender fácilmente cuánto cuesta una solicitud y cuántos créditos les quedan.
2. Ofrece valor: Asegúrate de que los créditos aporten valor real al usuario. Si el coste de una solicitud es demasiado alto, los usuarios sentirán que los están sangrando a pequeños cargos.
3. Sé transparente: Siempre muestra al usuario su saldo de créditos actual e historial de uso. Esto genera confianza y reduce la confusión.
4. Automatiza todo: Utiliza los webhooks y APIs de Dodo para automatizar tanto como sea posible el proceso de facturación. Esto reduce el trabajo manual y garantiza que tu facturación sea siempre precisa.

​

Características clave de Dodo utilizadas