DEV Community: Notify sphere

Firebase iOS Push Notifications: APNs Key and SDK Setup

Notify sphere — Mon, 02 Nov 2026 10:36:08 +0000

Firebase Cloud Messaging (FCM) can deliver push notifications to iPhones, but it doesn't talk to iOS devices directly — it goes through Apple Push Notification service (APNs). Most “Firebase iOS push isn't working” problems come from the Apple side of that handshake. This guide sets up both sides in order.

How Firebase push works on iOS

Your app registers with APNs and receives an APNs device token. The Firebase iOS SDK maps that token to an FCM registration token, which is the one your server uses. When you send a message, FCM authenticates with APNs using the key you uploaded, and APNs delivers it to the device. If Firebase can't authenticate with APNs, nothing arrives — even though everything looks fine in your app.

Prerequisites

A paid Apple Developer Program membership — push needs one.
A Firebase project with your iOS app added, and its GoogleService-Info.plist.
Xcode and a physical iPhone or iPad. The Simulator isn't a reliable test for remote push.

1. Create an APNs authentication key

In the Apple Developer portal, open Certificates, Identifiers & Profiles → Keys and create a new key.
Enable Apple Push Notifications service (APNs) for the key, then register it.
Download the .p8 file and note its Key ID. Apple lets you download it only once, so store it somewhere safe.
Note your Team ID, shown in your developer account's membership details.

An authentication key doesn't expire like a push certificate, and one key works for all your apps — which is why it's the recommended option over the older .p12 certificates.

2. Upload the key to Firebase

In the Firebase console, open Project settings → Cloud Messaging. Under your Apple app, upload the .p8 key and enter the Key ID and Team ID. Firebase uses this key to authenticate with APNs on your behalf.

3. Add the Firebase iOS SDK

In Xcode, choose File → Add Package Dependencies and add https://github.com/firebase/firebase-ios-sdk. Select the FirebaseMessaging product. Then drag GoogleService-Info.plist into your app target.

4. Enable capabilities

Select your app target, open Signing & Capabilities, and add Push Notifications. Add Background Modes and check Remote notifications if you send silent or data-only pushes.

5. Request permission and get the FCM token

Configure Firebase at launch, ask the user for permission, register for remote notifications, and listen for the FCM token:

import UIKit
import FirebaseCore
import FirebaseMessaging
import UserNotifications

