Black Friday!-$150 off
home

Expo Push Notifications: A 2026 Setup Guide

·29 min read

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.

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. The binary you will install comes from EAS Build and EAS Submit.

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.

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 ServiceFCM and APNs, directOneSignal
Who your server callshttps://exp.host/--/api/v2/push/sendFCM HTTP v1 and APNs HTTP/2OneSignal's API
Token on the deviceExpo push token from getExpoPushTokenAsyncNative token from getDevicePushTokenAsyncOneSignal's own subscription, after their SDK initializes
Credentials you still createFCM V1 key uploaded to EAS. APNs key via EAS.Those same keys, stored where your server can sign requestsFirebase credentials and an APNs p8 (or p12) saved in the OneSignal dashboard
Remote push in Expo GoNot 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 gainOne 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 upSome 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 priceNo 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, sending, FAQ, FCM and APNs direct, OneSignal 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.

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 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:

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.

{
  "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.

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.

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.

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 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 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 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 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.

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. 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.

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:

FieldPlatformsUse it for
toiOS and AndroidOne token, or an array. Required.
title, bodyiOS and AndroidThe visible copy. Localize on the server.
dataiOS and AndroidJSON for the app. Keep it small. The whole payload must be at most 4096 bytes.
channelIdAndroidMust match a channel the app created. Omit it and Expo uses a user-facing "Default" channel.
priorityiOS and Androiddefault, normal, or high. Omit it and Expo uses default (normal on Android, high on iOS).
badgeiOSNumber on the icon. 0 clears it.
ttliOS and AndroidSeconds 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:

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:

WhereCodeWhat to do
Ticket or receiptDeviceNotRegisteredDelete the token. Send again only after the app registers a new one.
ReceiptMessageTooBigThe payload is over 4096 bytes on iOS and Android. Shrink data.
ReceiptMessageRateExceededYou are sending too often to one device. Back off and retry.
ReceiptMismatchSenderIdThe FCM V1 key and google-services.json are not the same Firebase sender.
ReceiptInvalidCredentialsThe APNs key or FCM key was revoked or never uploaded for this build. Rebuild after you replace it.
Whole requestTOO_MANY_REQUESTSOver 600 notifications per second for this project. The Node SDK throttles this.
Whole requestPUSH_TOO_MANY_NOTIFICATIONSMore than 100 messages in one request. Chunk.
Whole requestPUSH_TOO_MANY_RECEIPTSMore than 1000 ticket ids in one receipt request.
Whole requestPUSH_TOO_MANY_EXPERIENCE_IDSTokens 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.

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.

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 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:

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 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 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 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 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, and the product page is the 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. Kit pricing is on the pricing page. EAS and the Expo push service bill the Expo account you connect. They are not a line item on the starter kit.

Ship the app that receives the pushCore Kit is the Expo app, the web app, and the extension on one backend.
Try TurboStarter

FAQ

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 is this same flow, with the client hooks already in the repo and the token table left for you to own.

world map
Community

Connect with like-minded people

Join our community to get feedback, support, and grow together with 1,000+ builders on board, let's ship it!

Join us

Ship your startup everywhere. In minutes.

Don't burn tokens on setup and start building features on day one.

Get TurboStarter