Saltar al contenido

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)
  1. Dónde se pierden las notificaciones push con Expo
  2. Pedir permiso en el momento correcto
  3. Guardar y actualizar el token
  4. Probar en un teléfono real
  5. Tickets y recibos de entrega
  6. Limpiar tokens que ya no sirven
  7. Errores comunes
  8. Preguntas frecuentes
  9. Checklist

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.

el viaje de una notificación push con Expotu servidorguarda tokensExpo Pushda ticketsFCM / APNsentreganteléfonomuestra1 · tokenviejo o nuncaguardado2 · ticketrechazo al enviarDeviceNotRegistered3 · recibocredenciales,tamaño, ritmo4 · permisopermiso negado,sin canal Androidticket ok: los servidores de Expo recibieron el mensajerecibo ok: FCM o APNs lo aceptaron, no que se mostrararevisa los recibos 15 min después; Expo los borra a las 24 hcuatro puntos, cuatro revisionesfuente: docs.expo.dev, envío, tickets y recibos

Desliza la figura para verla completa

PuntoSíntomaDónde lo vesQué revisar
1. PermisoNo hay token o no se muestra nadaEn la app: getPermissionsAsyncCuándo pides el permiso y el canal de Android
2. TokenEnvías a un token viejo o de otro usuarioEn tu base de datosQue se guarde en cada inicio y cuando cambia
3. EnvíoLa petición falla o el ticket trae errorEn la respuesta de /push/sendLímites, formato y DeviceNotRegistered
4. EntregaEl ticket es "ok" pero no llegaEn los recibos, 15 minutos despuésCredenciales, 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);
  });
}
  1. projectId sale 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, getExpoPushTokenAsync falla.
  2. setNotificationHandler decide 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.
  3. setNotificationChannelAsync va primero, por la regla de Android 13. En iOS no hace nada y devuelve null, así que no hace falta preguntar por la plataforma.
  4. getPermissionsAsync lee el estado sin mostrar nada. Solo si no hay permiso y canAskAgain es verdadero se llama a requestPermissionsAsync.
  5. 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.
  6. getExpoPushTokenAsync devuelve un objeto; el token, con la forma ExponentPushToken[...], está en data. saveToken es tu llamada al servidor, con la sesión del usuario.
  7. keepTokenFresh usa addPushTokenListener. 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 a getExpoPushTokenAsync como devicePushToken: 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;
  1. token es 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.
  2. disabled_at marca los tokens que ya no sirven. No se borran de inmediato porque push_pending los referencia.
  3. push_pending guarda el ID de cada ticket "ok" con su token y la hora de envío, para leer el recibo después.
  4. El INSERT ... ON CONFLICT es lo que ejecuta saveToken: actualiza el usuario y la fecha, y quita disabled_at si el dispositivo vuelve a registrarse.
el ciclo del token de notificaciones pushpermisoen contextotokenprojectIdservidorusuario + tokenenvíosticketsrecibos15 min despuéssi el token rotaaddPushTokenListenerpide el token y guárdalosi el recibo diceDeviceNotRegistereddesactiva y deja de enviarun token por dispositivo; un usuario puede tener variosAndroid 13+: crea el canal antes del permiso y del tokense guarda, se renueva y se retirafuente: referencia de expo-notifications, SDK 58

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"}'
  1. La petición es un POST con JSON al endpoint de envío; el encabezado Content-Type: application/json es obligatorio.
  2. to es el token que imprimió tu app; title y body son el texto visible.
  3. La respuesta trae data con un ticket: status y, si es "ok", un id para 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;
}
  1. PushStore son 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.
  2. WAIT y KEEP son los dos tiempos de la documentación: 15 minutos para preguntar y 24 horas antes de que el recibo desaparezca.
  3. sendPush descarta los textos que no tienen forma de token con Expo.isExpoPushToken y parte la lista con chunkPushNotifications, que arma grupos de 100.
  4. Si la petición falla con 429, 5xx o un error de red, el grupo vuelve en retry para 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.
  5. Cada ticket corresponde al mensaje con el mismo índice. Los "ok" se guardan como pendientes; los DeviceNotRegistered desactivan el token en ese momento.
  6. checkReceipts lee los pendientes de más de 15 minutos y los pide en grupos con chunkPushNotificationReceiptIds. El SDK arma grupos de 300, por debajo del máximo de 1,000.
  7. 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.
  8. Un recibo "ok" se borra de pendientes. DeviceNotRegistered desactiva 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.

errores de notificaciones push en Expo y qué hacercódigodóndequé hacerDeviceNotRegisteredticket, recibodesactiva el tokenInvalidCredentialsreciborevisa FCM V1 o la llave de APNsMessageTooBigrecibopayload de más de 4096 bytesMessageRateExceededrecibomuchos a un equipo: espaciaMismatchSenderIdreciboel remitente de FCM no coincideTOO_MANY_REQUESTSpeticiónmás de 600/s: reintenta despuésticket ok y recibo ok no prueban que el teléfono la mostraralee details.error, no solo statusfuente: docs.expo.dev, códigos de error (16 nov 2026)

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.
  • projectId viene de la configuración de EAS.
  • El token se guarda en cada arranque con permiso y cuando addPushTokenListener avisa.
  • 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.
  • DeviceNotRegistered desactiva 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

Luis Morales

Luis Morales

Desarrollador frontend y Shopify, EcomLabs

@luismoralesdev en Instagram

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

← Blog