@main
class AppDelegate: UIResponder, UIApplicationDelegate,
                   UNUserNotificationCenterDelegate, MessagingDelegate {

  func application(_ application: UIApplication,
                   didFinishLaunchingWithOptions launchOptions:
                     [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
    FirebaseApp.configure()
    Messaging.messaging().delegate = self
    UNUserNotificationCenter.current().delegate = self

    UNUserNotificationCenter.current().requestAuthorization(
      options: [.alert, .badge, .sound]
    ) { granted, error in
      // Respect the user's choice; you can ask again later from settings
    }
    application.registerForRemoteNotifications()
    return true
  }

  // Called with a new or refreshed FCM registration token
  func messaging(_ messaging: Messaging,
                 didReceiveRegistrationToken fcmToken: String?) {
    guard let fcmToken else { return }
    // Send this token to your push server
    print("FCM token: \(fcmToken)")
  }

  // Show notifications while the app is in the foreground
  func userNotificationCenter(_ center: UNUserNotificationCenter,
                              willPresent notification: UNNotification) async
    -> UNNotificationPresentationOptions {
    [.banner, .sound, .badge]
  }
}

By default the Firebase SDK uses method swizzling to pass the APNs token to FCM automatically. If you set FirebaseAppDelegateProxyEnabled to NO in your Info.plist, you must pass the APNs token yourself by setting Messaging.messaging().apnsToken in didRegisterForRemoteNotificationsWithDeviceToken.

6. Send a test notification

Run the app on a physical device, accept the permission prompt, and copy the FCM token from the console. In the Firebase console, open Messaging, create a notification, and use Send test message with that token. Test with the app in the foreground, in the background, and fully closed.

Why Firebase iOS push isn't working

No APNs key in Firebase: the token is generated, but nothing is delivered. Check Project settings → Cloud Messaging.
Wrong Team ID or Key ID: APNs rejects Firebase's requests. Re-enter both from your Apple developer account.
Bundle ID mismatch: the iOS app in Firebase must use exactly the same bundle ID as your Xcode target.
Push Notifications capability missing: the app never receives an APNs token, so no FCM token works.
Swizzling disabled without passing the APNs token: FCM has no APNs token to map.
Permission denied: the user declined the prompt; notifications are delivered silently or not shown.

Using React Native or Flutter?

The Apple-side steps — APNs key, Firebase upload, and capabilities — are the same. The notifySphere SDKs handle the token and permission code for you: see the React Native guide and the Flutter guide. notifySphere runs on Firebase Cloud Messaging, so once your Firebase project can reach APNs, uploading its service account lets you send segmented iOS, Android, and web campaigns from one dashboard.

Originally published on the notifySphere blog. notifySphere is push notifications, WhatsApp Business API, deep linking, and in-app support in one SDK — free up to 1,000 users.

WhatsApp BSP in India: What It Is, Top Providers, Charges and How to Choose

Notify sphere — Mon, 02 Nov 2026 06:18:33 +0000

If you want to send WhatsApp messages from your own software, you'll quickly run into the term “BSP”. Here's what a WhatsApp Business Solution Provider actually does, how Meta's partner types differ, what they charge, and how to pick one without overpaying.

What is a WhatsApp BSP?

A WhatsApp Business Solution Provider (BSP) is a company that helps businesses access the WhatsApp Business Platform — the API version of WhatsApp. A BSP typically handles onboarding your business and phone number, gives you a dashboard to manage message templates and send campaigns, connects WhatsApp to your other tools, and supports you when something breaks.

Meta now calls these companies Solution Partners, but “BSP” is still the term most people search for and use.

Do you need a BSP?

Not strictly. Meta hosts the WhatsApp Cloud API, and any developer can call it directly with a Meta Business account, a verified phone number, and an access token. Going direct means no provider fee — but you build everything else yourself: template management, a send UI, contact lists, opt-in tracking, delivery reports, a shared inbox, and retries.

A provider makes sense when you want those pieces ready-made, when non-developers need to send campaigns, or when you want WhatsApp inside a wider engagement platform alongside push, email, or support.

WhatsApp BSP vs the WhatsApp Business app

The free WhatsApp Business app and a BSP solve different problems. The app is for a person replying to customers by hand from a phone. The API, which you reach directly or through a BSP, is for software sending messages: OTPs, order updates, reminders, and campaigns to thousands of people.

	WhatsApp Business app	WhatsApp Business API via a BSP
Who sends	A person, from a phone	Your backend, dashboard, or automations
Bulk and automated messages	No	Yes, with approved templates
Integrations and webhooks	No	Yes
Cost	Free	Meta's per-message rate plus the provider's fee

A phone number registered on the API can't be used in the regular WhatsApp or WhatsApp Business app at the same time, so many businesses use a separate number for the API.

Solution Partner vs Tech Provider vs Tech Partner

Meta's partner program has three types. The difference matters mostly for how you're billed:

Type	What they do	Who pays Meta
Solution Partner (the classic “BSP”)	Full WhatsApp services: onboarding, messaging, billing, support	The partner can extend its credit line and invoice you for Meta's charges
Tech Provider	Full WhatsApp services, on their own or with a Solution Partner	You add your own payment method to your WhatsApp Business Account
Tech Partner	Builds add-on solutions on top of the platform	Depends on the joint solution

WhatsApp BSPs in India: the main options

There are dozens of WhatsApp providers in India. Most businesses end up choosing between these, and the right one depends on who will use it and what you send:

Provider	Best suited to
Gupshup	Large brands and developers who want a mature messaging API and chatbot tools
Interakt	Small businesses and D2C stores that want a ready dashboard, catalogue and Shopify-style integrations
AiSensy	Small teams sending broadcast campaigns and running simple chatbots without code
WATI	Support teams that need a shared inbox where several agents answer WhatsApp chats
Twilio	Developers building WhatsApp into their own product with a global, pay-as-you-go API
Exotel	Businesses that already use cloud calling and want WhatsApp alongside it
notifySphere	Mobile apps that want WhatsApp, push notifications, install attribution and in-app support in one dashboard, with Meta's rate passed through at cost

All of them send through the same WhatsApp Business Platform, so message delivery and Meta's rates are the same. What differs is the dashboard, the integrations, the support, and the fee on top. Shortlist two or three by fit, then compare their fees with the table below.

How WhatsApp BSP pricing works

Your WhatsApp bill always has two parts:

Meta's per-message charge. Set by Meta, by template category (marketing, utility, authentication) and recipient country. Every provider pays the same Meta rate.
The provider's fee. A monthly platform fee, a markup on each message, or both. This is the only part that differs between providers.

So when comparing BSPs, ignore the headline per-message price and work out the markup over Meta's rate. Meta's October 2026 India rate card lists marketing templates at ₹0.8631 and utility, authentication and service messages at ₹0.115 per message, before GST. See what changed in October 2026 and what a monthly bill looks like in India.

What providers charge in India

Per-message pricing published by common providers, checked in October 2026 (excluding GST):

Provider	Marketing	Utility	Authentication
AiSensy	₹1.09	₹0.145	₹0.145
Interakt	₹0.949–₹0.970 (by plan)	₹0.160	₹0.129
Gupshup	Meta rate + $0.001 per message
Twilio	Meta rate + $0.005 per message, inbound and outbound
notifySphere	Meta rate + ₹0.04	Meta rate + ₹0.02	Meta rate + ₹0.01

Prices change — confirm on each provider's pricing page. Platform subscription fees are charged separately by some providers and aren't included above.

Markups add up quickly at volume. At 10,000 marketing and 20,000 utility messages a month, a 26% markup on Meta's rate costs about ₹2,800 more than paying Meta's rate alone, before any platform fee.

How to choose a WhatsApp BSP

Transparent pricing: can you see Meta's rate and the provider's fee separately?
Your own WhatsApp Business Account: make sure the account and phone number belong to you, so you can switch providers later without losing them.
API and webhooks: if your backend sends OTPs or order updates, check the API docs and delivery webhooks before signing up.
Template management: submitting templates and tracking approval in one place saves real time.
Opt-in and compliance: look for consent tracking and easy opt-out handling.
Other channels: if you also send push notifications or run support, one platform avoids a second vendor and a second customer record.
Billing model: decide whether you want the provider to invoice Meta's charges, or to pay Meta directly with your own card.

Can you switch WhatsApp BSPs later?

Yes. Meta supports moving a phone number from one WhatsApp Business Account to another, so you aren't locked in for good. Switching is easiest when the WhatsApp Business Account is in your own name from day one. Before you move, export your contacts and opt-in records, list the templates you rely on, and plan for a short window where sending is paused while the number moves across.

WhatsApp on notifySphere

notifySphere connects to your own WhatsApp Business Account and adds template management, campaign sending, delivery and read receipts, consent tracking, and a support inbox — alongside push notifications and app attribution in the same dashboard. Meta's rate is passed through at cost, with a processing fee of ₹0.01–₹0.04 per message. See pricing, or read the WhatsApp Business API developer guide. Sending one-time passwords? See the WhatsApp OTP API guide.

Frequently asked questions

What does BSP stand for in WhatsApp?

BSP stands for Business Solution Provider: a company that gives businesses access to the WhatsApp Business Platform (the API), usually with a dashboard, template management, and support. Meta now calls them Solution Partners.

Do I need a BSP to use the WhatsApp Business API?

No. Meta's Cloud API can be called directly with a Meta Business account, a verified phone number, and an access token. A provider is useful when you want a ready-made dashboard, campaigns, contact management, and support instead of building them yourself.

How much does a WhatsApp BSP charge in India?

Every provider pays Meta the same per-message rate. What differs is the provider's markup or platform fee on top. Published markups in India range from a few paise to over ₹0.20 per marketing message. notifySphere passes Meta's rate through at cost and adds a processing fee of ₹0.01 to ₹0.04 per message.

Who are the main WhatsApp BSPs in India?

Commonly used WhatsApp Business API providers in India include Gupshup, Interakt, AiSensy, WATI, Twilio, Exotel and notifySphere. They all send through Meta's WhatsApp Business Platform, so they differ mainly in dashboard, integrations, support and the fee they add on top of Meta's rate.

Is a WhatsApp BSP the same as a WhatsApp Business API provider?

Yes, in everyday use. BSP (Business Solution Provider) is the older name; Meta now calls these companies Solution Partners or Tech Providers. Any of them gives you access to the WhatsApp Business API.

Which is the cheapest WhatsApp BSP in India?

Compare the markup over Meta's rate, not the headline price, and include any monthly platform fee. Of the providers compared above, notifySphere has the lowest per-message processing fee. Prices change, so confirm on each provider's pricing page.

Can I use the same number in the WhatsApp Business app and the API?

Not at the same time. Once a number is registered on the WhatsApp Business Platform it can't be used in the regular WhatsApp or WhatsApp Business app, so many businesses use a separate number for the API.

Can I change my WhatsApp BSP later?

Yes. Meta supports moving a phone number between WhatsApp Business Accounts. Keeping the account in your own business's name makes the move much simpler.

Originally published on the notifySphere blog. notifySphere is push notifications, WhatsApp Business API, deep linking, and in-app support in one SDK — free up to 1,000 users.

Flutter Push Notifications Not Received in Background or When App Is Killed: Fixes

Notify sphere — Wed, 28 Oct 2026 06:37:22 +0000

Your Flutter app gets push notifications while it's open, but nothing shows up once it's in the background or closed. This is one of the most common Firebase Cloud Messaging problems, and it almost always comes down to a handful of causes. Here they are, from most to least likely.

Quick checklist

The background handler is a top-level function with @pragma('vm:entry-point').
FirebaseMessaging.onBackgroundMessage() is registered before runApp().
The message has a notification block, or is data-only with high priority (Android) and content-available (iOS).
Notification permission is granted (Android 13+ and iOS both ask).
On iOS: Push Notifications and Background Modes → Remote notifications are enabled, and the APNs key is uploaded to Firebase.
You're testing on a real device in a release or profile build, and the app wasn't force-stopped.

1. Set up the background handler correctly

When your app isn't in the foreground, firebase_messaging runs your handler in a separate Dart isolate. That only works if Flutter can find the function by itself, so it has to be a top-level function (not inside a class) and marked as an entry point. Otherwise tree shaking in release builds can remove it, and messages silently do nothing.

import 'package:firebase_core/firebase_core.dart';
import 'package:firebase_messaging/firebase_messaging.dart';
import 'package:flutter/material.dart';

// Must be a top-level function, not a class method or closure
@pragma('vm:entry-point')
Future<void> firebaseMessagingBackgroundHandler(RemoteMessage message) async {
  // Runs in its own isolate, so initialise Firebase again here
  await Firebase.initializeApp();
  debugPrint('Background message: ${message.messageId}');
}

Future<void> main() async {
  WidgetsFlutterBinding.ensureInitialized();
  await Firebase.initializeApp();

  // Register before runApp()
  FirebaseMessaging.onBackgroundMessage(firebaseMessagingBackgroundHandler);

  runApp(const MyApp());
}

Because the handler runs in its own isolate, it can't touch your widgets, providers or in-memory state. If you use other Firebase services inside it, call Firebase.initializeApp() there too.

2. Send the right kind of message

FCM has two kinds of messages, and they behave very differently in the background:

Notification messages (with a notification block) are displayed by the operating system itself when your app is in the background or closed. Your Dart code doesn't have to run for the user to see them. This is what you want for anything user-facing.
Data-only messages (just a data block) display nothing on their own. They wake your background handler, and only if the platform agrees to deliver them.

For a notification the user must see, send something like this through the FCM HTTP v1 API:

{
  "message": {
    "token": "DEVICE_FCM_TOKEN",
    "notification": {
      "title": "Your order is out for delivery",
      "body": "Arriving in about 20 minutes"
    },
    "data": { "orderId": "4821" },
    "android": {
      "priority": "high",
      "notification": { "channel_id": "high_importance" }
    },
    "apns": {
      "headers": { "apns-priority": "10" },
      "payload": { "aps": { "sound": "default" } }
    }
  }
}

If you really need a silent data-only message, mark it high priority on Android and as a background push on iOS:

{
  "message": {
    "token": "DEVICE_FCM_TOKEN",
    "data": { "type": "sync", "orderId": "4821" },
    "android": { "priority": "high" },
    "apns": {
      "headers": { "apns-push-type": "background", "apns-priority": "5" },
      "payload": { "aps": { "content-available": 1 } }
    }
  }
}

You can build and check both payloads with our free FCM payload builder, which also gives you the cURL command.

3. Ask for notification permission

Since Android 13, apps need the POST_NOTIFICATIONS runtime permission, and iOS has always needed one. Without it, messages are delivered to the device but never shown. Ask once, at a sensible moment:

final settings = await FirebaseMessaging.instance.requestPermission(
  alert: true,
  badge: true,
  sound: true,
);
debugPrint('Permission: ${settings.authorizationStatus}');

If the status comes back as denied, the system won't show the dialog again, so point the user to the app's notification settings instead.

4. Android: battery savers and force stop

If notifications arrive on a Pixel but not on some Xiaomi, Oppo, Vivo, Realme, OnePlus or Samsung phones, the phone's battery optimisation is likely stopping your app in the background. Things to check:

Force stop from Settings blocks every FCM message until the user opens the app again. A normal swipe from recents shouldn't, but some brands treat it like a force stop.
Use high priority for time-sensitive messages. Normal priority can be delayed while the phone is in Doze mode.
Create a notification channel with high importance and send its channel_id, or the notification may arrive silently without a heads-up banner.
For testing, set the app's battery usage to Unrestricted and turn on Autostart where the phone has it. You can't do this for your users, but it confirms the cause.

5. iOS: capabilities, APNs and how the app was closed

In Xcode, under Signing & Capabilities, add Push Notifications and Background Modes with Remote notifications ticked.
Upload your APNs authentication key in the Firebase console (Project settings → Cloud Messaging). Without it, nothing reaches iOS at all. The Firebase iOS push guide walks through it.
Background data messages are throttled by iOS and aren't delivered at all if the user swiped the app away. Notification messages are still shown in that case.
If you see apns-token-not-set, the device never got an APNs token. See how to fix the APNs token error.

6. Test the right way

Debug builds behave differently from what your users run. When you stop the app from your IDE, the process is killed in a way that real users never do, and background messages may not arrive. Test background and terminated states on a real device with flutter run --release (or a profile build), close the app the way a user would, then send a message.

To handle taps, use FirebaseMessaging.onMessageOpenedApp for a tap while the app is in the background, and FirebaseMessaging.instance.getInitialMessage() for a tap that launched the app from closed.

Want this handled for you?

The notifySphere Flutter SDK handles token registration and wires your background handler in at startup, and it tracks delivery and opens for every notification, so you can see whether a message reached the phone or was dropped on the way. It's free up to 1,000 monthly active users. Compare it with other options on our OneSignal alternatives page.

Frequently asked questions

Why do Flutter notifications work in the foreground but not in the background?

Usually one of four things: the background handler isn't a top-level function marked @pragma('vm:entry-point'), it's registered after runApp(), the message is data-only without high priority, or the phone's battery saver is stopping your app. Fix them in that order.

Why does onBackgroundMessage not get called on iOS?

For a data-only message, iOS needs content-available: 1 in the aps payload and the Background Modes capability with Remote notifications enabled. Even then iOS throttles background messages and won't deliver them if the user swiped the app away. For anything the user must see, send a notification payload instead.

Do push notifications arrive if the user force-stops or swipes away the app?

On Android, force stop from Settings blocks all FCM messages until the user opens the app again; a normal swipe from recents does not, except on some phone brands with aggressive battery savers. On iOS, notification messages are still shown after a swipe, but background data messages are not delivered.

Can I update the UI from onBackgroundMessage?

No. The background handler runs in a separate isolate with no access to your widgets or app state. Save what you need (for example with shared_preferences) and read it when the app opens, or use onMessageOpenedApp and getInitialMessage to react to taps.

Why are notifications not showing when the app is open?

That's expected. In the foreground, Android doesn't display FCM notifications on its own, so you show them yourself with flutter_local_notifications. On iOS, call setForegroundNotificationPresentationOptions(alert: true, badge: true, sound: true).

Originally published on the notifySphere blog. notifySphere is push notifications, WhatsApp Business API, deep linking, and in-app support in one SDK — free up to 1,000 users.

React Native Push Notifications: A Step-by-Step Guide

Notify sphere — Thu, 22 Oct 2026 05:35:22 +0000

Push notifications in React Native come down to three pieces: Firebase Cloud Messaging (FCM) to deliver messages, native setup on Android and iOS, and JavaScript that registers the device and reacts to notifications. This guide walks through all three with the notifySphere React Native SDK.

How React Native push notifications work

Each device gets a push token from FCM. Your app sends that token to a server — here, notifySphere — along with the user it belongs to. When you send a campaign, the server asks FCM to deliver it, and FCM reaches Android directly and iOS through Apple Push Notification service (APNs). One Firebase project covers both platforms.

Prerequisites

React Native 0.70 or newer.
A Firebase project with Cloud Messaging enabled.
A notifySphere app with an App ID and API token, and your Firebase service account uploaded under Settings → Messaging (see Firebase credentials).
A physical iPhone for iOS testing — push doesn't work on the iOS Simulator.

1. Install the SDK and its dependencies

npm install react-native-notify-sphere
npm install @react-native-firebase/app @react-native-firebase/messaging
npm install @notifee/react-native
npm install @react-native-async-storage/async-storage@^1.23.1
npm install react-native-device-info react-native-install-referrer
cd ios && pod install && cd ..

Pin AsyncStorage to v1 as shown. Version 2 needs a custom Maven repository that most React Native projects don't have configured.

2. Configure Android

Download google-services.json from the Firebase console into android/app/.
Apply the Google Services Gradle plugin.
Add the POST_NOTIFICATIONS permission — Android 13 and later require it to show notifications.
Add a small notification icon. Android silently drops notifications that don't have one.

3. Configure iOS

Add GoogleService-Info.plist to your Xcode project.
Under Signing & Capabilities, enable Push Notifications and Background Modes → Remote notifications.
Configure Firebase and the notification center delegate in your AppDelegate.

4. Register the background handler

Notifications that arrive while the app is in the background or closed are handled before your React tree mounts. Register the handler synchronously in index.js, before registerComponent() — if it's wrapped in a promise or timeout, those notifications are dropped.

// index.js
import { AppRegistry } from "react-native";
import App from "./src/App";
import { name as appName } from "./app.json";
import NotifySphere from "react-native-notify-sphere";
import { APP_ID, API_TOKEN } from "./src/App";

// Must run synchronously, before registerComponent()
NotifySphere.setBackgroundHandler({ appId: APP_ID, apiKey: API_TOKEN });

AppRegistry.registerComponent(appName, () => App);

5. Register the device and handle notifications

Call initialize() when the app mounts. It's safe to call on every launch — it only re-registers when the FCM token or user details change.

// src/App.tsx
import { useEffect } from "react";
import { Platform } from "react-native";
import NotifySphere from "react-native-notify-sphere";

export const APP_ID = "your-notifysphere-app-id";
export const API_TOKEN = "your-api-token";
const PUSH_TYPE = Platform.OS === "android" ? "AndroidPush" : "IOSPush";

export default function App() {
  useEffect(() => {
    NotifySphere.initialize({
      applicationUserId: 123, // your user's ID
      type: PUSH_TYPE,
      appId: APP_ID,
      apiKey: API_TOKEN,
      tags: { plan: "free" },
      debug: __DEV__,
    });

    NotifySphere.onNotification((notification, type) => {
      // type: "received" | "press" | "opened" | "initial"
      if (type === "press") {
        // navigate to the screen this notification is about
      }
    });

    return () => NotifySphere.destroy();
  }, []);

  // ...render your app
}

6. Tag users for segmentation

Tags let you target campaigns at specific groups — users in one city, users on a plan, users who haven't ordered in 30 days. Update them without re-registering the device:

await NotifySphere.updateTags({
  applicationUserId: 123,
  type: PUSH_TYPE,
  tags: { city: "Mumbai", lastOrderAt: new Date().toISOString() },
});

7. Send a test notification

Run the app on a physical device, accept the notification permission, then send a test push from the dashboard. Check three states: app open (foreground), app in the background, and app fully closed. If the closed-app case fails, the background handler almost always isn't registered early enough.

dashboard.notifysphere.net

Once devices register, subscriptions, monthly active users, and push sends show up on the dashboard.

8. Handle sign-out and account switching

A push token belongs to the device, not the user. If someone signs out and a different person signs in on the same phone, the server can keep sending the first user's notifications to that device unless you detach it. destroy() only removes local listeners, so on sign-out call logout() instead: it unsubscribes the device on the server, deletes the FCM token and clears cached user data. It doesn't clear tags, so when the new user signs in, call initialize() with that user's ID and their own tags.

// On sign-out: detach this device from the user (SDK 1.3.0+)
async function onSignOut() {
  await NotifySphere.logout();
  // ...then clear your own session
}

// On sign-in: register the device for the new user
async function onSignIn(user) {
  await NotifySphere.initialize({
    applicationUserId: user.id,
    type: PUSH_TYPE,
    appId: APP_ID,
    apiKey: API_TOKEN,
  });
}

Test it on one device, because foreground, background and closed-app checks won't catch this:

Sign in as User A and send a push to A. It should arrive.
Sign out, then send to A again. Nothing should arrive on this device.
Sign in as User B. A push to B should arrive; a push to A still shouldn't.
Check that B's tags and segments carry nothing over from A.

Thanks to Dave Kurian, who suggested this test in the comments of this guide on DEV.

Common problems

Nothing arrives on iOS: you're on the Simulator, or the Push Notifications capability is missing.
Nothing arrives on Android 13+: the user never granted the notification permission.
Arrives in foreground only: the background handler is registered too late.
Android shows nothing, no error: the small notification icon is missing.

The React Native SDK reference covers every method and option. Building in Flutter? See the Flutter push notifications guide.

Notifications arriving late rather than not at all? See why push notifications arrive late and how to fix it. Comparing push providers? Read notifySphere vs OneSignal and other OneSignal alternatives.

Originally published on the notifySphere blog. notifySphere is push notifications, WhatsApp Business API, deep linking, and in-app support in one SDK — free up to 1,000 users.

Flutter Push Notifications: A Step-by-Step Guide

Notify sphere — Wed, 14 Oct 2026 11:42:07 +0000

Flutter push notifications run on Firebase Cloud Messaging (FCM) for both Android and iOS. The Dart side is short; most of the work is native setup — and on iOS, one step that many guides skip decides whether you can tell if a notification was ever delivered.

How push notifications work in Flutter

Your app gets a device token from FCM and sends it to your push server along with the user it belongs to. When you send a campaign, the server asks FCM to deliver it. FCM reaches Android devices directly and iPhones through Apple Push Notification service (APNs), using the APNs key you upload to Firebase.

This guide uses flutter_notify_sphere, the notifySphere Flutter SDK, which handles registration and reports when each notification is delivered and tapped.

Prerequisites

Dart 3.9 or newer.
A Firebase project with Cloud Messaging enabled, and your APNs .p8 key uploaded in its Cloud Messaging settings.
A notifySphere app with an App ID and API token, with your Firebase service account uploaded (see push setup).
A physical iPhone — push doesn't work on the iOS Simulator.

1. Add the packages

dependencies:
  flutter:
    sdk: flutter
  flutter_notify_sphere: ^1.0.0
  firebase_core: ^4.3.0
  firebase_messaging: ^16.1.0

Use these Firebase versions or newer within the same major version. Older firebase_core and firebase_messaging releases won't resolve alongside the SDK.

2. Configure Android

Put google-services.json in android/app/ and apply the Google Services Gradle plugin.
Add the INTERNET, POST_NOTIFICATIONS, and VIBRATE permissions. Android 13 and later need POST_NOTIFICATIONS to show anything.
Set a default notification icon and the default channel ID in the manifest.

3. Configure iOS

Add GoogleService-Info.plist to the Runner target in Xcode.
Enable Push Notifications, Background Modes → Remote notifications, and an App Group named group.<your.bundle.id>.

4. Add a Notification Service Extension on iOS

This is the step most Flutter push tutorials leave out. When a notification arrives while your app is in the background or closed, iOS doesn't run any Dart code. Without native code, you can't confirm delivery or attach images in those states — which is most of the time.

A Notification Service Extension is a small native target that iOS runs for every incoming notification. Add one in Xcode (File → New → Target → Notification Service Extension), give it the same App Group as your app, and add the delivery-confirmation code from the Flutter SDK docs. The extension reads the credentials the SDK saved in the shared App Group, confirms delivery, and downloads any image attachment.

5. Initialize the SDK

Initialize Firebase, then the SDK, before runApp. The background handler must be a top-level function marked with @pragma('vm:entry-point') so it survives tree shaking and can run in a background isolate.

import 'package:firebase_core/firebase_core.dart';
import 'package:firebase_messaging/firebase_messaging.dart';
import 'package:flutter/material.dart';
import 'package:flutter_notify_sphere/flutter_notify_sphere.dart';

@pragma('vm:entry-point')
Future<void> backgroundMessageHandler(RemoteMessage message) async {
  // Runs in a background isolate — keep it short
}

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  await Firebase.initializeApp();

  await FlutterNotifySphere().initialize(
    showForegroundNotification: true,
    onNotificationClick: (RemoteMessage? message) {
      // Navigate to the screen this notification is about
    },
    backgroundMessageHandler: backgroundMessageHandler,
  );

  runApp(const MyApp());
}

