Skip to content

Expo push notifications not arriving? Tokens, tickets and receipts

From the work/ 16 min read

The four places Expo push notifications get lost, with tested code to save the token, read delivery receipts and remove dead tokens.

  • React
  • Node.js
In this article (9)
  1. Where Expo push notifications get lost
  2. Ask for permission at the right moment
  3. Save and refresh the push token
  4. Test on a real phone
  5. Push tickets and delivery receipts
  6. Remove push tokens that no longer work
  7. Common mistakes
  8. Frequently asked questions
  9. Checklist

If your Expo push notifications are not arriving, one of four points is failing: permission, token, sending or delivery. Ask for permission when the user understands why, save and refresh the token on your server, check delivery receipts about 15 minutes after sending, and disable tokens that come back with DeviceNotRegistered.

Below is the app code (permission and token), the Postgres table, and the server code that sends, stores the tickets and reads the receipts. The server code ran against a local copy of the Expo push API; nothing was sent to the real service.

Where Expo push notifications get lost

A notification makes four hops. The app gets an Expo push token with getExpoPushTokenAsync and sends it to your server. Your server sends the message to the Expo push service. Expo hands it to Firebase Cloud Messaging (FCM) on Android or Apple Push Notification service (APNs) on iOS. They carry it to the phone, which decides whether to show it based on the user's permissions and settings.

Each hop fails in its own way, and each one says "ok" with a different meaning. The Expo sending docs (updated November 16, 2026) are explicit: a ticket with status: "ok" only means Expo's servers received the message. A receipt with "ok" means FCM or APNs accepted it and will try to deliver it, but the device won't necessarily receive it. Neither one tells you the user saw the notification.

the journey of an Expo push notificationyour serverstores tokensExpo Pushgives ticketsFCM / APNsdeliverphonedisplays1 · tokenstale or neversaved2 · ticketrejected on sendDeviceNotRegistered3 · receiptcredentials,size, rate4 · permissionpermission denied,no Android channelticket ok: Expo's servers received the messagereceipt ok: FCM or APNs accepted it, not that it was showncheck receipts 15 min later; Expo clears them after 24 hfour points, four checkssource: docs.expo.dev, sending, tickets and receipts

Scroll the figure sideways to see all of it

PointSymptomWhere you see itWhat to check
1. PermissionNo token, or nothing is shownIn the app: getPermissionsAsyncWhen you ask, and the Android channel
2. TokenYou send to a stale token or another user'sIn your databaseIt is saved on every launch and when it changes
3. SendingThe request fails or the ticket has an errorIn the /push/send responseLimits, format and DeviceNotRegistered
4. DeliveryThe ticket is "ok" but nothing arrivesIn the receipts, 15 minutes laterCredentials, size and dead tokens

Ask for permission at the right moment

Permission is the first point of failure and the only one you can't retry at will. Apple's Asking permission to use notifications puts it plainly: the first time your app asks, the system prompts the person and records the response; subsequent requests don't prompt. Ask on first launch and the user has no idea why you want it, so "Don't Allow" is the easy answer.

Apple recommends asking in a context that explains why. Its example is a task app that asks after the person schedules a first task. In a store, the equivalent is the order confirmation screen: "Want a heads-up when your package ships?" Show your own message first and call requestPermissionsAsync only if the user says yes, so you don't spend the one system prompt on someone who never wanted notifications.

iOS has another option: provisional authorization. Notifications arrive quietly, only in Notification Center history, with buttons to keep or turn them off, and no permission prompt is shown. In Expo you request it with requestPermissionsAsync({ ios: { allowProvisional: true } }). Note that granted can then be false; the expo-notifications reference checks ios.status === IosAuthorizationStatus.PROVISIONAL to decide whether you can send.

On Android 13 and later the user also has to accept a prompt, and the same reference says that prompt won't appear until at least one notification channel exists. The channel must also exist before you ask for the token. If your app asks for permission before creating the channel, the prompt never shows and it looks like the user said no.

Save and refresh the push token

This app file does three things: creates the channel, asks only if asking is still possible, and saves the token. It also listens for the system changing the token while the app is open. It type-checks with tsc --strict against expo-notifications 58.1.9 and expo-constants from 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 comes from your EAS config. The Expo setup guide uses it to tie the token to your project; with no project ID at all, getExpoPushTokenAsync rejects.
  2. setNotificationHandler decides what happens when a notification arrives with the app open. The four fields (shouldShowBanner, shouldShowList, shouldPlaySound, shouldSetBadge) are the ones from the guide. With no handler, the reference says the notification is shown with a banner; with one, you choose: banner and list yes, sound and badge no.
  3. setNotificationChannelAsync runs first because of the Android 13 rule. On iOS it does nothing and resolves to null, so there is no platform check.
  4. getPermissionsAsync reads the status without showing anything. requestPermissionsAsync runs only when there is no permission and canAskAgain is true.
  5. The function returns "blocked" when asking is no longer possible. The only way forward then is sending the user to system settings; calling again does nothing.
  6. getExpoPushTokenAsync returns an object; the token, shaped like ExponentPushToken[...], is in data. saveToken is your API call, made with the user's session.
  7. keepTokenFresh uses addPushTokenListener. The reference says that in rare cases the push service changes the token while the app is running, and the old one stops working. The listener receives the new device token, and we pass it to getExpoPushTokenAsync as devicePushToken: fetching it again inside the listener would fire the listener again.

