push technology

Implementing Push Notifications in iOS Apps

Angela Stringfellow Last updated on October 4, 2024

Push notifications are a powerful tool for keeping users engaged, informed, and coming back to your app for more. Whether it’s a timely reminder, an exciting update, or a personalized message, push notifications significantly improve the user experience while boosting retention.

Best of all, push notifications are available on nearly all browsers, devices, and operating systems. However, Apple iOS has more requirements for push notifications, so it’s critical for businesses and developers to understand these differences. iOS is notorious for its stringent security requirements and user-first privacy controls, so design push notifications for your iOS app with these requirements in mind.

In this guide, we’ll give you a comprehensive, step-by-step guide to implementing push notifications for iOS apps. This tutorial will walk you through the entire process, from setting up the necessary configurations and writing the code to testing and troubleshooting.

In this article:

Understanding Push Notifications for iOS

iOS devices
Photo by Lala Azizli from Unsplash

Push notifications are messages sent from an app server to users' devices, prompting them to take action. Unlike in-app notifications, push notifications reach users even when they aren’t actively using your app.

They can appear on lock screens, notification centers, or as banners. For iOS apps, push notifications rely on the Apple Push Notification service (APNs), which routes these messages from your server to the target devices.

At a high level, iOS push notifications follow a three-step process:

  1. Server-side setup: You set up a server that delivers a notification payload to the Apple Push Notification service.
  2. APNS delivery: The APNs processes and routes the notification to the user’s device.
  3. Receipt: The notification displays on the target device based on the user’s notification settings.

This process is relatively straightforward, but remember that iOS push notifications must follow more stringent requirements than Android notifications. iOS implementation also has to account for:

Although iOS mobile push notifications have a few more requirements and considerations, they’re still worth your time. Push notifications offer several advantages that make them an essential feature for enhancing user engagement and retention, including:

Setting up iOS push notifications is a technical process. Still, with the right toolkit and processes, developers can build effective push notifications that keep users coming back to your iOS app.

6 Steps to Integrate Push Notifications Into an iOS App

iOS device settings
Photo by Brett Jordan from Pexels

Integrating push notifications into your iOS app involves several processes, from initial setup to implementation and testing. Follow these steps to set up push notifications for your iOS app.

1. Lay the Foundation

Start by getting your ducks in a row. To get started with integrating push notifications into your iOS app, you’ll need the following tools and software:

2. Set up a Project

Now that you have the necessary tools and an Apple Developer account, it's time to set up your iOS project in Xcode. Launch Xcode and click on "Create a new Xcode project" or select File > New > Project > App from the menu bar.

Configure your project by filling out these details:

  • Product Name: Enter a name for your app.
  • Team: Select your Apple Developer account.
  • Organization Name: Enter your organization or personal name.
  • Organization Identifier: Enter a unique identifier, typically in reverse domain format (like com.example.myapp).
  • Interface: Choose "Storyboard" or "SwiftUI" based on your preference.
  • Language: Select "Swift" as the programming language.

Now that you’ve set up the project, you’ll need to enable push notifications. Go to the project settings tab > Capabilities. Check the boxes and toggles to turn on Push Notifications, Background Modes, and Remote Notifications.

3. Configure Apple Push Notification Service (APNs)

To send push notifications to your iOS app, you need to configure the Apple Push Notification service (APNs). This involves registering your app with APNs, creating a push notification certificate, and generating an APNs Auth Key.

Visit the Apple Developer Console and sign in. Create an App ID and use it to create a push notification certificate. From there, you’ll generate a Certificate Signing Request (CSR). Once the system generates a certificate for you, download it and install it in Keychain Access. Save the certificate as a .p12 file, providing a password when prompted.

Next, go to Keys in the Apple Developer Console. Create a new key and download the Auth Key as a .p8 file. This file is only available for download once, so keep it somewhere safe!

4. Set up Push Notifications for Your iOS App

With the foundational setup complete, it's time to integrate push notifications into your iOS app by updating your code. The ‘AppDelegate’ file responds to application-level events like push notifications, so this is where you’ll make most of the changes.

Add the following import statement at the top of your AppDelegate.swift file:

import UserNotifications

Register your app for push notifications using the application(_:didFinishLaunchingWithOptions:) method:

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
    // Override point for customization after application launch.
    UNUserNotificationCenter.current().delegate = self
    registerForPushNotifications()
    return true
}
func registerForPushNotifications() {
    UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound, .badge]) { granted, error in
        print("Permission granted: \(granted)")
        guard granted else { return }
        self.getNotificationSettings()
    }
}
func getNotificationSettings() {
    UNUserNotificationCenter.current().getNotificationSettings { settings in
        print("Notification settings: \(settings)")
        guard settings.authorizationStatus == .authorized else { return }
        DispatchQueue.main.async {
            UIApplication.shared.registerForRemoteNotifications()
        }
    }
}

Next, you’ll set up device token registration for remote notifications:

func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
    let tokenParts = deviceToken.map { data in String(format: "%02.2hhx", data) }
    let token = tokenParts.joined()
    print("Device Token: \(token)")
}
func application(_ application: UIApplication, didFailToRegisterForRemoteNotificationsWithError error: Error) {
    print("Failed to register: \(error)")
}

