How do push notifications work in React Native?

Question

Accepted Answer

**Push notifications** let apps notify users even when the app isn't open — for messages, updates, and engagement. In React Native, they involve platform services (APNs for iOS, FCM for Android), permissions, device tokens, and handling notification events.

## How push notifications work (the flow)

```text
1. The app requests notification PERMISSION from the user (especially iOS — opt-in)
2. The device registers and gets a unique push TOKEN (identifies this device/app install)
3. The app sends the token to YOUR SERVER (stores it to target this device)
4. Your server sends a notification → via the platform service:
   APNs (Apple Push Notification service) for iOS, FCM (Firebase Cloud Messaging) for Android
5. The platform delivers it to the device → the app shows/handles it
→ Notifications work even when the app is closed (the OS handles delivery).
```

## Implementing in React Native

```text
→ LIBRARIES handle the complexity:
  - Expo Notifications (managed, simpler) — for Expo apps
  - @react-native-firebase/messaging (FCM) — common for bare/cross-platform
  - Notifee — rich local/displayed notifications
→ Request permission, get the token, send it to your backend, handle received notifications
```

## Handling notifications

```text
✓ FOREGROUND — app open: handle the notification in-app (show a banner, update data)
✓ BACKGROUND / closed — the OS shows it; tapping it OPENS the app (often to a specific
  screen — DEEP LINKING from the notification)
✓ Types: REMOTE (from a server, push) vs LOCAL (scheduled by the app itself)
✓ Handle the token lifecycle (refresh), permissions, and notification taps (navigation)
```

## Why it matters

Understanding how push notifications work is valuable because **notifications are a common, important feature** for user engagement and communication, so it's useful practical knowledge for apps that need them.

Push notifications (notifying users even when the app isn't open — for messages, updates, reminders, and engagement) are a widely-needed feature, and understanding how they work in React Native is valuable.

Understanding the **flow** — requesting **permission** (especially the iOS opt-in), getting a unique **device token**, sending it to **your server** (to target the device), and the server sending notifications **via platform services** (APNs for iOS, FCM for Android) that deliver to the device even when the app is closed — clarifies the architecture, which involves your app, your backend, and the platform push services working together.

Understanding that **libraries handle the complexity** (Expo Notifications for managed apps, React Native Firebase for FCM, Notifee for rich notifications) reflects the practical reality that you use libraries rather than implementing the low-level details.

Understanding **handling notifications** — the difference between foreground (app open, handle in-app), background/closed (the OS shows it, tapping opens the app, often with **deep linking** to a specific screen), and remote vs local notifications, plus managing the token lifecycle and notification taps (navigation) — is necessary for implementing notifications correctly.

Notifications are important for engagement and communication (a common product requirement), and implementing them involves platform-specific services and several moving parts.

Since push notifications are a common, valuable feature for engagement and communication, and since understanding the flow (permissions, tokens, platform services), the libraries, and handling notifications (foreground/background, deep linking) is necessary to implement them, understanding push notifications in React Native is valuable, practically-relevant knowledge — important for the common need of notifying and engaging users, involving platform-specific services and a multi-part flow that understanding clarifies, a useful capability for many real apps.