Cancelar una suscripción sin quitar el acceso antes de tiempo (Stripe y Polar)
Quien cancela conserva lo pagado hasta fin de periodo. Cómo tratar cancel_at_period_end en Stripe y canceled frente a revoked en Polar.
Este blog es de CREA.MBA, un boilerplate de Next.js con auth, pagos y panel de admin ya montados. Ver qué incluye
Un usuario paga el plan mensual el día 3. El día 10 decide que no va a seguir y pulsa «Cancelar suscripción». El día 11 entra a tu app y se encuentra en el plan gratuito, sin acceso a lo que había pagado hasta el día 3 del mes siguiente.
Ese fallo es de los más comunes en SaaS pequeños, y casi siempre nace en el mismo sitio: el handler del webhook ve la palabra cancel en el nombre del evento y pone el plan a FREE. En este artículo vemos qué mandan de verdad Stripe y Polar cuando alguien cancela, qué hay que guardar en la base de datos y cómo escribir la comprobación de acceso para que el día de corte sea el que el usuario pagó.
Cancelar y terminar son dos momentos distintos
En casi cualquier SaaS, cuando el usuario cancela desde el portal de cliente pasan dos cosas separadas en el tiempo:
- Hoy: la suscripción se marca para no renovarse. Sigue activa y el usuario conserva lo que ha pagado.
- Al final del periodo: la suscripción termina. Ahora sí se corta el acceso.
Entre una y otra el usuario puede arrepentirse y reactivar, y eso también hay que contemplarlo. Si tu código solo reacciona a la primera, quitas el acceso semanas antes de tiempo. Si solo reacciona a la segunda pero lee mal el estado, se lo dejas para siempre.
Lo que manda Stripe
En Stripe, la cancelación al final del periodo se hace poniendo cancel_at_period_end: true en la suscripción. Según su documentación, eso permite que la suscripción complete el tiempo que el cliente ya ha pagado, y se puede revertir poniendo el campo a false en cualquier momento antes de que acabe el periodo.
Los eventos son estos:
| Evento | Cuándo llega | Qué significa |
|---|---|---|
customer.subscription.updated |
Al programar la cancelación (y al deshacerla) | cancel_at_period_end cambia; el estado sigue active |
customer.subscription.deleted |
Al terminar el periodo, o al cancelar de inmediato | Estado canceled; ya no se puede reactivar |
Hay un tercer camino que conviene conocer: cancel_at, una fecha concreta de cancelación que puede no coincidir con el final del periodo (si la fecha cae antes, Stripe ajusta el current_period_end del item a esa fecha). Si en algún momento ofreces cancelar en una fecha concreta, o usas subscription schedules con end_behavior: cancel, la información del corte viene por ahí y no por cancel_at_period_end.
Y un detalle de la API reciente: desde la versión 2025-03-31.basil, el current_period_end vive en cada item de la suscripción (subscription.items.data[0].current_period_end) y ya no en la suscripción.
Lo que manda Polar
Polar tiene un evento con nombre propio para cada momento, y ahí está la trampa. Su documentación lo explica en la sección de cancelaciones:
subscription.canceled: el usuario ha cancelado. La suscripción sigue con estadoactive, pero concancel_at_period_endatrue.subscription.uncanceled: ha deshecho la cancelación.subscription.revoked: la suscripción se revoca definitivamente, se paran los cobros y se retiran los beneficios.
Con esos nombres, es muy natural escribir esto:
// ❌ Corta el acceso el día que el usuario cancela
case 'subscription.canceled':
case 'subscription.revoked':
await db.subscription.update({
where: { subscriptionId: event.data.id },
data: { status: 'CANCELED' },
});
break;Y está mal. subscription.canceled es, a efectos de acceso, una actualización más: hay que guardar cancelAtPeriodEnd: true y dejar el estado como venga. Solo subscription.revoked cierra la puerta. Polar además manda subscription.updated en todos estos cambios (su documentación lo describe como el evento comodín para cancelaciones y reactivaciones), así que tratar todos con la misma función de sincronización es lo más seguro.
Un aviso más si usas el SDK de Polar. validateEvent pasa el payload por sus esquemas y te lo devuelve en camelCase y con fechas como Date: el campo es event.data.cancelAtPeriodEnd, no cancel_at_period_end. Si lees los nombres en snake_case de los ejemplos JSON, todo te llega undefined y el || false de turno lo convierte en «no cancela nunca».
Qué guardar en la base de datos
Para decidir el acceso necesitas tres datos de cada suscripción. Este es un modelo mínimo con Prisma:
model Subscription {
id String @id @default(cuid())
userId String
provider String // 'STRIPE' | 'POLAR'
subscriptionId String
status String // active, trialing, past_due, canceled...
currentPeriodEnd DateTime
cancelAtPeriodEnd Boolean @default(false)
canceledAt DateTime?
updatedAt DateTime @updatedAt
@@unique([provider, subscriptionId])
@@index([userId])
}Lo importante es que el webhook copie el estado del proveedor en vez de traducir eventos a decisiones. Una única función de sincronización para todos los eventos de suscripción:
// Polar: los campos vienen en camelCase tras validateEvent
async function syncPolarSubscription(sub: {
id: string;
status: string;
currentPeriodEnd: Date;
cancelAtPeriodEnd: boolean;
canceledAt: Date | null;
metadata: Record;
}) {
const userId = String(sub.metadata.userId ?? '');
if (!userId) return;
const data = {
status: sub.status,
currentPeriodEnd: sub.currentPeriodEnd,
cancelAtPeriodEnd: sub.cancelAtPeriodEnd,
canceledAt: sub.canceledAt,
};
await db.subscription.upsert({
where: { provider_subscriptionId: { provider: 'POLAR', subscriptionId: sub.id } },
update: data,
create: { userId, provider: 'POLAR', subscriptionId: sub.id, ...data },
});
}
switch (event.type) {
case 'subscription.created':
case 'subscription.updated':
case 'subscription.active':
case 'subscription.canceled':
case 'subscription.uncanceled':
case 'subscription.revoked':
await syncPolarSubscription(event.data);
break;
}subscription.revoked pasa por la misma función: el payload ya trae el estado final, y guardarlo es todo lo que hay que hacer. El userId sale de los metadatos que pusiste al crear el checkout; si en tu caso lo resuelves por el cliente de Polar, cambia esa línea.
En Stripe es igual, con una diferencia: como el orden de los eventos no está garantizado, compensa recuperar la suscripción con stripe.subscriptions.retrieve() antes de guardarla, como explicamos en webhooks de Stripe en Next.js 16.
La comprobación de acceso
Con esos datos, la pregunta «¿tiene acceso este usuario?» se responde sin mirar qué evento llegó el último:
const ACCESS_STATUSES = new Set(['active', 'trialing']);
export function hasActiveAccess(sub: {
status: string;
currentPeriodEnd: Date;
} | null): boolean {
if (!sub) return false;
if (!ACCESS_STATUSES.has(sub.status)) return false;
return sub.currentPeriodEnd.getTime() > Date.now();
}cancelAtPeriodEnd no aparece en la comprobación, y es a propósito. Una suscripción cancelada pero dentro de su periodo sigue active con un currentPeriodEnd futuro, así que tiene acceso. Cuando el periodo termina, el proveedor manda el evento final, el estado pasa a canceled y el acceso se cierra.
La condición sobre currentPeriodEnd es un cinturón de seguridad por si el último webhook no llega (un despliegue caído justo ese día, un endpoint desactivado). Con ella, como mucho das acceso hasta la fecha que el usuario pagó, y no indefinidamente. Si prefieres dar unas horas de margen para absorber retrasos del proveedor al renovar, súmalas aquí y no en el webhook.
Para past_due (el cobro de renovación ha fallado) cada producto decide. Stripe sigue reintentando el cobro según tu configuración y, tras los intentos fallidos que configures en el dashboard, cancela la suscripción o la deja impagada, según lo que elijas ahí. Hay SaaS que mantienen el acceso durante ese tiempo y otros que lo cortan; lo que importa es que la decisión esté en hasActiveAccess y en ningún otro sitio.
Esta función se usa en el servidor, en el mismo sitio donde compruebas la sesión: en la página, en la server action o en el route handler que sirve la funcionalidad de pago. En el cliente, el plan solo sirve para pintar la interfaz.
Lo que ve el usuario
Con cancelAtPeriodEnd y currentPeriodEnd guardados, la página de facturación puede decir la verdad:
{sub.cancelAtPeriodEnd
? `Tu plan termina el ${formatDate(sub.currentPeriodEnd)}`
: `Se renueva el ${formatDate(sub.currentPeriodEnd)}`}Y conviene ofrecer el botón de reactivar mientras no haya terminado el periodo. En Stripe es un stripe.subscriptions.update(id, { cancel_at_period_end: false }); en Polar, el portal de cliente lo permite y te llega subscription.uncanceled. Un usuario que cancela un martes por despiste y lo deshace el jueves no debería tener que volver a pasar por el checkout.
Cómo probarlo
Probar el final del periodo sin esperar un mes requiere herramientas:
- Stripe: los test clocks permiten crear una suscripción en el entorno de pruebas y adelantar el reloj hasta después del
current_period_end. Con eso ves llegar elcustomer.subscription.deleteden local. - Polar: en el sandbox, cancela desde el portal de cliente y comprueba que llega
subscription.canceledy que el usuario sigue teniendo acceso. Para el final, puedes revocar la suscripción desde el panel y comprobar que llegasubscription.revoked.
En los dos casos, la prueba que más errores caza es la primera: cancelar y verificar que al día siguiente el usuario sigue dentro.
Lo que te llevas
- Cancelar programa el final; el acceso se corta cuando el proveedor dice que la suscripción ha terminado.
- En Polar,
subscription.canceledse trata como una actualización. Solosubscription.revokedcierra. - Guarda
status,currentPeriodEndycancelAtPeriodEnd, y deja que una única función decida el acceso. - Con el SDK de Polar, los campos llegan en camelCase.
Si estás montando los pagos desde cero, tienes la integración base en cómo integrar Polar en Next.js y el porqué de elegir uno u otro en Polar o Stripe para tu SaaS indie. CREA.MBA trae los dos proveedores detrás de la misma interfaz y el modelo de suscripción con estos campos en el esquema de Prisma.
¿Tu app corta el acceso al cancelar o al terminar el periodo? ¿Lo has comprobado con una suscripción de prueba?
¿Te gustó este artículo?
Suscríbete para más tutoriales y tips sobre crear productos con IA