Domina los Modelos de Suscripción con Stripe: De Flat-Rate a Usage-Based
Los modelos de suscripción han evolucionado. Ya no es suficiente un simple plan mensual: hoy necesitas flat-rate, per-seat, tiered y usage-based. Te muestro cómo implementarlos con Stripe y qué patrón elegir según tu negocio.
Domina los Modelos de Suscripción con Stripe: De Flat-Rate a Usage-Based
El Cambio que Nadie Esperaba
Hace cinco años, casi todos los SaaS usaban el mismo modelo: un plan mensual, punto. Hoy es diferente. Los fundadores han descubierto que cobrar según lo que realmente usan sus clientes es más justo, más escalable y genera menos fricción.
Y Stripe está ahí para facilitarlo.
La realidad es brutal: si tu modelo de negocio no se adapta a cómo tus clientes realmente consumen tu producto, alguien más lo hará. Por eso necesitas entender estos cuatro patrones y saber cuándo usarlos.
Los Cuatro Modelos Que Importan
#### 1. Flat-Rate: La Simplicidad Es Tu Arma
Un precio fijo, siempre. Sin sorpresas, sin cálculos.
Este modelo es perfecto cuando:
Tu producto tiene un valor claramente definido
Tus clientes no varían mucho en consumo
Quieres máxima simplicidad en la facturación
Ejemplo: una herramienta de diseño que cuesta lo mismo para todos, independientemente de cuántos proyectos crees.
Con Stripe, implementarlo es trivial:
```javascript const subscription = await stripe.subscriptions.create({ customer: customerId, items: [ { price: 'price_flatrate_monthly', }, ], }); ```
Lo difícil no es la técnica. Es decidir el precio correcto.
#### 2. Per-Seat: Escala Lineal Con Tu Cliente
Cobras por cada usuario que añade tu cliente. Típicamente lo ves en herramientas de colaboración.
Ventaja: tu cliente siente que paga por lo que usa. Desventaja: puede disuadirles de invitar a más gente a su equipo.
Implementación con Stripe:
```javascript const subscription = await stripe.subscriptions.create({ customer: customerId, items: [ { price: 'price_per_seat', quantity: numberOfSeats, }, ], });
// Cuando añaden un nuevo usuario await stripe.subscriptionItems.createUsageRecord( subscriptionItemId, { quantity: 1, action: 'increment' } ); ```
La clave aquí es sincronizar tu base de datos con Stripe. Cada vez que cambia el número de usuarios, Stripe necesita saberlo.
#### 3. Tiered: Diferentes Precios, Diferentes Beneficios
Tres planes: básico, profesional, empresarial. Cada uno con más features.
Este es el modelo tradicional, pero sigue siendo poderoso. La razón: crea una "escalera" psicológica que guía a tus clientes hacia arriba.
El truco: no hagas demasiados planes. Tres o cuatro es el máximo. Más de eso confunde.
```javascript const plans = { basic: 'price_basic_monthly', pro: 'price_pro_monthly', enterprise: 'price_enterprise_monthly', };
const subscription = await stripe.subscriptions.create({ customer: customerId, items: [ { price: plans[selectedPlan], }, ], }); ```
#### 4. Usage-Based: El Futuro (Y Ya Está Aquí)
Cobras según lo que realmente consumen. API calls, GB almacenados, minutos de procesamiento.
Este es el modelo que más está creciendo. Por qué: es el más justo. Un cliente que usa poco paga poco. Uno que explota tu servicio paga más. Todos contentos.
Pero es más complejo de implementar.
Con Stripe, usas "metered billing":
```javascript // Registrar uso en tiempo real await stripe.subscriptionItems.createUsageRecord( subscriptionItemId, { quantity: apiCallsThisMonth, action: 'set', // 'set' sobrescribe, 'increment' suma timestamp: Math.floor(Date.now() / 1000), } ); ```
La complejidad real está en: 1. Rastrear el uso con precisión - necesitas un sistema que cuente cada acción 2. Decidir el precio por unidad - demasiado alto ahuyenta, demasiado bajo no es rentable 3. Comunicarlo bien - tus clientes deben entender qué están pagando
El Modelo Híbrido: Tu Arma Secreta
Muchos SaaS ahora combinan modelos. Ejemplo:
Plan base fijo (flat-rate)
Más usuarios si lo necesitan (per-seat)
Uso extra facturado por encima de cierto límite (usage-based)
Esto es lo que ves en Vercel, Supabase, Stripe mismo.
Con Stripe, implementarlo requiere múltiples items en la misma suscripción:
```javascript const subscription = await stripe.subscriptions.create({ customer: customerId, items: [ { price: 'price_base_plan', // Flat-rate }, { price: 'price_per_seat', // Per-seat quantity: 5, }, { price: 'price_usage_based', // Usage-based }, ], }); ```
Cómo Elegir Tu Modelo
No existe un modelo "mejor". Depende de tu negocio:
Elige Flat-Rate si:
Tu producto tiene valor uniforme
Quieres máxima simplicidad
Tus clientes varían poco en consumo
Elige Per-Seat si:
Tu producto escala con usuarios
Quieres que crezca con tu cliente
Es fácil contar "asientos"
Elige Tiered si:
Tienes features claramente diferenciadas
Quieres guiar a clientes hacia planes premium
Es un modelo probado en tu industria
Elige Usage-Based si:
El consumo varía enormemente entre clientes
Quieres que pagues solo por lo que usas
Tienes infraestructura para rastrear uso
La Realidad de Implementar Esto
La API de Stripe es sólida. Pero hay detalles que muchos desarrolladores ignoran:
1. Webhooks - necesitas escuchar `invoice.payment_succeeded` para saber cuándo facturar 2. Sincronización - tu base de datos y Stripe deben estar en sync 3. Pruebas - es fácil romper facturación. Prueba todo. 4. Documentación para clientes - explica cómo funciona tu modelo
```javascript // Webhook básico para procesar facturación app.post('/webhooks/stripe', async (req, res) => { const event = req.body;
if (event.type === 'invoice.payment_succeeded') { const invoice = event.data.object; // Tu lógica aquí: enviar confirmación, actualizar acceso, etc. }
res.json({ received: true }); }); ```
El Factor Psicológico
Aquí está lo que nadie dice: el modelo de precios es psicología pura.
Usage-based suena justo, pero asusta a clientes que no saben cuánto van a gastar. Flat-rate es predecible, pero algunos clientes sienten que pagan por lo que no usan.
La mejor estrategia: ofrece un modelo que tenga sentido para tu negocio, pero comunícalo de forma que tu cliente entienda exactamente qué paga y por qué.
Mi Recomendación
Si estás empezando: empieza con flat-rate o tiered. Es simple, funciona, y tus clientes lo entienden.
Cuando crezcas y tengas suficientes datos: experimenta con usage-based. Muchos SaaS descubren que es más rentable.
Y siempre: usa Stripe. No es la única opción, pero es la más confiable. La documentación es buena, la API es estable, y el soporte funciona.
El Próximo Paso
No necesitas implementar todos los modelos hoy. Necesitas elegir uno, implementarlo bien, y iterar.
Mira tu competencia. Mira a tus clientes. Elige el modelo que tenga más sentido.
Y recuerda: el mejor modelo de precios es el que tus clientes entienden y aceptan sin fricción.
---
¿Qué modelo usas en tu SaaS? ¿Cuál fue tu mayor dolor implementándolo con Stripe? Comparte en los comentarios.
Lee el artículo completo en brianmenagomez.com