Notificaciones push con Expo que sí llegan: tokens, tickets y recibos
En la práctica/ 17 min de lectura
Los cuatro puntos donde se pierden las notificaciones push con Expo, con código probado para guardar el token, leer los recibos de entrega y limpiar tokens muertos.
- React
- Node.js
En este artículo (9)
Si tus notificaciones push con Expo no llegan, casi siempre falla uno de cuatro puntos: el permiso, el token, el envío o la entrega. Pide permiso cuando el usuario entiende para qué, guarda y renueva el token en tu servidor, revisa los recibos de entrega unos 15 minutos después y desactiva los tokens que devuelven DeviceNotRegistered.
Aquí tienes el código de la app (permiso y token), la tabla en Postgres y el código del servidor que envía, guarda los tickets y lee los recibos. El código del servidor lo corrimos contra una copia local de la API de Expo, sin mandar nada al servicio real.
Dónde se pierden las notificaciones push con Expo
Una notificación hace cuatro saltos. La app obtiene un token de Expo con getExpoPushTokenAsync y lo manda a tu servidor. Tu servidor envía el mensaje al servicio de push de Expo. Expo se lo entrega a Firebase Cloud Messaging (FCM) en Android o a Apple Push Notification service (APNs) en iOS. Y ellos lo llevan al teléfono, que decide si lo muestra según los permisos y la configuración del usuario.
Cada salto tiene su propia forma de fallar, y cada uno responde "ok" con un significado distinto. Según la documentación de envío de Expo (actualizada el 16 de noviembre de 2026), un ticket con status: "ok" solo significa que los servidores de Expo recibieron el mensaje. Un recibo con "ok" significa que FCM o APNs lo aceptaron y van a intentar entregarlo, pero el dispositivo no necesariamente lo recibe. Ninguno de los dos te dice que el usuario vio la notificación.
Desliza la figura para verla completa
| Punto | Síntoma | Dónde lo ves | Qué revisar |
|---|---|---|---|
| 1. Permiso | No hay token o no se muestra nada | En la app: getPermissionsAsync | Cuándo pides el permiso y el canal de Android |
| 2. Token | Envías a un token viejo o de otro usuario | En tu base de datos | Que se guarde en cada inicio y cuando cambia |
| 3. Envío | La petición falla o el ticket trae error | En la respuesta de /push/send | Límites, formato y DeviceNotRegistered |
| 4. Entrega | El ticket es "ok" pero no llega | En los recibos, 15 minutos después | Credenciales, tamaño y tokens muertos |
Pedir permiso en el momento correcto
El permiso es el primer punto de falla y el único que no puedes repetir a voluntad. La documentación de Apple sobre el permiso de notificaciones lo dice así: la primera vez que la app pide autorización, el sistema muestra el aviso y guarda la respuesta; las siguientes peticiones ya no lo muestran. Si lo pides al abrir la app por primera vez, el usuario todavía no sabe para qué lo quieres y lo más fácil es decir que no.
Apple recomienda pedirlo en un contexto que explique por qué lo necesitas. Su ejemplo es una app de tareas que lo pide después de que la persona programa su primer recordatorio. En una tienda, el equivalente es la pantalla de confirmación del pedido: "¿Te aviso cuando salga tu paquete?". Muestra tu propio mensaje primero y llama a requestPermissionsAsync solo si el usuario dice que sí; así no gastas el aviso del sistema con alguien que no quería notificaciones.
En iOS existe una alternativa: la autorización provisional. Las notificaciones llegan en silencio, solo al historial del centro de notificaciones, con botones para conservarlas o apagarlas, y no se muestra ningún aviso de permiso. En Expo se pide con requestPermissionsAsync({ ios: { allowProvisional: true } }). Ojo: en ese caso granted puede venir en false, y la referencia de expo-notifications revisa ios.status === IosAuthorizationStatus.PROVISIONAL para saber si puedes enviar.
En Android 13 y posteriores el usuario también tiene que aceptar un aviso, y según la misma referencia ese aviso no aparece hasta que exista al menos un canal de notificaciones. El canal también tiene que crearse antes de pedir el token. Si tu app pide permiso antes de crear el canal, el aviso nunca sale y parece que el usuario lo rechazó.
Guardar y actualizar el token
Este archivo de la app hace las tres cosas: crea el canal, pide permiso solo si todavía se puede y guarda el token. También escucha si el sistema cambia el token mientras la app está abierta. Lo revisamos con tsc --strict contra los tipos de expo-notifications 58.1.9 y expo-constants del SDK 58:
// notifications.ts: ask in context, save the token, keep it fresh.
import * as Notifications from "expo-notifications";
import Constants from "expo-constants";
const projectId = Constants.expoConfig?.extra?.eas?.projectId ?? Constants.easConfig?.projectId;
Notifications.setNotificationHandler({
handleNotification: async () => ({
shouldShowBanner: true,
shouldShowList: true,
shouldPlaySound: false,
shouldSetBadge: false,
}),
});
type Result = "granted" | "denied" | "blocked";
export async function enablePushAsync(saveToken: (token: string) => Promise<void>): Promise<Result> {
// Android 13+: no prompt until a channel exists. On iOS this resolves to null.
await Notifications.setNotificationChannelAsync("default", {
name: "Orders",
importance: Notifications.AndroidImportance.DEFAULT,
});
let perm = await Notifications.getPermissionsAsync();
if (!perm.granted && perm.canAskAgain) perm = await Notifications.requestPermissionsAsync();
if (!perm.granted) return perm.canAskAgain ? "denied" : "blocked";
if (!projectId) throw new Error("No EAS projectId in app config");
const { data } = await Notifications.getExpoPushTokenAsync({ projectId });
await saveToken(data);
return "granted";
}
export function keepTokenFresh(saveToken: (token: string) => Promise<void>) {
return Notifications.addPushTokenListener(async (devicePushToken) => {
// Pass the new device token in: fetching it again here would fire this listener again.
const { data } = await Notifications.getExpoPushTokenAsync({ projectId, devicePushToken });
await saveToken(data);
});
}
projectIdsale de la configuración de EAS. La guía de configuración de Expo lo usa para atar el token a tu proyecto; sin él,getExpoPushTokenAsyncfalla.setNotificationHandlerdecide qué pasa si llega una notificación con la app abierta. Los cuatro campos (shouldShowBanner,shouldShowList,shouldPlaySound,shouldSetBadge) son los de la guía. Sin handler, la referencia dice que la notificación se muestra con banner; con él eliges: aquí banner y lista sí, sonido e insignia no.setNotificationChannelAsyncva primero, por la regla de Android 13. En iOS no hace nada y devuelvenull, así que no hace falta preguntar por la plataforma.getPermissionsAsynclee el estado sin mostrar nada. Solo si no hay permiso ycanAskAgaines verdadero se llama arequestPermissionsAsync.- La función devuelve
"blocked"cuando ya no se puede preguntar. Ahí la única salida es mandar al usuario a los ajustes del sistema; volver a llamar no hace nada. getExpoPushTokenAsyncdevuelve un objeto; el token, con la formaExponentPushToken[...], está endata.saveTokenes tu llamada al servidor, con la sesión del usuario.keepTokenFreshusaaddPushTokenListener. La referencia dice que en casos raros el servicio cambia el token con la app abierta y que el viejo deja de servir. El listener recibe el token nuevo del dispositivo y se lo pasamos agetExpoPushTokenAsynccomodevicePushToken: si lo pidiera otra vez dentro del listener, el listener se volvería a disparar.
Llama a keepTokenFresh una vez, después del inicio de sesión, y guarda la suscripción para quitarla al cerrar sesión. Además, en cada arranque, si getPermissionsAsync ya dice que hay permiso, vuelve a mandar el token: no muestra nada y cubre las reinstalaciones y los cambios de cuenta en el mismo teléfono.
Del lado del servidor, el token es la llave, no el usuario: un usuario puede tener varios teléfonos y un teléfono puede cambiar de cuenta. Esta es la tabla, probada con PGlite (Postgres 18):
CREATE TABLE push_tokens (
token text PRIMARY KEY,
user_id bigint NOT NULL,
updated_at timestamptz NOT NULL DEFAULT now(),
disabled_at timestamptz
);
CREATE TABLE push_pending (
ticket_id text PRIMARY KEY,
token text NOT NULL REFERENCES push_tokens (token),
sent_at timestamptz NOT NULL DEFAULT now()
);
-- saveToken on the server
INSERT INTO push_tokens (token, user_id) VALUES ($1, $2)
ON CONFLICT (token) DO UPDATE
SET user_id = EXCLUDED.user_id, updated_at = now(), disabled_at = NULL;
tokenes la llave primaria: un token es un dispositivo, y si el mismo teléfono inicia sesión con otra cuenta, la fila cambia de dueño en lugar de duplicarse.disabled_atmarca los tokens que ya no sirven. No se borran de inmediato porquepush_pendinglos referencia.push_pendingguarda el ID de cada ticket "ok" con su token y la hora de envío, para leer el recibo después.- El
INSERT ... ON CONFLICTes lo que ejecutasaveToken: actualiza el usuario y la fecha, y quitadisabled_atsi el dispositivo vuelve a registrarse.
Desliza la figura para verla completa
Probar en un teléfono real
Lo primero: Expo Go no sirve para esto. La referencia de expo-notifications dice que las notificaciones push no están disponibles en Expo Go en Android desde el SDK 53, y la página sobre los tipos de notificación pide usar un development build porque la función no viene incluida en Expo Go. Si ya hiciste un development build para migrar a la arquitectura nueva de React Native, usa ese mismo.
La guía de configuración acepta un teléfono físico, un emulador de Android con Google Play services o un simulador de iOS con Xcode 14 o posterior (macOS 13+, iOS 16+). El emulador sirve para iterar rápido, pero antes de publicar prueba en un teléfono real: es donde se juntan el aviso de permiso, el canal que creaste, las credenciales reales (FCM V1 en Android, la llave de APNs en iOS) y la configuración que tiene el usuario.
Con el development build abierto y el token en pantalla o en tu log, tienes dos formas de mandar una prueba: la herramienta de Expo en expo.dev/notifications, donde pegas el token, o una petición directa a la API:
curl -H "Content-Type: application/json" -X POST "https://exp.host/--/api/v2/push/send" \
-d '{"to": "ExponentPushToken[xxxxxxxxxxxxxxxxxxxxxx]", "title": "Prueba", "body": "Hola desde el servidor"}'
- La petición es un
POSTcon JSON al endpoint de envío; el encabezadoContent-Type: application/jsones obligatorio. toes el token que imprimió tu app;titleybodyson el texto visible.- La respuesta trae
datacon un ticket:statusy, si es "ok", unidpara pedir el recibo.
Prueba tres estados: app abierta (decide tu setNotificationHandler), app en segundo plano y app cerrada. En Android, si el usuario forzó el cierre de la app, Expo advierte que hay que abrirla otra vez para que las notificaciones vuelvan a funcionar; no lo confundas con un error de tu servidor.
Tickets y recibos de entrega
Cuando tu servidor envía, Expo responde con un ticket por mensaje, en el mismo orden. El único error de ticket que lista la documentación es DeviceNotRegistered. Un ticket "ok" trae un id: con él pides el recibo después. La documentación de envío fija los números: hasta 100 mensajes por petición, 600 notificaciones por segundo por proyecto (si te pasas, TOO_MANY_REQUESTS), hasta 1,000 IDs por consulta de recibos, revisar los recibos unos 15 minutos después de enviar y que se borran a las 24 horas.
Este es el código del servidor con expo-server-sdk 8.0.0 (publicado el 22 de octubre de 2026; pide Node 22.12 o posterior y usa el fetch global):
// push.ts: send with expo-server-sdk, keep the tickets, check the receipts later.
import { Expo, type ExpoPushMessage } from "expo-server-sdk";
export type Pending = { id: string; token: string; sentAt: number };
export interface PushStore {
savePending(rows: Pending[]): Promise<void>;
pendingSentBefore(time: number): Promise<Pending[]>;
removePending(ids: string[]): Promise<void>;
disableToken(token: string): Promise<void>;
}
const WAIT = 15 * 60 * 1000; // Expo: check receipts about 15 minutes after sending
const KEEP = 24 * 60 * 60 * 1000; // Expo clears receipts after 24 hours
export async function sendPush(expo: Expo, store: PushStore, messages: (ExpoPushMessage & { to: string })[]) {
const retry: ExpoPushMessage[] = [];
const valid = messages.filter((m) => Expo.isExpoPushToken(m.to));
for (const chunk of expo.chunkPushNotifications(valid)) {
let tickets;
try {
tickets = await expo.sendPushNotificationsAsync(chunk);
} catch (e) {
const status = (e as { statusCode?: number }).statusCode;
if (status !== undefined && status !== 429 && status < 500) throw e; // a 400 will not fix itself
retry.push(...chunk); // 429, 5xx or network: try again later, with backoff
continue;
}
const pending: Pending[] = [];
for (const [i, ticket] of tickets.entries()) {
const token = chunk[i].to as string; // ticket i answers message i
if (ticket.status === "ok") pending.push({ id: ticket.id, token, sentAt: Date.now() });
else if (ticket.details?.error === "DeviceNotRegistered") await store.disableToken(token);
else console.error("push ticket", ticket.details?.error, ticket.message);
}
await store.savePending(pending);
}
return { skipped: messages.length - valid.length, retry };
}
export async function checkReceipts(expo: Expo, store: PushStore, now = Date.now()) {
const pending = await store.pendingSentBefore(now - WAIT);
const byId = new Map(pending.map((p) => [p.id, p]));
const done: string[] = [];
const count = { ok: 0, disabled: 0, errors: 0, waiting: 0, expired: 0 };
for (const ids of expo.chunkPushNotificationReceiptIds([...byId.keys()])) {
const receipts = await expo.getPushNotificationReceiptsAsync(ids);
for (const id of ids) {
const receipt = receipts[id];
const p = byId.get(id)!;
if (!receipt) {
if (now - p.sentAt > KEEP) { done.push(id); count.expired++; } else count.waiting++;
continue;
}
done.push(id);
if (receipt.status === "ok") { count.ok++; continue; }
if (receipt.details?.error === "DeviceNotRegistered") {
await store.disableToken(p.token);
count.disabled++;
} else {
console.error("push receipt", id, receipt.details?.error, receipt.message);
count.errors++;
}
}
}
await store.removePending(done);
return count;
}
PushStoreson las cuatro operaciones contra tu base: guardar tickets pendientes, leer los que ya tienen más de 15 minutos, borrarlos y desactivar un token. Con la tabla de arriba, cada una es una consulta.WAITyKEEPson los dos tiempos de la documentación: 15 minutos para preguntar y 24 horas antes de que el recibo desaparezca.sendPushdescarta los textos que no tienen forma de token conExpo.isExpoPushTokeny parte la lista conchunkPushNotifications, que arma grupos de 100.- Si la petición falla con 429, 5xx o un error de red, el grupo vuelve en
retrypara reintentarlo más tarde con espera creciente, como pide Expo. Un 400 se lanza: un payload mal formado no se arregla reintentando. El SDK ya reintenta solo los 429, dos veces. - Cada ticket corresponde al mensaje con el mismo índice. Los "ok" se guardan como pendientes; los
DeviceNotRegistereddesactivan el token en ese momento. checkReceiptslee los pendientes de más de 15 minutos y los pide en grupos conchunkPushNotificationReceiptIds. El SDK arma grupos de 300, por debajo del máximo de 1,000.- Si un ID no viene en la respuesta, el recibo todavía no está listo: se queda pendiente. Si ya pasaron 24 horas, Expo lo borró y no tiene caso seguir preguntando.
- Un recibo "ok" se borra de pendientes.
DeviceNotRegistereddesactiva el token. Cualquier otro error se registra, porque no es un problema del token sino de tu configuración o de tu ritmo de envío.
Probamos push.ts con node --test contra un servidor local que imita los dos endpoints, apuntando el SDK a él con la variable EXPO_BASE_URL (el SDK la documenta como uso interno de Expo; aquí solo sirvió para la prueba). Con 151 mensajes, uno con token inválido y uno de un dispositivo dado de baja, salieron dos peticiones de 100 y 50, el token muerto quedó desactivado y 149 tickets quedaron pendientes. Un 503 dejó el grupo en retry sin lanzar error. En los recibos: uno "ok", uno DeviceNotRegistered, uno InvalidCredentials, uno todavía sin recibo, uno de hace 25 horas que se descartó y uno de hace 2 minutos que ni se consultó. 350 IDs salieron en dos consultas, de 300 y 50.
Limpiar tokens que ya no sirven
DeviceNotRegistered es la señal de que ese dispositivo ya no puede recibir notificaciones, por ejemplo porque el usuario revocó el permiso o desinstaló la app. La documentación es directa: deja de enviar a ese token hasta que el dispositivo se vuelva a registrar en tu servidor. Si sigues enviando a tokens muertos, tus envíos se llenan de errores y cuesta ver los que sí importan. Con la tabla de arriba, disableToken es un UPDATE push_tokens SET disabled_at = now() WHERE token = $1, y tus consultas de envío filtran disabled_at IS NULL.
Los demás errores de recibo no se arreglan tocando tokens. InvalidCredentials quiere decir que las credenciales de push no sirven o se revocaron; en iOS la documentación pide regenerarlas con eas credentials. MessageTooBig aparece cuando el payload pasa de 4,096 bytes. MessageRateExceeded indica demasiados mensajes a un mismo dispositivo: espacia los envíos. MismatchSenderId es un desajuste entre el remitente de FCM y tu google-services.json.
Desliza la figura para verla completa
¿Dónde corre checkReceipts? En un trabajo programado cada pocos minutos, no en la misma petición que envía. Si ya tienes una cola de trabajos en Postgres, encaja como un trabajo más, y los grupos que devuelve sendPush en retry pueden volver a la cola con un run_at posterior. Por último, cuando un usuario cierra sesión, borra o desasocia su token en el servidor: si no, el siguiente que use ese teléfono recibirá las notificaciones del anterior.
Errores comunes
- Pedir permiso al abrir la app. El aviso del sistema sale una sola vez. Pídelo cuando la notificación tenga sentido para el usuario.
- Pedir permiso antes de crear el canal en Android. En Android 13+ el aviso no aparece sin un canal, y parece un rechazo.
- Probar en Expo Go. No tiene push en Android desde el SDK 53; usa un development build.
- Guardar el token una sola vez. Puede cambiar con la app abierta, el teléfono puede cambiar de cuenta y tu servidor pudo haberlo desactivado. Vuelve a guardarlo en cada arranque y en el listener.
- Tomar el ticket "ok" como entregado. Solo dice que Expo lo recibió. La entrega se ve en el recibo.
- No leer nunca los recibos. Ahí aparecen las credenciales vencidas y los tokens muertos. Si los lees a las 25 horas, ya no existen.
- Reintentar todo. Reintenta 429, 5xx y errores de red con espera creciente; un 400 no se arregla solo.
Preguntas frecuentes
¿Por qué las notificaciones push no llegan en Expo Go?
Porque en Android no están disponibles en Expo Go desde el SDK 53, y Expo pide un development build para usarlas. Crea uno con EAS, ábrelo en el teléfono y repite la prueba con el token que genere.
Si el recibo dice "ok", ¿el usuario vio la notificación?
No necesariamente. El recibo "ok" significa que FCM o APNs aceptaron el mensaje e intentarán entregarlo. El teléfono puede estar apagado o el usuario pudo silenciar la app. Si necesitas saber si se abrió, regístralo en la app cuando el usuario toca la notificación.
¿Cada cuánto cambia el token de Expo?
La referencia de expo-notifications solo dice que, en situaciones raras, el servicio lo cambia con la app abierta, y no documenta un intervalo. Por eso conviene guardarlo en cada arranque y escuchar addPushTokenListener.
¿Puedo volver a mostrar el aviso de permiso si el usuario dijo que no?
En iOS, no: después de la primera respuesta, Apple ya no muestra el aviso. En Android, canAskAgain te dice si todavía se puede. Cuando ya no se puede, explica para qué sirven las notificaciones y lleva al usuario a los ajustes del sistema.
Checklist
- El permiso se pide después de una acción del usuario, con tu propio mensaje antes del aviso del sistema.
- El canal de Android se crea antes de pedir permiso y token.
projectIdviene de la configuración de EAS.- El token se guarda en cada arranque con permiso y cuando
addPushTokenListeneravisa. - La tabla usa el token como llave y lo desasocia al cerrar sesión.
- Las pruebas se hacen en un development build, en un teléfono real, con la app abierta, en segundo plano y cerrada.
- El servidor envía en grupos de 100 y guarda el ID de cada ticket "ok".
- Un trabajo lee los recibos después de 15 minutos y antes de 24 horas.
DeviceNotRegistereddesactiva el token; los demás errores generan una alerta.- 429 y 5xx se reintentan con espera creciente; 400 no.
Si tu app usa Expo UI para su pantalla de ajustes, ese es buen lugar para el interruptor de notificaciones y para el enlace a los ajustes del sistema cuando el permiso quedó bloqueado.
¿Viste esto en Instagram? Todas las guías de los Reels están en ecomlabs.dev/guias.
Escrito por

Publicado el 19 de noviembre de 2026 · actualizado el 20 de noviembre de 2026