Notification Permission: what it is, notification types and how it works

What is Notification Permission?

Notification Permission is a system permission that controls an app’s ability to send notifications to the user. Before Android 13, all apps could display notifications without a request — it was enough to declare the permission in the manifest. However, with the rise of spam and intrusive notifications, Google introduced a mandatory runtime request, similar to iOS.

On iOS, notification permission has been mandatory since iOS 8, and starting with iOS 12, provisional notifications appeared — silent notifications that are delivered without sound and displayed in the Notification Center without an explicit request. Provisional notifications allow developers to show users the value of notifications before requesting full permission.

According to Localytics (2024), 61% of iOS users and 55% of Android users agree to receive push notifications after a request. Approval conversion directly depends on the context of the request: apps that ask for permission after the first valuable interaction receive 40% more approvals than those that ask on the first launch.

Evolution of Notification Permissions

The evolution of notification permissions shows how platforms have gradually restricted app access to this communication channel. Understanding this evolution helps developers properly handle different OS versions.

Android: from free access to strict control

Before Android 13 (2022), any app could display notifications without user consent. Android 8.0 (2017) introduced notification channels, Android 12 (2021) added automatic blocking of intrusive notifications, and finally Android 13 made it mandatory to request POST_NOTIFICATIONS at runtime. For apps with targetSdkVersion below 33, the system automatically grants the permission, but Google Play has required updating targetSdkVersion to 33+ since August 2023.

iOS: gradual tightening of control

iOS 8 (2014) introduced a mandatory permission request via UIUserNotificationSettings. iOS 10 (2016) introduced UNUserNotificationCenter with support for rich notifications. iOS 12 (2018) added provisional notifications and grouped notifications. iOS 15 (2021) introduced Focus Mode, which can block notifications regardless of app permission. App Tracking Transparency (iOS 14.5) is not related to notifications but has also influenced the overall culture of permission requests.

Current state

Currently, both platforms require a runtime Notification Permission request. Developers can no longer rely on automatic notification enablement. Users have full control over which apps can notify them. Notification channels on Android and notification categories on iOS allow users to fine-tune the types of alerts they receive.

Notification Permission on Android

Notification Permission on Android is enabled through the POST_NOTIFICATIONS permission declared in the manifest, followed by a runtime request for Android 13+.

Manifest declaration

For Android 13+, you must declare the POST_NOTIFICATIONS permission in AndroidManifest.xml. For backward compatibility with Android 12 and below, the permission is automatically granted by the system — no additional action is required.

<uses-permission android:name="android.permission.POST_NOTIFICATIONS" />

Runtime request in Kotlin

The POST_NOTIFICATIONS permission request is performed via the Activity Result API. It is important to check the SDK version: on Android 12 and below, no request is needed — the permission is considered automatically granted.

private val notificationPermissionLauncher =
    registerForActivityResult(ActivityResultContracts.RequestPermission()) { granted ->
    if (granted) {
        createNotificationChannel()
        showPushNotification()
    } else {
        logPermissionDenied()
    }
}

fun requestNotificationAccess() {
    if (Build.version.SDK_INT <= Build.VERSION_CODES.S_V2) {
        // Android 12 and below — permission granted automatically
        showNotification()
        return
    }
    if (ContextCompat.checkSelfPermission(this,
        Manifest.permission.POST_NOTIFICATIONS) == PackageManager.PERMISSION_GRANTED) {
        showNotification()
    } else {
        notificationPermissionLauncher.launch(Manifest.permission.POST_NOTIFICATIONS)
    }
}

Creating notification channels

On Android 8.0+, the app must create a notification channel via NotificationChannel before sending the first notification. The channel has an importance level from IMPORTANCE_NONE to IMPORTANCE_HIGH, which determines whether the notification will be displayed with sound and as a banner. If the user has disabled notifications for the app, new channels will not take effect until re-enabled in settings. It is recommended to create separate channels for different types of alerts: messages, ads, system events.

private fun createNotificationChannel() {
    val channel = NotificationChannel(
        CHANNEL_ID_MESSAGES,
        "Messages",
        NotificationManager.IMPORTANCE_HIGH
    ).apply {
        description = "New message notifications"
        enableVibration = true
    }
    val manager = getSystemService(NotificationManager::class.java)
    manager.createNotificationChannel(channel)
}

Notification Permission on iOS

Notification Permission on iOS is requested through UNUserNotificationCenter. Apple recommends a two-step approach: first request provisional notifications, then, after demonstrating value, request full permission.

Swift request with provisional option

Provisional notifications are silent notifications that appear in the Notification Center without sound or banner. They do not require explicit user consent and allow the app to demonstrate the value of notifications before a full request. After receiving several provisional notifications, the user can enable full notifications through the menu within the notification itself.

import UserNotifications

func requestNotificationPermission() {
    let center = UNUserNotificationCenter.current()
    center.requestAuthorization(options: [.alert, .badge, .sound]) { granted, error in
        if let error = error {
            print("Notification error: \(error.localizedDescription)")
            return
        }
        if granted {
            registerForRemoteNotifications()
        } else {
            handleDeniedPermission()
        }
    }
}

func requestProvisionalOnly() {
    let center = UNUserNotificationCenter.current()
    center.requestAuthorization(options: [.provisional, .alert, .badge, .sound]) { granted, error in
        // Provisional — user does not see the dialog
        // Notifications arrive silently in Notification Center
        registerForRemoteNotifications()
    }
}

Checking status and system settings

The current Notification Permission status on iOS can be obtained via UNUserNotificationCenter.current().getNotificationSettings. The status .authorized, .denied, .provisional, or .notDetermined allows the app to choose the correct behavior. After the first denial, the system dialog is not shown again — you must redirect the user to Settings via UIApplication.openSettingsURLString. Apple also recommends handling the .ephemeral status (iOS 17+), which provides temporary notifications for specific scenarios.

Best Practices for Requesting Notifications

Best practices for requesting Notification Permission aim to increase approval conversion and reduce user churn. An incorrect request can not only deprive the app of the ability to send notifications but also lead to app uninstallation.

Don’t ask on first launch

The most common antipattern is requesting Notification Permission on the first launch of the app. The user does not yet understand the app’s value and is highly likely to deny. The optimal moment is after the user has performed the first valuable action: placed an order, sent a message, subscribed to updates. A post-value prompt increases approval conversion to 65-75%.

Use a pre-permission screen

Before the system dialog, show your own screen with examples of notifications the user will receive. Display a mockup of a future notification with text and an icon. If the user sees that the notifications will be useful and non-intrusive, they are more likely to consent. A notification preview on the pre-permission screen is an effective technique that boosts conversion by 35-50%.

Use provisional notifications on iOS

Proactively requesting Provisional Notifications on iOS allows delivering notifications without explicit user consent. If the user sees value in these notifications, they can enable full notifications through the notification’s context menu. Apple recommends this approach for news apps, weather apps, and other services where notifications are informational rather than transactional. According to Apple WWDC 2024, this approach increases full approval conversion by 20-30%.