November 11, 2026 · 9 min read
Expo Push Notifications: Setup, Sending and Receipts
Add push notifications to an Expo React Native app: permissions, push tokens, Android channels, sending from Node.js in batches, receipts and tapped links.
Hasnain IrfanSenior Software Engineer · Remote for US, UK & UAE teams

To add push notifications to an Expo app, install expo-notifications and expo-constants, ask the user for permission, get an Expo push token with your project ID, and save that token on your server. Your server then sends messages to Expo's push service, which forwards them to Apple (APNs) and Google (FCM). Push needs a development build: Expo's docs say Expo Go has no push support from SDK 53 on. Check push receipts about 15 minutes after sending and delete tokens that come back as DeviceNotRegistered.
Key takeaways
- Use a development build, not Expo Go. Expo Go dropped push notifications in SDK 53.
- Credentials: Android needs Firebase Cloud Messaging (FCM V1) credentials; iOS needs a paid Apple Developer account.
- Batch on the server: up to 100 messages per request and at most 600 notifications per second per project. Expo's Node SDK (
expo-server-sdk) handles batching, throttling and gzip for you. - A ticket isn't a delivery. A push ticket means Expo accepted the message. Check the push receipt to see whether Apple or Google accepted it.
- Clean up dead tokens. When a ticket or receipt says
DeviceNotRegistered, stop sending to that token. - Keep payloads small: the whole notification must be at most 4096 bytes.
How do Expo push notifications work?
Expo push notifications go from your server to Expo's push service, then to Apple or Google, then to the phone:
- The app asks for permission and gets an Expo push token (it looks like
ExponentPushToken[...]). - The app sends the token to your server, which stores it against the user.
- Your server posts messages to Expo's push API, and Expo returns a push ticket for each one.
- Expo hands each message to APNs (iPhone) or FCM (Android) and records a push receipt.
- Your server reads the receipts later and removes tokens that no longer work.
Expo doesn't lock you in: the expo-notifications library works with any push service, and Expo documents how to send through FCM and APNs directly if you need finer control.
What do you need before you start?
You need:
- An Expo project with a development build. Push isn't available in Expo Go from SDK 53, so build the app with
eas build(or build it locally). - A test device. A physical phone works, as does an Android emulator with Google Play services or an iOS Simulator on Xcode 14 or later (macOS 13+, iOS 16+).
- Android credentials: a Firebase project and FCM V1 credentials uploaded to your Expo project.
- iOS credentials: a paid Apple Developer Program membership (99 USD a year). On your first development build, the EAS CLI offers to set up push and generate an Apple Push Notifications key. Answer yes to both.
Install the two libraries and add the config plugin:
npx expo install expo-notifications expo-constants
{
"expo": {
"plugins": ["expo-notifications"]
}
}
How do you get a push token in the app?
Ask for permission, create an Android notification channel, then request the token with your project ID. This is based on the example in Expo's setup guide, trimmed to the parts you'll keep:
// lib/push.ts
import { Platform } from 'react-native';
import * as Notifications from 'expo-notifications';
import Constants from 'expo-constants';
// Show notifications as banners even while the app is open.
Notifications.setNotificationHandler({
handleNotification: async () => ({
shouldPlaySound: true,
shouldSetBadge: false,
shouldShowBanner: true,
shouldShowList: true,
}),
});
export async function registerForPush(): Promise<string | null> {
if (Platform.OS === 'android') {
// Android 8+ needs a channel before it shows anything.
await Notifications.setNotificationChannelAsync('default', {
name: 'default',
importance: Notifications.AndroidImportance.MAX,
});
}
const current = await Notifications.getPermissionsAsync();
let status = current.status;
if (status !== 'granted') {
status = (await Notifications.requestPermissionsAsync()).status;
}
if (status !== 'granted') return null; // the user said no: respect it
const projectId =
Constants?.expoConfig?.extra?.eas?.projectId ?? Constants?.easConfig?.projectId;
if (!projectId) throw new Error('No projectId in app config');
const { data: token } = await Notifications.getExpoPushTokenAsync({ projectId });
return token; // looks like ExponentPushToken[xxxxxxxx]
}
Expo recommends passing projectId yourself. A token tied to your project ID stays the same if the project moves to another Expo account or the account is renamed.
When to ask: don't request permission on the first screen. Ask when the user does something that makes notifications useful, such as placing an order or following a thread, and explain what they'll get. On iPhone, the system permission prompt appears only once, so the first ask matters.
How do you save the token on your server?
Send the token to your API after sign-in, so you know which user it belongs to:
// lib/save-push-token.ts
import { registerForPush } from './push';
export async function savePushToken(apiUrl: string, sessionToken: string) {
const token = await registerForPush();
if (!token) return;
await fetch(`${apiUrl}/push-tokens`, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
Authorization: `Bearer ${sessionToken}`,
},
body: JSON.stringify({ token }),
});
}
On the server, store tokens in their own table (user ID, token, platform, created and last-seen dates) with the token as a unique key. One user can have several phones, and a token can change, so upsert on every app start rather than inserting once.
How do you send push notifications from Node.js?
Use Expo's Node SDK, expo-server-sdk. It splits messages into chunks of up to 100, throttles requests, gzips them and retries with backoff, which keeps you under Expo's limit of 600 notifications per second per project:
// server/push.ts
import { Expo, type ExpoPushMessage, type ExpoPushTicket } from 'expo-server-sdk';
const expo = new Expo({ accessToken: process.env.EXPO_ACCESS_TOKEN });
type Sent = { ticketId: string; token: string };
export async function sendToUsers(tokens: string[], title: string, body: string, url?: string) {
const messages: ExpoPushMessage[] = tokens
.filter((t) => Expo.isExpoPushToken(t))
.map((to) => ({ to, title, body, sound: 'default', data: url ? { url } : {} }));
const sent: Sent[] = [];
const dead: string[] = [];
// Chunks of up to 100 messages; the SDK throttles and gzips for you.
for (const chunk of expo.chunkPushNotifications(messages)) {
const tickets: ExpoPushTicket[] = await expo.sendPushNotificationsAsync(chunk);
tickets.forEach((ticket, i) => {
const token = chunk[i].to as string;
if (ticket.status === 'ok') sent.push({ ticketId: ticket.id, token });
else if (ticket.details?.error === 'DeviceNotRegistered') dead.push(token);
});
}
return { sent, dead }; // save `sent`; check receipts in ~15 minutes
}
Tickets come back in the same order as the messages, which is why the code can match tickets[i] to chunk[i].
Turn on push security. By default, anyone who has a user's push token can send that user a notification. In the Expo dashboard you can require an access token on every push request; after that, requests without it fail with UNAUTHORIZED. Keep EXPO_ACCESS_TOKEN in your server's environment variables, never in the app.
Keep messages under 4096 bytes. That limit covers the title, body and data together. Put an ID or a URL in data, not the whole record, and let the app fetch the details.
Why do you need to check push receipts?
A push ticket with status: "ok" only means Expo received your message. The push receipt tells you whether Apple or Google accepted it, and it's where most real errors show up: bad credentials, oversized messages and uninstalled apps. Expo recommends checking receipts about 15 minutes after sending, and it clears them after 24 hours:
// server/push.ts (continued)
export async function checkReceipts(sent: Sent[]) {
const byId = new Map(sent.map((s) => [s.ticketId, s.token]));
const dead: string[] = [];
for (const ids of expo.chunkPushNotificationReceiptIds([...byId.keys()])) {
const receipts = await expo.getPushNotificationReceiptsAsync(ids);
for (const [id, receipt] of Object.entries(receipts)) {
if (receipt.status === 'error') {
console.error('push failed', receipt.message, receipt.details?.error);
if (receipt.details?.error === 'DeviceNotRegistered') dead.push(byId.get(id)!);
}
}
}
return dead; // delete these tokens from your database
}
Run it from a queue job or a scheduled function, not inside the request that sent the notifications. Even an ok receipt doesn't guarantee the phone showed the message. A phone that's switched off, for example, may never receive it.
| Error | Where it appears | What to do |
|---|---|---|
DeviceNotRegistered | Ticket or receipt | Stop sending to that token and delete it |
MessageTooBig | Receipt | Keep the whole notification at 4096 bytes or less |
TOO_MANY_REQUESTS | Whole request | Throttle to 600 per second per project (the Node SDK does this) |
PUSH_TOO_MANY_RECEIPTS | Whole request | Ask for at most 1,000 receipt IDs per request |
UNAUTHORIZED | Whole request | Send your access token, or turn push security off |
How do you open the right screen when a notification is tapped?
Put a link in the notification's data and open it when the user taps. The useLastNotificationResponse hook also catches the tap that launched the app from closed, which a plain listener added later can miss:
// hooks/use-notification-links.ts
import { useEffect } from 'react';
import { Linking } from 'react-native';
import * as Notifications from 'expo-notifications';
// Opens data.url when the user taps a notification, including the tap
// that launched the app from closed.
export function useNotificationLinks() {
const response = Notifications.useLastNotificationResponse();
useEffect(() => {
if (!response) return;
if (response.actionIdentifier !== Notifications.DEFAULT_ACTION_IDENTIFIER) return;
const url = response.notification.request.content.data?.url;
if (typeof url === 'string') Linking.openURL(url);
}, [response]);
}
Call the hook once in your root layout. Use your app's own deep-link scheme in data.url (for example myapp://orders/123) so the link opens a screen inside the app. Older tutorials use getLastNotificationResponseAsync; the current typings mark it as deprecated in favour of getLastNotificationResponse.
How do you test push notifications?
- Start the dev server with
npx expo startand open your development build on the phone. - Copy the push token the app logs.
- Paste it into Expo's push notifications tool, add a title and body, and send.
- Test three states: app open, app in the background, and app closed (tap the notification to launch it).
- Test on both an iPhone and an Android phone before release. Android channels and iOS permission prompts behave differently.
If nothing arrives, check the credentials first: the Expo docs' FAQ lists missing or wrong credentials as a common cause.
Common mistakes
- Testing in Expo Go. It has no push support from SDK 53. Use a development build.
- Asking for permission too early. Ask when the notification is clearly useful to the user.
- Never reading receipts. You won't see credential problems or dead tokens, and Apple and Google may block apps that keep sending to devices that opted out.
- Putting whole records in the payload. Send an ID or a link and fetch the rest in the app.
- Leaving push security off. Anyone with a leaked token could message your users.
- Shipping without your own credentials. If push works in development but not in the store build, the production app is missing its FCM V1 credentials (Android) or its push key (iOS). Run
eas credentialsto check. - Leaving Android priority unset. If notifications sometimes don't show on Android, send them with
priority: 'high'. Expo's FAQ says this gives Android the best chance of displaying them.
Need push notifications built for your app?
I'm a senior software engineer with 5+ years of experience, based in Karachi and working remotely with startups and agencies in the US, UK, Canada, Australia and the UAE. I build iOS and Android apps with React Native and Expo, including push notifications and deep links, plus the Next.js and Node.js backends that send them. If you're choosing a developer, my guide on how to hire a React Native developer covers rates and what to test.
Send me a short brief and I'll reply within 24 hours with a plan, a timeline and a price.
Summary
Expo push notifications need a development build, expo-notifications and expo-constants, FCM V1 credentials for Android and a paid Apple Developer account for iOS. The app asks permission, gets an Expo push token with your project ID and saves it on your server. The server sends through expo-server-sdk in chunks of up to 100, checks receipts about 15 minutes later and deletes tokens marked DeviceNotRegistered. Keep each notification under 4096 bytes, turn on push security, and open a deep link from data.url when the user taps.
Questions
Do push notifications work in Expo Go?
No, not from SDK 53 on. Expo's docs say push isn't built into Expo Go, so test with a development build.
How big can a push notification be?
The whole notification, including the title, body and `data`, must be at most 4096 bytes, or the receipt shows `MessageTooBig`. Send an ID or a link and load the rest in the app.
What is the difference between a push ticket and a push receipt?
A push ticket is Expo's reply when you send: it means Expo received the message. A push receipt comes later and says whether Apple or Google accepted it. Check receipts about 15 minutes after sending; Expo clears them after 24 hours.
What does DeviceNotRegistered mean?
The device can't receive push notifications from your app anymore, usually because the user turned notifications off or uninstalled the app. Stop sending to that token and delete it.
Is the Expo push notification service free?
Yes. Expo's FAQ says there is no cost for sending through its push service. The limit is 600 notifications per second per project; above that, requests fail until the rate drops, so throttle and retry on your server (`expo-server-sdk` does both).
Can I send push notifications without Expo's push service?
Yes. `expo-notifications` works with any push service, and Expo documents how to send directly through FCM and APNs when you need more control.
Keep reading