Push Notifications

The Radar iOS SDK supports both local and remote push notifications for location events, enabling you to engage users based on their real-time location and behavior.

Overview

Radar supports two types of push notifications:

Local notifications: Triggered by location events (geofence entries/exits, beacon proximity)
Silent push notifications: Server-triggered notifications for campaign delivery and tracking

Setup

Enable push notification capability

In Xcode, navigate to your app target’s Signing & Capabilities tab.Click + Capability and add Push Notifications.

Configure notification permissions

Request notification permissions from the user:

import UserNotifications

UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound, .badge]) { granted, error in
    if granted {
        DispatchQueue.main.async {
            UIApplication.shared.registerForRemoteNotifications()
        }
    }
}

@import UserNotifications;

UNUserNotificationCenter *center = [UNUserNotificationCenter currentNotificationCenter];
[center requestAuthorizationWithOptions:(UNAuthorizationOptionAlert | UNAuthorizationOptionSound | UNAuthorizationOptionBadge)
                      completionHandler:^(BOOL granted, NSError * _Nullable error) {
    if (granted) {
        dispatch_async(dispatch_get_main_queue(), ^{
            [[UIApplication sharedApplication] registerForRemoteNotifications];
        });
    }
}];

Initialize SDK with notification options

Configure the SDK to automatically handle notifications:

import RadarSDK

let options = RadarInitializeOptions()
options.autoLogNotificationConversions = true  // Auto-log opened_app conversions
options.autoHandleNotificationDeepLinks = true // Auto-open URLs from notifications
options.silentPush = true                      // Enable silent push support

Radar.initialize(publishableKey: "YOUR_PUBLISHABLE_KEY", options: options)

@import RadarSDK;

RadarInitializeOptions *options = [[RadarInitializeOptions alloc] init];
options.autoLogNotificationConversions = YES;  // Auto-log opened_app conversions
options.autoHandleNotificationDeepLinks = YES; // Auto-open URLs from notifications
options.silentPush = YES;                      // Enable silent push support

[Radar initializeWithPublishableKey:@"YOUR_PUBLISHABLE_KEY" options:options];

Setting silentPush = true automatically calls registerForRemoteNotifications() and swizzles the app delegate to handle remote notifications.

Local notifications for location events

Radar can automatically show local notifications when location events occur.

Configure geofence notifications

Add notification metadata to your geofences in the Radar dashboard:

{
  "radar:entryNotificationText": "Welcome to our store! Show this notification for 15% off.",
  "radar:exitNotificationText": "Thanks for visiting! Come back soon."
}

Configure beacon notifications

Add notification metadata to your beacons:

{
  "radar:entryNotificationText": "You're near our product display!",
  "radar:exitNotificationText": "Check out more displays around the store."
}

Configure trip notifications

Add notification metadata to trip destinations:

{
  "radar:approachingNotificationText": "You're almost at your destination.",
  "radar:arrivalNotificationText": "You've arrived at your destination!"
}

Notification metadata format

For more control over notification appearance, use the full notification format:

{
  "radar:notificationText": "Check out our new arrivals!",
  "radar:notificationTitle": "Welcome to Our Store",
  "radar:notificationSubtitle": "Limited Time Offer",
  "radar:notificationURL": "myapp://store/new-arrivals",
  "radar:campaignId": "store-entry-campaign",
  "radar:campaignType": "eventBased"
}

Silent push notifications

Silent push notifications enable server-triggered location tracking and campaign delivery.

Enable silent push

Enable remote notification background mode

In Xcode, add Background Modes capability and enable Remote notifications.

Configure app delegate

When silentPush is enabled during initialization, the SDK automatically handles remote notifications. To manually handle them:

func application(_ application: UIApplication,
                 didReceiveRemoteNotification userInfo: [AnyHashable: Any],
                 fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
    Radar.didReceivePushNotificationPayload(userInfo) {
        completionHandler(.newData)
    }
}

func application(_ application: UIApplication,
                 didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
    // Device token is automatically captured by the SDK
}

- (void)application:(UIApplication *)application
    didReceiveRemoteNotification:(NSDictionary *)userInfo
          fetchCompletionHandler:(void (^)(UIBackgroundFetchResult))completionHandler {
    [Radar didReceivePushNotificationPayload:userInfo completionHandler:^{
        completionHandler(UIBackgroundFetchResultNewData);
    }];
}

- (void)application:(UIApplication *)application
    didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)deviceToken {
    // Device token is automatically captured by the SDK
}

If you enable automatic handling with silentPush = true, the SDK swizzles these methods automatically.

Notification conversions

Track when users interact with notifications:

Automatic conversion tracking

When autoLogNotificationConversions = true, the SDK automatically logs conversions when users tap notifications:

// Automatically tracked:
// - User opens app from notification
// - Event name: "opened_app"
// - Metadata includes notification payload

Manual conversion tracking

Manually log conversions for custom notification handling:

import RadarSDK

func userNotificationCenter(_ center: UNUserNotificationCenter,
                           didReceive response: UNNotificationResponse,
                           withCompletionHandler completionHandler: @escaping () -> Void) {
    // Log conversion for Radar notification
    Radar.logConversion(response: response)
    
    completionHandler()
}

@import RadarSDK;

- (void)userNotificationCenter:(UNUserNotificationCenter *)center
       didReceiveNotificationResponse:(UNNotificationResponse *)response
                withCompletionHandler:(void (^)(void))completionHandler {
    // Log conversion for Radar notification
    [Radar logConversionWithNotificationResponse:response];
    
    completionHandler();
}