Call keepTokenFresh once after sign-in and keep the subscription so you can remove it on sign-out. Also, on every launch, if getPermissionsAsync already reports permission, send the token again: it shows nothing and covers reinstalls and account switches on the same phone.

On the server, the token is the key, not the user: one user can have several phones, and one phone can switch accounts. Here is the table, tested with 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 is the primary key: a token is a device, so when the same phone signs in to another account the row changes owner instead of being duplicated.
  2. disabled_at marks tokens that no longer work. They are not deleted right away because push_pending references them.
  3. push_pending stores the ID of every "ok" ticket with its token and send time, so the receipt can be read later.
  4. The INSERT ... ON CONFLICT is what saveToken runs on the server: it updates the user and the date, and clears disabled_at when the device registers again.
the life of a push notifications tokenpermissionin contexttokenprojectIdserveruser + tokensendsticketsreceipts15 min laterif the token rotatesaddPushTokenListenerfetch it again, save itif the receipt saysDeviceNotRegistereddisable it, stop sendingone token per device; one user can have severalAndroid 13+: create the channel before permission and tokensave it, refresh it, retire itsource: expo-notifications reference, SDK 58

Scroll the figure sideways to see all of it

Test on a real phone

First, Expo Go won't do. The expo-notifications reference says push notifications are unavailable in Expo Go on Android from SDK 53, and the page about notification types says you must use a development build because the capability is not built into Expo Go. If you already made a development build to migrate to the React Native New Architecture, use that one.

The setup guide accepts a physical device, an Android Emulator with Google Play services, or an iOS Simulator on Xcode 14 or later (macOS 13+, iOS 16+). The emulator is fine for quick iteration, but test on a real phone before you ship: that is where the permission prompt, the channel you created, the real credentials (FCM V1 on Android, the APNs key on iOS) and the user's own settings all meet.

With the development build open and the token on screen or in your logs, there are two ways to send a test: Expo's tool at expo.dev/notifications, where you paste the token, or a direct request to the API:

curl -H "Content-Type: application/json" -X POST "https://exp.host/--/api/v2/push/send" \
  -d '{"to": "ExponentPushToken[xxxxxxxxxxxxxxxxxxxxxx]", "title": "Test", "body": "Hello from the server"}'
  1. The request is a JSON POST to the send endpoint; the Content-Type: application/json header is required.
  2. to is the token your app printed; title and body are the visible text.
  3. The response has data with one ticket: a status and, when it is "ok", an id to fetch the receipt.

Test three states: app open (your setNotificationHandler decides), app in the background, and app closed. On Android, if the user force-stopped the app, Expo notes it must be opened again before notifications work; don't mistake that for a server bug.

Push tickets and delivery receipts

When your server sends, Expo answers with one ticket per message, in the same order. The only ticket error the docs list is DeviceNotRegistered. An "ok" ticket carries an id you later use to fetch the receipt. The sending docs set the numbers: up to 100 messages per request, 600 notifications per second per project (above that, TOO_MANY_REQUESTS), up to 1,000 IDs per receipts request, check receipts about 15 minutes after sending, and receipts are cleared after 24 hours.

This is the server code with expo-server-sdk 8.0.0 (released October 22, 2026; it needs Node 22.12 or later and uses the global fetch):

// 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 is the four operations against your database: save pending tickets, read the ones older than 15 minutes, delete them and disable a token. With the table above, each one is a single query.
  2. WAIT and KEEP are the two times from the docs: 15 minutes before asking and 24 hours before the receipt is gone.
  3. sendPush drops strings that are not shaped like a token with Expo.isExpoPushToken and splits the list with chunkPushNotifications, which builds groups of 100.
  4. If the request fails with a 429, a 5xx or a network error, the group comes back in retry so you can try again later with growing waits, as Expo asks. A 400 is thrown: a malformed payload won't fix itself. The SDK already retries 429s on its own, twice.
  5. Each ticket answers the message at the same index. "ok" tickets are saved as pending; DeviceNotRegistered disables the token right away.
  6. checkReceipts reads the pending tickets older than 15 minutes and asks for them in groups with chunkPushNotificationReceiptIds. The SDK uses groups of 300, under the 1,000 maximum.
  7. If an ID is missing from the response, the receipt isn't ready yet, so it stays pending. If 24 hours have passed, Expo has cleared it and there is no point asking again.
  8. An "ok" receipt is removed from pending. DeviceNotRegistered disables the token. Any other error is logged, because it is not a token problem but a problem with your setup or your sending rate.

