APNs vs FCM: how push notifications actually reach your app
APNs is Apple's own delivery service between your server and an iPhone; FCM is Google's cross-platform messaging layer that on Apple devices still routes through APNs underneath. What each side owns (a trusted sending environment plus your app logic - your own server, managed compute, or the console as appropriate), payload caps (4 KB regular and 5 KB VoIP on APNs; 4096 bytes per FCM message but 2048 to topics, 1000 characters from the console), token trust, topics and offline behavior - from Apple's and Google's own documentation, read 21 November 2026.
Per Apple's and Google's own documentation, read 21 November 2026: APNs and FCM are not two rival services you pick between. Apple Push Notification service (APNs) is the delivery road between your server and an Apple device. Firebase Cloud Messaging (FCM) is Google's cross-platform messaging layer - and per Google's own architecture overview, on Apple devices FCM still routes messages through APNs as its platform transport. The real decision is whether to talk to the platform transports directly or to put Google's layer in between, and that decision is mostly about how many platforms you serve and which dependencies you accept.
What APNs is, and what you still own
Per Apple's documentation, a remote notification involves four components: your provider server, APNs, the user's device, and your app. You decide what to send and when; you forward a request with the payload and a device identifier to APNs; APNs handles delivery; the device's operating system handles user interaction and hands the notification to your app. Apple states it manages everything in between - but the two ends are yours: you are responsible for the provider server and for configuring your app. Concretely, per Apple's task list, your server must receive and store device tokens, decide when to send, maintain an HTTP/2 connection with TLS to APNs, POST notification requests, and handle token-based or certificate-based trust (token-based trust needs periodic regeneration). Apple's page also notes a root-certificate migration from AAA to USERTrust, with dates in its Developer News - worth checking before your certificates surprise you. On delivery, Apple is careful with its promises: APNs can store notifications for a device that is offline and forward them later, and it may coalesce notifications for the same bundle ID, for example for device power considerations. Best effort, not a guarantee.
What FCM is, and what it adds
Per Google's documentation, FCM is a cross-platform messaging solution covering iOS, Android, Web and Flutter. An implementation has two main parts: a trusted environment (Cloud Functions for Firebase, App Engine, or your own app server) where messages are built and sent via the Firebase Admin SDK or the FCM server protocol, and a client app that receives messages via the platform-specific transport. Per Google's architecture overview, those transports are the Android transport layer (restricted to approved Android devices with Google Play services, Chrome browsers and specific Google hardware), APNs for Apple devices, and the web push protocol for web apps. Google also notes these platform transports sit outside the core FCM product, so messages routed through them may be subject to platform-specific terms rather than FCM's. What the layer buys you: one API across platforms, message targeting to single devices, device groups or topics, fanout and message IDs handled by the FCM backend, a Notifications composer for testing and marketing sends, and a documented payload of up to 4096 bytes per message. What it does not remove: a trusted sender and your app logic - though that sender can be the console's Notifications composer for manual and marketing sends, or a managed environment such as Cloud Functions for Firebase or App Engine for automated ones. A dedicated self-operated server is not required.
How to choose between direct and layered
Start from platforms, not features. If your app is iOS-only, talking to APNs directly is a real, documented option: one dependency (Apple), full control of your connection and tokens, and you build exactly the sending features you need. The cost is that if Android ever arrives, you build a second pipeline. If you ship on more than one platform, FCM gives you one API, one token model (registration tokens per app instance) and topic targeting across all of them - at the price of adding Google's backend and SDKs as a dependency and, on iPhone, still depending on APNs underneath. Some teams mix: FCM for Android plus direct APNs for iOS, which keeps iOS on one dependency but means two sending paths to maintain. There is no default winner here; the right answer follows your platform list and how much infrastructure you want to operate versus delegate.
Where the honest limits are
Neither service promises instant or guaranteed delivery. Apple documents storage-and-forward for offline devices and coalescing; Google documents that delivery depends on the platform transport and the device's state. Device tokens and registration tokens change over time, so both models require you to keep your token store fresh. Payloads are small and the caps differ by path: APNs refuses payloads over 4 KB (4096 bytes) for regular remote notifications and 5 KB (5120 bytes) for VoIP, per Apple's payload reference; FCM documents up to 4096 bytes for both notification and data messages sent via its API, and a 1000-character limit on sends from the Firebase console. On size, Google's own pages are not perfectly aligned: the concept-and-limits page documents a 4096-byte maximum for both message types, while FCM's error reference specifies 4096 bytes for most messages but 2048 bytes, keys and values included, for messages sent to topics - so design topic payloads for the stricter figure. APNs sets its own caps as above. Either way, push is a doorbell, not a data channel: sync real content after the tap. And if you use FCM for marketing messages, note the composer exists for that, but transactional and marketing traffic have very different tolerance for delay; design them separately. This article describes the documented mechanics; it does not benchmark delivery speed on either service.
Sources, all read 21 November 2026: Apple Developer Documentation, Setting up a remote notification server (provider server, APNs, device and app components; Apple manages everything in between; HTTP/2 and TLS with token- or certificate-based trust; AAA-to-USERTrust root certificate migration; offline storage, forwarding and coalescing); Firebase Cloud Messaging documentation (cross-platform messaging; trusted environment plus client app; notification and data messages; single devices, groups or topics; payload up to 4096 bytes; updated 18 November 2026); FCM Architectural Overview (FCM backend plus platform transport layers: Android transport layer restricted to approved devices, APNs for Apple devices, web push protocol; transports outside the core FCM product; registration tokens per app instance; updated 18 November 2026); FCM message types, collapsible behavior and limits (4096-byte maximum payload for both message types; 1000-character limit for sends from the Firebase console); FCM error codes reference (messaging/payload-size-limit-exceeded: 4096 bytes for most messages, 2048 bytes for messages sent to topics, keys and values included); Apple Developer Documentation, Generating a remote notification (payload caps: 4 KB regular, 5 KB VoIP; APNs refuses larger payloads).
Choosing or building push infrastructure for a real app? Omnistu's Mobile Engineering practice works on iOS and Android apps, including the publishing process for both stores - write to team@omnistu.com with what you are deciding.
Frequently asked questions
Is FCM a replacement for APNs?
No. Per Google's architecture overview, FCM uses APNs as its platform transport layer for Apple devices - FCM adds a cross-platform API and backend on top. On Android, FCM's own Android transport layer is the transport, restricted to approved devices with Google Play services, Chrome and Google hardware.
What do I still have to build if I use APNs directly?
Per Apple's documentation, a provider server that: receives and stores device tokens from your app, decides when to send, keeps an HTTP/2 connection with TLS to APNs, POSTs notification payloads, and maintains token-based or certificate-based trust (token-based trust is regenerated periodically). Your app must also be configured to register with APNs.
What does FCM add over talking to APNs directly?
Per Google's docs: one API across iOS, Android, Web and Flutter; targeting to single devices, device groups or topics; message IDs and fanout handled by the FCM backend; a Notifications composer for testing and marketing sends; and notification plus data message types with payloads up to 4096 bytes. Automated sends still need a trusted environment - which can be managed, such as Cloud Functions for Firebase or App Engine; manual and marketing sends can come from the console's Notifications composer.
Is there a message size limit?
Yes, and it depends on the path. Per Apple's payload reference, APNs refuses regular remote notifications over 4 KB (4096 bytes) and allows up to 5 KB (5120 bytes) for VoIP notifications. Per Google's docs, FCM allows up to 4096 bytes per message for most messages sent via its API - but its error reference caps messages sent to topics at 2048 bytes, keys and values included (the limits page does not mention that carve-out, so treat 2048 as the safe topic figure) - and the Firebase console enforces a 1000-character limit. Either way, push is for waking the app, not shipping data.
Do notifications arrive if the phone is offline?
Per Apple, APNs can store notifications for an offline device and forward them when it comes back online, and it may coalesce notifications for the same bundle ID (for example for power considerations). Neither Apple nor Google promises immediate delivery in all conditions.
Who handles web push?
Both paths exist. Apple's documentation points Safari and browser pushes to APNs-based web push; Google's architecture uses the web push protocol for web apps. The web choice usually follows your mobile decision rather than driving it.