6. Register the user

Register once you know who the user is. Taps and deliveries that happen before registration — such as a tap that cold-starts the app — are queued and sent once registration completes, so you don't lose them.

// After login, or on your home screen
await FlutterNotifySphere().registerUser(
  appId: 'YOUR_APP_ID',
  apiKey: 'YOUR_API_TOKEN',
  userData: {
    'applicationUserId': 12345,
    'name': 'Jane Doe',
  },
  onFcmToken: (token) => debugPrint('FCM token: $token'),
  onRegistrationComplete: (id) => debugPrint('Subscription: $id'),
  onError: (error) => debugPrint('Registration failed: $error'),
);

7. Test all three app states

Send a test from the dashboard to a real device, and check each state separately:

Foreground: a heads-up notification appears and onForegroundMessage fires.
Background: the notification shows in the tray; tapping it fires onNotificationClick.
Closed: the notification still shows, and on iOS the Delivered count rises — proof the service extension works.

dashboard.notifysphere.net

Registered Flutter devices appear as app subscribers, with push sends and delivery tracked per campaign.

Common problems

Version solving failed: your Firebase packages are older than the SDK requires.
iOS delivered count stays at zero when the app is closed: the service extension is missing, or it isn't in the same App Group as the app.
Nothing on Android 13+: the notification permission wasn't granted.
Background handler never runs: it isn't a top-level function, or the vm:entry-point annotation is missing.