We tested push.ts with node --test against a local server that mimics both endpoints, pointing the SDK at it through the EXPO_BASE_URL variable (the SDK documents it as internal to Expo; here it only served the test). With 151 messages, one with an invalid token and one from an unregistered device, two requests went out with 100 and 50 messages, the dead token was disabled, and 149 tickets were left pending. A 503 put the group in retry without throwing. In the receipts: one "ok", one DeviceNotRegistered, one InvalidCredentials, one with no receipt yet, one from 25 hours ago that was dropped, and one from 2 minutes ago that was not requested at all. 350 IDs went out in two requests of 300 and 50.

Remove push tokens that no longer work

DeviceNotRegistered means that device can no longer receive notifications, for example because the user revoked permission or uninstalled the app. The docs are direct: stop sending to that token until the device registers with your server again. Keep sending to dead tokens and your logs fill with errors that hide the ones that matter. With the table above, disableToken is an UPDATE push_tokens SET disabled_at = now() WHERE token = $1, and your send queries filter on disabled_at IS NULL.

The other receipt errors are not fixed by touching tokens. InvalidCredentials means your push credentials are invalid or were revoked; for iOS, the docs say to regenerate them with eas credentials. MessageTooBig shows up when the payload goes over 4,096 bytes. MessageRateExceeded means too many messages to one device: space them out. MismatchSenderId is a mismatch between your FCM sender and your google-services.json.

Expo push notifications errors and what to docodewherewhat to doDeviceNotRegisteredticket, receiptdisable the tokenInvalidCredentialsreceiptcheck FCM V1 or the APNs keyMessageTooBigreceiptpayload over 4096 bytesMessageRateExceededreceipttoo many to one device: slow downMismatchSenderIdreceiptFCM sender does not matchTOO_MANY_REQUESTSrequestover 600/s: retry lateran ok ticket and an ok receipt do not prove the phone showed itread details.error, not just statussource: docs.expo.dev, error codes (Nov 16, 2026)

Scroll the figure sideways to see all of it

Where does checkReceipts run? In a scheduled job every few minutes, not in the request that sends. If you already have a Postgres job queue, it fits as one more job, and the groups sendPush returns in retry can go back to the queue with a later run_at. Finally, when a user signs out, delete or detach their token on the server; otherwise the next person on that phone gets the previous user's notifications.

Common mistakes

  • Asking for permission on launch. The system prompt shows once. Ask when a notification makes sense to the user.
  • Asking before creating the Android channel. On Android 13+ the prompt doesn't appear without a channel, and it looks like a denial.
  • Testing in Expo Go. It has no push on Android since SDK 53; use a development build.
  • Saving the token only once. It can change while the app is open, the phone can switch accounts, and your server may have disabled it. Save it on every launch and in the listener.
  • Treating an "ok" ticket as delivered. It only says Expo got the message. Delivery shows up in the receipt.
  • Never reading receipts. That is where expired credentials and dead tokens appear. Read them after 25 hours and they are gone.
  • Retrying everything. Retry 429s, 5xx and network errors with growing waits; a 400 won't fix itself.

Frequently asked questions

Why are push notifications not working in Expo Go?

Because on Android they are unavailable in Expo Go from SDK 53, and Expo requires a development build to use them. Create one with EAS, open it on the phone and repeat the test with the token it generates.

If the receipt says "ok", did the user see the notification?

Not necessarily. An "ok" receipt means FCM or APNs accepted the message and will try to deliver it. The phone may be off, or the user may have muted the app. If you need to know whether it was opened, record that in the app when the user taps the notification.

How often does the Expo push token change?

The expo-notifications reference only says that, in rare situations, the push service changes it while the app is running, and it documents no interval. That is why you save it on every launch and listen with addPushTokenListener.

Can I show the permission prompt again after the user says no?

On iOS, no: after the first answer, the system doesn't prompt again. On Android, canAskAgain tells you whether you still can. When you can't, explain what the notifications are for and send the user to system settings.

Checklist

  • Permission is requested after a user action, with your own message before the system prompt.
  • The Android channel is created before asking for permission and the token.
  • projectId comes from your EAS config.
  • The token is saved on every launch with permission and whenever addPushTokenListener fires.
  • The table uses the token as its key and detaches it on sign-out.
  • Tests run on a development build, on a real phone, with the app open, in the background and closed.
  • The server sends in groups of 100 and stores the ID of every "ok" ticket.
  • A job reads receipts after 15 minutes and before 24 hours.
  • DeviceNotRegistered disables the token; every other error raises an alert.
  • 429s and 5xx are retried with growing waits; 400s are not.

If your app uses Expo UI for its settings screen, that is a good place for the notifications toggle and for the link to system settings when permission is blocked.

Saw this on Instagram? Every Reel guide is at ecomlabs.dev/guides.

Written by

Luis Morales

Luis Morales

Frontend and Shopify developer, EcomLabs

@luismoralesdev on Instagram

Published November 19, 2026 · updated November 20, 2026

← Blog