# Expo Push Notifications: A 2026 Setup Guide

> Set up Expo push notifications in 2026: permissions, Expo push tokens, FCM and APNs, the push API, receipts, and when to use FCM or OneSignal.

Published: 2026-11-20 · Tags: mobile, development, guide

**Expo push notifications** are remote alerts that your server sends to an iOS or Android app through Expo's push service. The phone still gets them from Apple Push Notification service (APNs) or Firebase Cloud Messaging (FCM). Expo sits in the middle so your backend can speak one HTTP API instead of two.

That is the usual path, not the only one. You can also talk to FCM and APNs yourself, or hand the send path to a product such as OneSignal. The client library stays `expo-notifications` in the first two cases. This guide is the setup that matches Expo's docs on **20 November 2026**, plus the decision of when to leave their service.

If you are new to Expo itself, start with the [Expo React Native guide](https://www.turbostarter.dev/blog/native-mobile-apps-for-web-developers-complete-expo-react-native-guide). The binary you will install comes from [EAS Build and EAS Submit](https://www.turbostarter.dev/blog/eas-build-eas-submit-guide).

<Callout type="success" title="Short answer">
  Install `expo-notifications` and `expo-constants` with `npx expo install`. Ask for permission only after you have created an Android notification channel. Read an Expo push token with `getExpoPushTokenAsync({ projectId })` from a **development build** on a real device, an Android emulator with Google Play services, or an iOS Simulator on Xcode 14 or later (macOS 13+, iOS 16+). Remote push does not run in Expo Go on Android from SDK 53. Upload an FCM V1 service account to EAS for Android, and let EAS create an APNs key for iOS. Save the token on your server, then POST it to `https://exp.host/--/api/v2/push/send` (the `expo-server-sdk` package on Node). A ticket means Expo accepted the message. Check the receipt about 15 minutes later and delete tokens that come back `DeviceNotRegistered`. Sending through this service has no fee. The limit is 600 notifications per second per project, and there is no SLA.
</Callout>

**Definition:** an Expo push token (`ExponentPushToken[...]`) identifies one app install to Expo's push service. A native device token identifies that install to FCM or APNs. `getExpoPushTokenAsync` returns the first. `getDevicePushTokenAsync` returns the second.

## Expo push notifications, and the three ways to send them

Search results for "expo notifications", "expo-notifications", and "react native push notifications" mix three different jobs. Pick the sender before you write the client. The permission prompt, the Android channel, and the tap handler stay the same.

|                              | Expo Push Service                                                                                  | FCM and APNs, direct                                             | OneSignal                                                                                                        |
| ---------------------------- | -------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------- |
| Who your server calls        | `https://exp.host/--/api/v2/push/send`                                                             | FCM HTTP v1 and APNs HTTP/2                                      | OneSignal's API                                                                                                  |
| Token on the device          | Expo push token from `getExpoPushTokenAsync`                                                       | Native token from `getDevicePushTokenAsync`                      | OneSignal's own subscription, after their SDK initializes                                                        |
| Credentials you still create | FCM V1 key uploaded to EAS. APNs key via EAS.                                                      | Those same keys, stored where your server can sign requests      | Firebase credentials and an APNs p8 (or p12) saved in the OneSignal dashboard                                    |
| Remote push in Expo Go       | Not on Android from SDK 53. Use a development build.                                               | Same. Expo Go is the wrong app.                                  | Their Expo guide says push does not work in Expo Go. Development build required.                                 |
| What you gain                | One payload for iOS and Android, tickets, and receipts.                                            | Every field FCM and APNs expose. You own retries and auth.       | A dashboard, segments, and in-app messages on top of the same FCM and APNs pipes.                                |
| What you give up             | Some native fields. No published SLA. Tokens are enough to send, unless you turn on push security. | Two integrations, two failure modes, and your own receipt store. | Another vendor on the send path. Their current Expo SDK wants Expo SDK 53+, the New Architecture, and EAS Build. |
| Send price                   | No cost to send, per Expo's FAQ on 20 November 2026.                                               | Not quoted here. Confirm on Google and Apple.                    | A free account exists. Plan prices are not quoted here.                                                          |

Sources: [push setup](https://docs.expo.dev/push-notifications/push-notifications-setup/), [sending](https://docs.expo.dev/push-notifications/sending-notifications/), [FAQ](https://docs.expo.dev/push-notifications/faq/), [FCM and APNs direct](https://docs.expo.dev/push-notifications/sending-notifications-custom/), [OneSignal Expo SDK setup](https://documentation.onesignal.com/docs/en/react-native-expo-sdk-setup) (read the same day).

Use the Expo push service for a product you are shipping yourself, including a React Native app that already uses Expo modules. Move to direct FCM and APNs when you need a field the Expo payload does not map, or when the send pipeline already exists. Add OneSignal when a non-engineer has to write, segment, and schedule messages and you accept their SDK in the binary.

React Native Firebase Messaging is the other name people use for the direct-FCM path: a Firebase client in the app and FCM on the server. This page does not document that package. Expo's equivalent is `getDevicePushTokenAsync` plus your own calls to Google and Apple.

## A development build, not Expo Go

The `expo-notifications` reference (SDK docs labeled v58.0.0, recommended library `~58.1.9` on 20 November 2026) says remote push is **unavailable in Expo Go on Android from SDK 53**. Local notifications still run in Expo Go. The push FAQ is broader: from SDK 53 on, Expo Go does not support push notifications, and on SDK 52 and earlier Expo Go used Expo's own credentials so you could skip setting up yours. Treat Expo Go as the wrong app for a remote test. Install a [development build](https://docs.expo.dev/develop/development-builds/introduction/).

You can test on:

* a physical Android or iOS device
* an Android emulator with Google Play services
* an iOS Simulator on Xcode 14 or later, macOS 13 or later, and iOS 16 or later

Older tutorials install `expo-device` and return early when `Device.isDevice` is false. The current setup guide does not install `expo-device`. A simulator check that always bails out will hide a token the current docs say you can get. Skip that package unless you have your own reason to detect hardware.

A development build is your app plus `expo-dev-client`. Create one with `eas build --profile development`, or locally with `npx expo run:android` / `npx expo run:ios`. Plugin changes (the notification icon, the Android channel name, the iOS entitlement) do not apply over an OTA update. They need a new native binary. The [EAS guide](https://www.turbostarter.dev/blog/eas-build-eas-submit-guide) covers profiles, credentials, and submit.

iOS push credentials need a paid Apple Developer account. That fee is Apple's, not a charge for the Expo push service.

## Install expo-notifications and ask for permission

From the app directory:

```bash
npx expo install expo-notifications expo-constants
```

`npx expo install` picks the version that matches your SDK. Do not pin a version from this post. `expo-notifications` requests permission, reads tokens, schedules local notifications, and listens for taps. `expo-constants` reads the EAS `projectId`.

Add the config plugin. These values are baked in at build time. The Android icon must be a 96×96 all-white PNG with transparency, or Android draws a white square.

```json
{
  "expo": {
    "plugins": [
      [
        "expo-notifications",
        {
          "icon": "./assets/notification-icon.png",
          "color": "#ffffff",
          "defaultChannel": "default",
          "enableBackgroundRemoteNotifications": false
        }
      ]
    ]
  }
}
```

`enableRemoteNotifications` defaults to `true` and adds the iOS APNs entitlement (`development` on debug builds, `production` on the release archive). Set it to `false` only if the app is local-only. `enableBackgroundRemoteNotifications` adds `remote-notification` to `UIBackgroundModes`. Leave it off until you run a background task.

### Android 13 and notification channels

The library's Android manifest declares `android.permission.POST_NOTIFICATIONS` (confirmed in the SDK 58 manifest) and `RECEIVE_BOOT_COMPLETED` (so scheduled notifications can be restored after reboot).

On Android 13 (API 33) and later, the user must opt in. Expo's docs say the system prompt **does not appear until at least one notification channel exists**, and that `setNotificationChannelAsync` must run **before** `getExpoPushTokenAsync` or `getDevicePushTokenAsync`. Create the channel, then request permission.

```ts
import * as Notifications from "expo-notifications";
import { Platform } from "react-native";

export const ensureAndroidChannel = async () => {
  if (Platform.OS !== "android") return;

  await Notifications.setNotificationChannelAsync("default", {
    name: "default",
    importance: Notifications.AndroidImportance.MAX,
  });
};
```

Channel ids are stable. Android stores the user's mute choice against the id. If you rename `default` to `general`, you get a new channel and you lose the old preference. Pass the same `channelId` in the push payload. If you send a `channelId` the app has never created, Android does not show the notification.

On Android 8 and later, sound and importance live on the channel, not on each message. The HTTP field `sound` is documented as **iOS only**.

Exact alarms are separate. From Android 12, a notification that must fire at an exact clock time needs `SCHEDULE_EXACT_ALARM`. Android 14 denies it by default on new installs. Request it with `requestExactAlarmPermissionsAsync` only when you need that. Do not declare `USE_EXACT_ALARM` unless the app is an alarm, timer, or calendar. Google Play limits that permission to those categories.

### iOS permission

iOS does not need a usage-description string for notifications. `requestPermissionsAsync()` asks for alerts, badge, and sound by default. The root `status` is not the whole answer. A user can allow alerts and deny sound or badges. `getPermissionsAsync()` reports those as `ios.allowsSound` and `ios.allowsBadge`, and the top-level status can stay `granted` while either one is off. Provisional authorization is `IosAuthorizationStatus.PROVISIONAL`.

```ts
import * as Notifications from "expo-notifications";

export const notificationsAllowed = async () => {
  const settings = await Notifications.getPermissionsAsync();
  return (
    settings.granted ||
    settings.ios?.status === Notifications.IosAuthorizationStatus.PROVISIONAL
  );
};
```

Ask after the user has seen why the alert is useful. A cold-start prompt gets denied, and iOS will not show it again. Send them to system settings with `Linking.openSettings()` when status is `denied`.

## Read the Expo push token

The token is scoped to your EAS project. `projectId` is set when you create a development build. Set it yourself anyway, under `extra.eas.projectId`, so a transfer between Expo accounts does not mint a new token.

```tsx
import Constants from "expo-constants";
import * as Notifications from "expo-notifications";
import { Platform } from "react-native";

Notifications.setNotificationHandler({
  handleNotification: async () => ({
    shouldPlaySound: false,
    shouldSetBadge: false,
    shouldShowBanner: true,
    shouldShowList: true,
  }),
});

export const getExpoPushToken = async () => {
  if (Platform.OS === "android") {
    await Notifications.setNotificationChannelAsync("default", {
      name: "default",
      importance: Notifications.AndroidImportance.MAX,
    });
  }

  const existing = await Notifications.getPermissionsAsync();
  let status = existing.status;

  if (status !== "granted") {
    const requested = await Notifications.requestPermissionsAsync();
    status = requested.status;
  }

  if (status !== "granted") return null;

  const projectId =
    Constants.expoConfig?.extra?.eas?.projectId ??
    Constants.easConfig?.projectId;

  if (!projectId) {
    throw new Error("Project ID not found");
  }

  const token = await Notifications.getExpoPushTokenAsync({ projectId });
  return token.data;
};
```

`shouldShowAlert` on the handler is deprecated. The current fields are `shouldShowBanner` and `shouldShowList`. On Android, the SDK says `shouldPlaySound: false` **drops the heads-up banner** no matter the priority, and it overrides the channel sound. If a foreground Android notification never drops down, set `shouldPlaySound: true`.

If `projectId` is missing, `getExpoPushTokenAsync` rejects with `ERR_NOTIFICATIONS_NO_EXPERIENCE_ID`. The sample above throws `"Project ID not found"` before that call so the failure is obvious.

The string you store looks like `ExponentPushToken[xxxxxxxxxxxxxxxxxxxxxx]`. The FAQ, same day:

* It stays the same across app upgrades.
* On Android, a reinstall can change it.
* On iOS, it stays the same across uninstall and reinstall.
* It changes if you change `applicationId` or `experienceId` (usually `@expoUsername/projectSlug`).
* It does not expire. After an uninstall, a later send comes back `DeviceNotRegistered`. Stop sending to that token.

`getExpoPushTokenAsync` and `getDevicePushTokenAsync` can sit unresolved for a long time on iOS. Expo points at Apple's troubleshooting note: that is often no network, airplane mode, or APNs being slow, not a bug in the library. Do not treat a hanging promise as a null token.

A restricted key inside `google-services.json` is a different failure. If the key blocks the FCM Registration API or the Firebase Installations API, or the Android restriction uses the upload-key SHA-1 instead of the Play app-signing SHA-1, Firebase returns `403 PERMISSION_DENIED` and the app never gets a token. The [FCM V1 guide](https://docs.expo.dev/push-notifications/fcm-credentials/) has the check.

## FCM on Android and an APNs key on iOS

You need both credentials even when every send goes through Expo. Expo forwards Android to FCM v1 and iOS to APNs. You do not call Google or Apple from your server unless you opt out of the Expo service.

### Android: FCM V1

1. Create or reuse a Firebase project and add an Android app whose package name matches `android.package`.
2. Download `google-services.json`. Point `android.googleServicesFile` at it. This file is public identifiers. You may commit it.
3. In Firebase, open Project settings, Service accounts, and generate a new private key. Do not commit that JSON.
4. Upload it to EAS as the FCM V1 credential: `eas credentials`, then Android, your build profile, Google Service Account, **Manage your Google Service Account Key for Push Notifications (FCM V1)**. The [Expo dashboard](https://expo.dev) path is Project, Credentials, FCM V1 service account key.

If you reuse an existing service account, it needs the **Firebase Cloud Messaging API Admin** role. A legacy FCM server key is not the credential this guide uses.

Firebase is required for Android delivery. It is not required for iOS on the Expo path. iOS uses the APNs key below. TurboStarter's [Firebase project](https://www.turbostarter.dev/docs/mobile/installation/firebase) doc is the kit's version of step 1.

### iOS: APNs key

On the first iOS `eas build`, answer yes to setting up push notifications and generating an Apple Push Notifications key. Or run `eas credentials` later, choose iOS, and open Push Notifications. Register a physical device before that first device build if you have not already.

A missing key shows up as `No valid aps-environment entitlement string found`. Generate the key and rebuild. Revoking the key stops delivery for every app that used it until you upload a replacement. A new key does not change existing Expo push tokens. `InvalidCredentials` on a receipt is the same family of failure. Sometimes the receipt also says `InvalidProviderToken`, which Expo ties to both the APNs key and the provisioning profile: rebuild, and regenerate the key and profile.

On SDK 52 and earlier, Expo Go used Expo's credentials, so push could succeed there without your own keys. A release binary never borrows those keys. If a development build receives pushes and the store build does not, the production FCM key or APNs key is missing or revoked.

## Save the token, then send with the Expo push API

The token is useless until your server has it, tied to the user and ideally to the install. Refresh the row when permission is granted, when the app returns to the foreground after a reinstall, and when a receipt says `DeviceNotRegistered`.

If the phone and the web app share a login, store the token on that user. [Better Auth on Expo](https://www.turbostarter.dev/blog/better-auth-expo-react-native-guide) is the session this site uses for that shared identity. The token is not a secret you put in the binary, and it is not a session token. Anyone who has it can ask Expo to deliver a notification to that device until you turn on push security.

### A single message with curl

The HTTP/2 API does not require authentication unless you enable push security. Headers Expo documents: `accept: application/json`, `accept-encoding: gzip, deflate`, `content-type: application/json`.

```bash
curl -H "Content-Type: application/json" -X POST "https://exp.host/--/api/v2/push/send" -d '{
  "to": "ExponentPushToken[xxxxxxxxxxxxxxxxxxxxxx]",
  "title": "Hello",
  "body": "World",
  "data": { "url": "/dashboard" }
}'
```

The body is one object, or an array of **up to 100** message objects, all for the same EAS project. One `to` value can itself be an array of tokens. Gzip the body when the batch is large. Do not mix tokens from two Expo projects in one request (`PUSH_TOO_MANY_EXPERIENCE_IDS`).

### expo-server-sdk on Node

The npm package is `expo-server-sdk` (8.0.0 on the registry on 20 November 2026). The repo is [expo-server-sdk-node](https://github.com/expo/expo-server-sdk-node). It chunks to the request limit, gzips, opens at most six concurrent connections, and retries with backoff. That six-connection cap is Expo's docs, not a number to raise.

```ts
import { Expo, type ExpoPushMessage } from "expo-server-sdk";

const expo = new Expo();

export const sendExpoPush = async (to: string) => {
  if (!Expo.isExpoPushToken(to)) {
    throw new Error("Not an Expo push token");
  }

  const messages: ExpoPushMessage[] = [
    {
      to,
      title: "Hello",
      body: "World",
      sound: "default",
      data: { url: "/dashboard" },
    },
  ];

  const tickets = [];

  for (const chunk of expo.chunkPushNotifications(messages)) {
    const chunkTickets = await expo.sendPushNotificationsAsync(chunk);
    tickets.push(...chunkTickets);
  }

  return tickets;
};
```

`sound: "default"` plays the system sound on iOS when the user allowed sounds. Android playback follows the channel.

When you enable **push security** in the Expo dashboard, pass `accessToken` into `new Expo({ accessToken })`. Raw HTTP clients send an Authorization header of `Bearer` plus the access token. Docs say the constructor option needs `expo-server-sdk` **3.6.0 or newer**. Current 8.x is past that. Requests without a valid token then fail with `UNAUTHORIZED`. Until you flip the switch, `new Expo()` is enough. Turn it on before real users exist: a leaked Expo push token is enough to send to that device.

Fields worth knowing, from the [message format](https://docs.expo.dev/push-notifications/sending-notifications/#message-request-format):

| Field           | Platforms       | Use it for                                                                                        |
| --------------- | --------------- | ------------------------------------------------------------------------------------------------- |
| `to`            | iOS and Android | One token, or an array. Required.                                                                 |
| `title`, `body` | iOS and Android | The visible copy. Localize on the server.                                                         |
| `data`          | iOS and Android | JSON for the app. Keep it small. The whole payload must be at most 4096 bytes.                    |
| `channelId`     | Android         | Must match a channel the app created. Omit it and Expo uses a user-facing "Default" channel.      |
| `priority`      | iOS and Android | `default`, `normal`, or `high`. Omit it and Expo uses `default` (normal on Android, high on iOS). |
| `badge`         | iOS             | Number on the icon. `0` clears it.                                                                |
| `ttl`           | iOS and Android | Seconds to keep the message for redelivery. Omit it and each provider's default is 4 weeks.       |

`priority: "high"` is the value Expo's FAQ names when Android notifications show up, then stop. Normal priority will not wake a sleeping device. A `ttl` of 0 can also drop a normal-priority message that arrives while the device is in Doze.

Do not put secrets, one-time codes, or full message bodies you would not want Expo staff to see into `title`, `body`, or `data`. The FAQ says Expo does not store notification contents in a database, only in memory and queues long enough to deliver them, and that staff can see contents while they are actively debugging the service. Put an id in `data` and load the rest from your API after the tap.

## Tickets, receipts, and DeviceNotRegistered

A ticket with `status: "ok"` and an `id` means Expo **accepted** the message. It does not mean Apple, Google, or the phone got it. A ticket can also be `error` immediately, including `DeviceNotRegistered` when Expo already knows that token is dead.

Fetch receipts with the ticket ids:

```bash
curl -H "Content-Type: application/json" -X POST "https://exp.host/--/api/v2/push/getReceipts" -d '{
  "ids": ["XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX"]
}'
```

Expo asks you to check about **15 minutes** after the send. Receipts are often earlier. If one is still missing after 15 minutes, they treat that as a problem on their side. Receipts are **cleared after 24 hours**. The Node SDK readme, same vendor, says that under load you should allow up to 30 minutes, and that receipts stay available for at least a day. Use 15 minutes as the normal poll, and do not poll past 24 hours.

An `ok` receipt still only means FCM or APNs accepted the handoff. A phone that is off may get the alert later, or not, under that provider's rules. Expo's own line is best-effort, at-least-once delivery to Apple and Google. Duplicates and drops are both described as uncommon. There is **no SLA**, and FCM and APNs have outages of their own. Billing and security alerts need email or an in-app fallback.

Handle these codes. They are the ones Expo lists:

| Where             | Code                           | What to do                                                                                          |
| ----------------- | ------------------------------ | --------------------------------------------------------------------------------------------------- |
| Ticket or receipt | `DeviceNotRegistered`          | Delete the token. Send again only after the app registers a new one.                                |
| Receipt           | `MessageTooBig`                | The payload is over 4096 bytes on iOS and Android. Shrink `data`.                                   |
| Receipt           | `MessageRateExceeded`          | You are sending too often to one device. Back off and retry.                                        |
| Receipt           | `MismatchSenderId`             | The FCM V1 key and `google-services.json` are not the same Firebase sender.                         |
| Receipt           | `InvalidCredentials`           | The APNs key or FCM key was revoked or never uploaded for this build. Rebuild after you replace it. |
| Whole request     | `TOO_MANY_REQUESTS`            | Over 600 notifications per second for this project. The Node SDK throttles this.                    |
| Whole request     | `PUSH_TOO_MANY_NOTIFICATIONS`  | More than 100 messages in one request. Chunk.                                                       |
| Whole request     | `PUSH_TOO_MANY_RECEIPTS`       | More than 1000 ticket ids in one receipt request.                                                   |
| Whole request     | `PUSH_TOO_MANY_EXPERIENCE_IDS` | Tokens from more than one Expo project in one request.                                              |

`DeviceNotRegistered` shows up when Google or Apple say the device is gone. Uninstall the app and send again a minute later and you often will **not** see it. The FAQ says the delay is undefined and hard to reproduce on purpose. Still delete the token when the error arrives. Apple asks senders to stop.

Retry network errors, HTTP 429, and HTTP 5xx with exponential backoff. Do not retry HTTP 400. A malformed payload will fail the same way every time. The Node SDK readme is explicit that some tickets have no id: those failed before enqueue, and there is no receipt to fetch.

## Handlers, taps, and deep links

`setNotificationHandler` runs while the app is in the foreground. You decide whether a banner, a list entry, a sound, or a badge happens. In the background or when the app is killed, a normal notification (one with a title or body) is drawn by the OS. A headless push (only `data`, plus `contentAvailable: true` on iOS) is not drawn. It can run a JavaScript task if you add `expo-task-manager` and, on iOS, background remote notifications. The OS does not promise that task will run. Apple's guidance, via Expo, is no more than a couple of silent pushes an hour. Prefer a visible notification unless you need the background task.

Register listeners at startup, not after the first navigation. If the user taps a notification that launches a killed app, the listener can miss the event on iOS. Also read `getLastNotificationResponse()` (or `useLastNotificationResponse`) once on launch.

```tsx
import * as Notifications from "expo-notifications";
import { router } from "expo-router";

const openFromNotification = (notification: Notifications.Notification) => {
  const url = notification.request.content.data?.url;
  if (typeof url !== "string") return;
  if (!url.startsWith("/")) return;

  router.push(url);
  Notifications.clearLastNotificationResponse();
};

export const bindNotificationTaps = () => {
  const last = Notifications.getLastNotificationResponse();
  if (last?.notification) openFromNotification(last.notification);

  const subscription = Notifications.addNotificationResponseReceivedListener(
    (response) => {
      openFromNotification(response.notification);
    },
  );

  return () => subscription.remove();
};
```

Only accept a path you know. `data.url` is attacker-controlled if someone can send to your tokens. The [deep linking](https://www.turbostarter.dev/docs/mobile/deep-linking) doc covers schemes, Universal Links, and App Links. `addNotificationReceivedListener` is the "it arrived" event, including in the foreground. The response listener is the tap.

On Android, force-stopping the app from system settings stops notifications until the user opens the app again. That is Android, not an Expo bug.

## Local notifications vs remote push

Local notifications are scheduled on the device. Remote notifications come from your server. Both use the same permission, the same Android channels, and the same handler.

Show one immediately:

```ts
import * as Notifications from "expo-notifications";

await Notifications.scheduleNotificationAsync({
  content: { title: "Saved", body: "We stored your draft on this phone." },
  trigger: null,
});
```

`trigger: null` never touches Expo, FCM, or APNs. If it does not appear, the bug is permission, the channel, or the handler. A `TIME_INTERVAL` trigger (with optional `repeats: true`) and a `DATE` trigger are the same function. Scheduling still will not show a foreground banner unless the handler allows one.

Use local notifications for reminders that only this device knows about. Use remote push when the event happened on the server.

## Test with the Expo push notification tool

The [push notification tool](https://expo.dev/notifications) is a form on expo.dev. Paste the `ExponentPushToken[...]`, set a title and body, and send. The setup guide says the device should show it within a few seconds once credentials and the binary are right.

Order that does not waste a rebuild:

1. Schedule a local notification with `trigger: null`. That proves permission and the handler.
2. Print the Expo push token from the development build. If it is missing, stop. The tool cannot help.
3. Send from the tool, then from curl, then from `expo-server-sdk`.
4. POST the ticket id to `/push/getReceipts` if the ticket was `ok` and nothing arrived.

A send that works in a debug build and is silent in release is credentials. Release binaries do not borrow Expo Go's keys. One Android debug-only footgun: launching from a notification in a development build can skip the splash icon and fade (the SDK page says about 70% of the time). Release builds do not do this. Check with `npx expo run:android --variant release` before you call it a routing bug.

## Expo push notifications pricing and limits

Checked on Expo's push FAQ and the sending guide, 20 November 2026:

* **Sending is free.** There is no per-message price and no monthly push fee on the Expo push service.
* **600 notifications per second per project.** Over that, requests fail until you slow down. The Node SDK throttles and retries.
* **100 messages per send request. 1000 receipt ids per receipt request.**
* **4096 bytes** total payload, or the receipt is `MessageTooBig`.
* **No SLA.** Design for a late or missing push.
* **No authentication on the API until you enable push security.**

EAS Build, EAS Submit, and EAS Update are different products. Their prices are not a push fee. The [EAS guide](https://www.turbostarter.dev/blog/eas-build-eas-submit-guide) quotes the build plans. A paid Apple Developer account is still required before iOS will issue a push key. Bursts over 600 per second belong in a queue. Do not open unbounded `fetch` calls next to the SDK.

## When the Expo push service is the wrong tool

Stay on Expo's API if you send transactional alerts from the backend you already run, you can live with the documented payload, and 600 per second is enough headroom. That is the common SaaS case: a reply, a billing receipt, a team invite.

Call FCM and APNs yourself when you need a feature the Expo payload does not expose, or you already operate those providers. Swap `getExpoPushTokenAsync` for `getDevicePushTokenAsync` and keep the permission and display code. Expo's [custom sending guide](https://docs.expo.dev/push-notifications/sending-notifications-custom/) shows the shape of an FCM HTTP v1 request and an APNs HTTP/2 request. Two details from that page that bite people coming from old Expo Go posts: `experienceId` and `scopeKey` on an FCM data message matter for **Expo Go**, and from SDK 53 that support is gone. On APNs, those fields are documented as required only for legacy Expo Go on SDK 52 and earlier. A development build does not need them. Sandbox APNs is `api.sandbox.push.apple.com`. Production is `api.push.apple.com`.

OneSignal's current Expo setup (their docs, 20 November 2026) is a different client. They require a development build, Expo SDK 53 or newer, the New Architecture, and EAS Build. Push does not work in Expo Go. You still create Firebase credentials for Android and an APNs p8 or p12 for iOS, and you store those in OneSignal, not only in EAS. Install `onesignal-expo-plugin` and `react-native-onesignal`, and put the plugin first in the plugins array. They offer a free account to start. This post does not quote their paid tiers. Pick them for the dashboard and segmentation. Do not pick them to avoid FCM and APNs setup. You still do that setup. You just do it in their UI, and you take a dependency you do not own.

## What TurboStarter already wires

[TurboStarter](https://www.turbostarter.dev) is a production-ready starter kit: a web app, an Expo mobile app, and a browser extension on one backend you own. The mobile notifications wiring is documented in [push notifications](https://www.turbostarter.dev/docs/mobile/push-notifications), and the product page is the [Expo push notifications starter](https://www.turbostarter.dev/stacks/expo-push-notifications-starter).

What the kit actually ships:

* The `expo-notifications` config plugin, with an Android icon, a `default` channel, and an accent color, in `app.config.ts`.
* A `NotificationsProvider` that sets the foreground handler (`shouldShowBanner` and `shouldShowList` on, sound and badge off) and listens for receive and response events.
* `useNotificationsPermissions`, which creates the `default` channel before the Android permission request.
* `usePushToken`, which reads the token once permission is granted.
* A screen at **Dashboard, Settings, Notifications** to request permission, copy the token, and fire a local test (`trigger: null`).

What it does not ship, on purpose: a table for tokens, or an API route that sends. You persist `usePushToken`'s value for the logged-in user and send with `expo-server-sdk` from the backend you already have. Deep links are a listener you extend, reading `data.url`, not a router that is already wired. The stack page's marketing line about topic and segment targeting is not a feature in the docs. Add channels (`account` versus `marketing`) and your own segments on the server if you need them. Keep channel ids stable.

The same binary's sign-in is the [Better Auth Expo guide](https://www.turbostarter.dev/blog/better-auth-expo-react-native-guide). Kit pricing is on the [pricing page](https://www.turbostarter.dev/pricing). EAS and the Expo push service bill the Expo account you connect. They are not a line item on the starter kit.

<ContentCta title="Ship the app that receives the push" subtitle="Core Kit is the Expo app, the web app, and the extension on one backend." />

## FAQ

<Accordions>
  <Accordion title="Is Expo push notifications free?">
    Yes, for sending. Expo's push FAQ says there is no cost to send through the Expo push notification service. The cap is 600 notifications per second per project, with up to 100 messages per request. There is no SLA. EAS Build and EAS Update are priced separately. A paid Apple Developer account is required before EAS can create an iOS push key. That charge is Apple's.
  </Accordion>

  <Accordion title="Do Expo push notifications work in Expo Go?">
    Not for a real test on current SDKs. The `expo-notifications` reference says remote push is unavailable in Expo Go on Android from SDK 53, and that local notifications still work there. The push FAQ says Expo Go does not support push notifications from SDK 53 onward. On SDK 52 and earlier, Expo Go used Expo's credentials. Use a development build, a store build, or a local `npx expo run` binary. OneSignal's Expo guide says the same thing about Expo Go.
  </Accordion>

  <Accordion title="How do I test Expo push notifications?">
    Confirm a local notification with `scheduleNotificationAsync` and `trigger: null`. Then copy the `ExponentPushToken[...]` from the development build and paste it into the [Expo push notification tool](https://expo.dev/notifications), or POST it to `https://exp.host/--/api/v2/push/send`. If the ticket is `ok` and nothing arrives, fetch the receipt from `https://exp.host/--/api/v2/push/getReceipts` after about 15 minutes. A failure that exists only in a release build is credentials, not the tool.
  </Accordion>

  <Accordion title="What is different about iOS and Android setup?">
    Android needs a notification channel before the permission prompt, the `POST_NOTIFICATIONS` runtime opt-in on API 33+, and an FCM V1 service account plus `google-services.json`. Sound and importance are channel settings. iOS needs a paid Apple Developer account and an APNs key from `eas credentials` or the first `eas build`. There is no notification usage string. Badge and sound can be denied while alerts stay on, so read `ios.allowsSound` and `ios.allowsBadge`. iOS Simulator testing needs Xcode 14+, macOS 13+, and iOS 16+. Android emulators need Google Play services.
  </Accordion>

  <Accordion title="Do I need Firebase for Expo push notifications?">
    For Android, yes. Expo delivers Android notifications through FCM v1, so you upload a service account key to EAS and ship `google-services.json` even if your server only calls Expo. For iOS on this path, no. iOS uses an APNs key. You need Firebase on iOS only if you choose a sender that goes through FCM for Apple devices too.
  </Accordion>

  <Accordion title="Why is my Expo push token null?">
    The usual reasons, in order: permission was not granted, so the register function returned before `getExpoPushTokenAsync`. `projectId` is missing, which throws `Project ID not found` or `ERR_NOTIFICATIONS_NO_EXPERIENCE_ID` rather than a token. The app is Expo Go on Android, SDK 53 or later, where remote push is unavailable. `google-services.json` has a restricted API key and Firebase returns 403, so no token is issued. On iOS the call can also hang for a long time without returning null. Log the rejection. Do not only render an empty string.
  </Accordion>

  <Accordion title="How do Expo push notifications compare with Firebase and OneSignal?">
    Expo's service is a single HTTP API in front of FCM and APNs. You still create the FCM V1 key and the APNs key. Direct Firebase (including what people mean by React Native Firebase Messaging) uses `getDevicePushTokenAsync` and your own server calls, which is more control and more code. OneSignal adds a dashboard and segments. Their current Expo SDK still needs a development build, FCM, and an APNs key, and it targets Expo SDK 53 or newer. Use Expo's API until a person who does not ship code has to run campaigns, or until you need a native field Expo does not pass through.
  </Accordion>

  <Accordion title="What is the difference between local and remote notifications?">
    Local notifications are created on the device with `scheduleNotificationAsync`. `trigger: null` shows one now. A time interval or a date schedules one. Remote notifications start on your server, go through the Expo push API (or FCM and APNs), and arrive as a push. They share permission, channels, and the foreground handler. Test local first when a remote send fails.
  </Accordion>
</Accordions>

## Ship the token path, then the campaign tool

**Expo push notifications** come down to four pieces: a development build, a channel plus permission, an Expo push token tied to a `projectId`, and a server that stores tickets and reads receipts. FCM V1 and an APNs key are part of that path. The service is free to send, capped at 600 per second per project, and has no SLA.

Move to OneSignal, or to direct FCM and APNs, when the Expo payload or the lack of a campaign UI is the blocker. That move does not skip credentials. The mobile app in the [TurboStarter docs](https://www.turbostarter.dev/docs/mobile/push-notifications) is this same flow, with the client hooks already in the repo and the token table left for you to own.


More posts: [blog](https://www.turbostarter.dev/blog.md)