The Flutter SDK reference lists every option. Using React Native instead? See the React Native push notifications guide.

Originally published on the notifySphere blog. notifySphere is push notifications, WhatsApp Business API, deep linking, and in-app support in one SDK — free up to 1,000 users.

Best SDK for Real-Time Push Notification Delivery: What Actually Matters

Notify sphere — Mon, 12 Oct 2026 09:58:40 +0000

An OTP that arrives after the user gave up, or a “your driver has arrived” alert that shows up five minutes late, is worse than no notification at all. If you're choosing a push SDK because delivery speed matters, here's how delivery actually works and what to compare.

How push delivery works

Every push notification takes the same path, whichever SDK you use:

Your server, or your push provider, sends the message with the device's token.
The platform service delivers it: Firebase Cloud Messaging (FCM) on Android and Apple Push Notification service (APNs) on iOS.
The operating system wakes your app or shows the notification directly.
A good SDK then reports back that the message arrived and whether it was tapped.

That means no SDK can deliver faster than FCM or APNs. What an SDK can do is make sure every message is sent in the way that gets it delivered immediately, and tell you when that didn't happen.

Why push notifications arrive late

Normal priority on Android. FCM holds normal-priority messages while the phone is in Doze mode and delivers them in the next maintenance window. Only high-priority messages wake the device.
Hidden high-priority messages. Android may deprioritise an app whose high-priority messages don't result in a visible notification. Keep high priority for messages the user will see.
Battery optimisation on some Android phones. Several manufacturers stop background apps aggressively, which is common on phones popular in India. Data messages handled by your app suffer most; notification messages shown by the system are more reliable.
Low priority or background pushes on iOS. APNs delivers apns-priority: 5 and silent content-available pushes when it suits the device's power state, and throttles them.
Stale device tokens. Tokens change after reinstalls and restores. Sending to an old token fails silently unless your provider removes tokens that FCM or APNs reports as unregistered.
Slow fan-out on the sending side. Large campaigns sent one token at a time from a single worker can take minutes to reach the last user.