Now it’s time to request permission from the user to send notifications. This is a crucial step you take using the ‘registerForPushNotifications()’ method:

UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound, .badge]) { granted, error in
    print("Permission granted: \(granted)")
    guard granted else { return }
    self.getNotificationSettings()
}

The app receives a device token when it successfully registers for remote notifications. This token must be sent to your server to send push notifications to this device:

func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
    let tokenParts = deviceToken.map { data in String(format: "%02.2hhx", data) }
    let token = tokenParts.joined()
    print("Device Token: \(token)")
    // Send the token to your server
}

Finally, you must conform to the UNUserNotificationCenterDelegate protocol to handle incoming notifications. Set the UNUserNotificationCenter delegate in the didFinishLaunchingWithOptions method:

UNUserNotificationCenter.current().delegate = self

Implement the userNotificationCenter(_:willPresent:withCompletionHandler:) and userNotificationCenter(_:didReceive:withCompletionHandler:) methods to handle notifications while the app is in the foreground and background, respectively:

extension AppDelegate: UNUserNotificationCenterDelegate {
    func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification, withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
        let userInfo = notification.request.content.userInfo
        // Handle the notification content here
        print("Foreground Notification received: \(userInfo)")
        completionHandler([.alert, .sound, .badge])
    }
    func userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse, withCompletionHandler completionHandler: @escaping () -> Void) {
        let userInfo = response.notification.request.content.userInfo
        // Handle the notification response here
        print("Background Notification received: \(userInfo)")
        completionHandler()
    }
}

5. Start Sending Notifications

The most intensive coding is done, so pat yourself on the back! Now that you’ve set up the iOS app to receive push notifications, it’s time to send them.

There are a lot of push notification services out there, but Firebase Cloud Messaging (FCM) is one of the most popular options. This cross-platform messaging solution allows you to send notifications for less hassle.

To get started, you’ll need an FCM account. Create a new project and add your iOS app to the project. Register your app with the iOS bundle ID, download the GoogleService-Info.plist file, and add it to your Xcode project. Make sure to add it to the root directory of your project.

From there, import Firebase in your AppDelegate.swift file:

import Firebase

Next, configure Firebase in the application(_:didFinishLaunchingWithOptions:) method:

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

Extend AppDelegate to conform to MessagingDelegate:

import Firebase
extension AppDelegate: MessagingDelegate {
    func messaging(_ messaging: Messaging, didReceiveRegistrationToken fcmToken: String?) {
        print("FCM Token: \(String(describing: fcmToken))")
        // Send the FCM token to your server
    }
}

Set the Messaging delegate in the application(_:didFinishLaunchingWithOptions:) method:

Messaging.messaging().delegate = self

6. Test and Troubleshoot

You’ve worked hard to set up iOS push notifications, but you should always double-check your work before sending messages to real users. iOS simulators are a popular option, but they won’t work for testing push notifications, so it’s best to test this on an actual iOS device.

There’s also a Push Notifications Console within the Apple Developer Console that allows you to send test notifications to Apple devices through APNs. And if you’re setting up push notifications for an iOS PWA, webpushtest.com is an excellent free tool. Use your chosen push notification service to send a test notification to your device.

Problems are common with web development, and push notifications are no exception. Every app has its quirks, but here are some common issues to look for:

  • Push notifications not going through: Check the app permissions, verify device tokens, and ensure you correctly configured the APNs certificate or key and it’s still valid. Check the console logs for any errors related to push notifications.
  • APNs issues: Ensure the notification payload is valid and complies with APNs requirements. Make sure your APNs certificate or key is correctly configured and not expired.
  • FCM debugging: Verify that your app is correctly configured in the Firebase Console and ensure the FCM token is correctly registered to the device.

Perfecting Push Notifications in Your iOS App

Push notifications are a powerful tool for increasing user engagement and retention for iOS apps. They require a few more steps than push notifications for Android devices, but iOS push notifications offer a much-needed lifeline between a business and its users.

You may need to get creative and customize implementation for your business’s unique needs. Still, the steps in this guide will set you up for iOS success.

But we’re willing to bet your users aren’t just active on iOS devices. They’re also on Slack, email, and other channels. Instead of creating push notifications for every single channel, go with MagicBell’s all-in-one solution. Create your free account now to start sending notifications in under an hour.

Frequently Asked Questions

What should I do if my push notifications aren’t being delivered?

  1. Check device token: Ensure the device token is correctly registered with your server.
  2. Verify APNs certificate and key: Make sure your APNs certificate or key is correctly configured and hasn’t expired.
  3. Check notification payload: Ensure your notification payload is valid and complies with APNs requirements.
  4. Monitor logs: Use tools like Charles Proxy or Wireshark to monitor network traffic and debug push notification requests.

Can I customize the appearance of push notifications?

Yes, you can customize the appearance of push notifications by adding rich media such as images, videos, and interactive elements. You can also use the UNNotificationContent class to specify custom content.

How do iOS push notification requirements differ from Android requirements?

iOS requires an Apple Developer Account, APNs, and explicit user permission to receive notifications. Android, on the other hand, requires a Firebase project and the Firebase API key. Android permissions are also declared in the manifest file and don’t require a runtime prompt for basic notifications.