Deep link handling

Automatic deep link handling

When autoHandleNotificationDeepLinks = true, the SDK automatically opens URLs from notification metadata:

{
  "url": "myapp://product/123"
}

Manual deep link handling

Manually handle deep links for custom routing:

func userNotificationCenter(_ center: UNUserNotificationCenter,
                           didReceive response: UNNotificationResponse,
                           withCompletionHandler completionHandler: @escaping () -> Void) {
    let userInfo = response.notification.request.content.userInfo
    
    if let urlString = userInfo["url"] as? String,
       let url = URL(string: urlString) {
        // Handle deep link
        handleDeepLink(url)
    }
    
    completionHandler()
}

- (void)userNotificationCenter:(UNUserNotificationCenter *)center
       didReceiveNotificationResponse:(UNNotificationResponse *)response
                withCompletionHandler:(void (^)(void))completionHandler {
    NSDictionary *userInfo = response.notification.request.content.userInfo;
    
    NSString *urlString = userInfo[@"url"];
    if (urlString) {
        NSURL *url = [NSURL URLWithString:urlString];
        // Handle deep link
        [self handleDeepLink:url];
    }
    
    completionHandler();
}

Upload APNs certificate

For server-triggered push notifications:

Generate an APNs certificate in the Apple Developer Portal
Upload the certificate to the Radar dashboard under Settings > Push Notifications
Configure your notification campaigns in the dashboard

Custom notification handling

For full control over notification presentation:

import UserNotifications
import RadarSDK

class NotificationDelegate: NSObject, UNUserNotificationCenterDelegate {
    func userNotificationCenter(_ center: UNUserNotificationCenter,
                               willPresent notification: UNNotification,
                               withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
        // Customize notification presentation
        if notification.request.identifier.hasPrefix("radar_") {
            // Radar notification
            completionHandler([.banner, .sound, .badge])
        } else {
            completionHandler([])
        }
    }
}

// Set delegate
UNUserNotificationCenter.current().delegate = NotificationDelegate()

@import UserNotifications;
@import RadarSDK;

@interface NotificationDelegate : NSObject <UNUserNotificationCenterDelegate>
@end

@implementation NotificationDelegate

- (void)userNotificationCenter:(UNUserNotificationCenter *)center
       willPresentNotification:(UNNotification *)notification
         withCompletionHandler:(void (^)(UNNotificationPresentationOptions))completionHandler {
    // Customize notification presentation
    if ([notification.request.identifier hasPrefix:@"radar_"]) {
        // Radar notification
        completionHandler(UNNotificationPresentationOptionBanner | UNNotificationPresentationOptionSound | UNNotificationPresentationOptionBadge);
    } else {
        completionHandler(UNNotificationPresentationOptionNone);
    }
}

@end

// Set delegate
[UNUserNotificationCenter currentNotificationCenter].delegate = [[NotificationDelegate alloc] init];

Best practices

Request permission at the right time

Request notification permissions when the user will understand the value, not immediately on app launch.

Keep messages relevant

Ensure notification content is contextually relevant to the location event.

Test notification campaigns

Use test devices and geofences to verify notifications before launching campaigns.

Monitor conversion rates

Track notification conversion rates in the Radar dashboard to optimize campaigns.

Troubleshooting

Notifications not appearing

Verify notification permissions are granted
Check that the Push Notifications capability is enabled
Ensure notification metadata is properly formatted in geofence/beacon configuration
Check device notification settings for your app

Silent push not working

Verify Remote notifications background mode is enabled
Ensure silentPush = true in initialization options
Check that APNs certificate is uploaded to the Radar dashboard
Verify the device token is registered

Conversions not tracking

Ensure autoLogNotificationConversions = true or call logConversion manually
Check that notification identifiers start with “radar_”
Verify the notification delegate is properly set

Getting Started

Core Features

Location Services

Configuration

Advanced

Migration & Support

Overview

Setup

Local notifications for location events

Configure geofence notifications

Configure beacon notifications

Configure trip notifications

Notification metadata format

Silent push notifications

Enable silent push

Notification conversions

Automatic conversion tracking

Manual conversion tracking

Deep link handling

Automatic deep link handling

Manual deep link handling

Upload APNs certificate

Custom notification handling

Best practices

Request permission at the right time

Keep messages relevant

Test notification campaigns

Monitor conversion rates

Troubleshooting

​Overview

​Setup

​Local notifications for location events

​Configure geofence notifications

​Configure beacon notifications

​Configure trip notifications

​Notification metadata format

​Silent push notifications

​Enable silent push

​Notification conversions

​Automatic conversion tracking

​Manual conversion tracking

​Deep link handling

​Automatic deep link handling

​Manual deep link handling

​Upload APNs certificate

​Custom notification handling

​Best practices

Request permission at the right time

Keep messages relevant

Test notification campaigns

Monitor conversion rates

​Troubleshooting

​Related resources

Overview

Setup

Local notifications for location events

Configure geofence notifications

Configure beacon notifications

Configure trip notifications

Notification metadata format

Silent push notifications

Enable silent push

Notification conversions

Automatic conversion tracking

Manual conversion tracking

Deep link handling

Automatic deep link handling

Manual deep link handling

Upload APNs certificate

Custom notification handling

Best practices

Troubleshooting

Related resources