The settings that control delivery speed

For a time-sensitive alert, these are the fields that matter in an FCM HTTP v1 request:

{
  "message": {
    "token": "DEVICE_TOKEN",
    "notification": { "title": "Your order is out for delivery", "body": "Arriving in 20 minutes" },
    "android": { "priority": "high", "ttl": "600s", "collapse_key": "order_1234" },
    "apns": {
      "headers": { "apns-priority": "10", "apns-push-type": "alert", "apns-collapse-id": "order_1234" }
    }
  }
}

android.priority: high and apns-priority: 10 deliver immediately.
apns-push-type: alert marks a user-facing notification on iOS.
ttl drops the message if it can't be delivered in time, so a stale “driver arriving” alert never shows up an hour later.
collapse_key and apns-collapse-id replace an older update with the newest one instead of stacking them.

What to compare when choosing a push SDK

Check	Why it matters for real-time delivery
Priority control per message	OTPs and live updates need high priority; promotions don't
Delivery receipts from the device	“Sent” isn't “delivered”. You need to see what reached the phone
Automatic token refresh and cleanup	Stale tokens are the quietest cause of lost notifications
Background and killed-app handling	Notifications must show when the app isn't running
TTL and collapse support	Old alerts expire instead of arriving late
Fallback channel	If a push isn't delivered or opened, a WhatsApp message can still reach the user
SDKs for your stack	Native setup for React Native and Flutter is where most delivery bugs start

Comparing providers? See how this plays out in notifySphere vs OneSignal and other OneSignal alternatives.

How to test delivery speed yourself

Install a release build on a real Android phone and a real iPhone, not an emulator.
Lock both phones and leave them for 30 minutes so Android enters Doze.
Send a high-priority notification and note the time it appears.
Repeat with the app force-stopped, and on a phone from a manufacturer known for battery optimisation.
Compare the send time with the delivery time your provider reports.

Real-time push with notifySphere

notifySphere delivers through FCM and APNs, and its React Native and Flutter SDKs report delivery and taps back to your dashboard, so you see what actually arrived, not just what was sent:

import NotifySphere from "react-native-notify-sphere";

await NotifySphere.initialize({
  applicationUserId: 123,
  type: Platform.OS === "android" ? "AndroidPush" : "IOSPush",
  appId: "YOUR_APP_ID",
  apiKey: "YOUR_API_KEY",
});

// Delivery and press events are reported back to your dashboard automatically
NotifySphere.onNotification((notification, type) => {
  if (type === "press") {
    // open the screen this notification is about
  }
});

If a push isn't opened, a journey can follow up on WhatsApp from the same dashboard. Setting up iOS? Start with the Firebase iOS push guide.

Frequently asked questions

What is the best SDK for real-time push notification delivery?

There's no SDK that is faster than the transport: on Android every push SDK delivers through Firebase Cloud Messaging, and on iOS through Apple Push Notification service. The best SDK is the one that sends with the right priority, keeps device tokens fresh, retries on failure, and reports delivery back to you so you can see what actually arrived.

Why are my push notifications delayed on Android?

The usual causes are normal-priority messages held during Doze mode, aggressive battery optimisation on some Android phones that stops apps in the background, and stale device tokens. Send time-sensitive messages with high priority and make sure each one shows a visible notification.

Why are push notifications delayed on iOS?

Low-priority (apns-priority 5) and background (content-available) pushes are delivered when it suits the device's power state and are throttled. User-facing alerts sent with apns-priority 10 and apns-push-type alert are delivered immediately.

Is Firebase Cloud Messaging real-time?

High-priority FCM messages are delivered immediately when the device is online, including waking it from Doze. Normal-priority messages may wait for a maintenance window. FCM is the delivery layer most push SDKs, including notifySphere, use on Android.

How can I measure push notification delivery?

A send API returning success only means FCM or APNs accepted the message. To know whether it reached the phone, the SDK on the device has to report a delivery event back. notifySphere's React Native and Flutter SDKs report delivery and taps to your dashboard.

Originally published on the notifySphere blog. notifySphere is push notifications, WhatsApp Business API, deep linking, and in-app support in one SDK — free up to 1,000 users.