Interactive Notification in Mobile Apps: What They Are, Types and How They Work

What is Interactive Notification

Interactive Notification is an extended format of a push notification containing interactive controls: buttons, switches, and text input fields. Unlike a standard notification that only informs, an interactive one allows the user to perform a target action directly from the notification shade or lock screen. According to Google Material Design (2025), interactive notifications are processed by the operating system without launching the main app process — this saves battery resources and speeds up response time. The developer defines a set of actions through categories on iOS and channels on Android, and the system displays them depending on the context.

Structure of an Interactive Notification

Each interactive notification consists of three levels: main content (title, body), actions (buttons), and optional text input. On iOS, these components are combined through UNNotificationCategory, and on Android — through NotificationCompat.Action.Builder. The system displays buttons below the notification text in a collapsed or expanded view depending on the OS version and text length. The user sees available actions immediately after receiving the notification and can perform one of them without switching to the app.

How Interactive Notifications Work

The mechanism of Interactive Notification operation is divided into two phases: registering categories when the app starts and processing the action when the user taps. At the registration stage, the developer creates category objects with a set of actions — each action has an identifier, a title, and options. When a push notification is received, the system matches it with the registered category by the categoryIdentifier field and automatically adds the corresponding buttons. When the user taps a button, the system calls the UNUserNotificationCenter delegate or PendingIntent on Android with the action identifier and passes the result back to the app. According to WWDC 2024, the processing time of an interactive action on iOS does not exceed 200 ms with proper configuration.

Types of Interactive Notifications

Interactive notifications are divided into three main types by interaction method: button-based, text-based, and multimedia. Each type solves its own task and is used in specific scenarios. The choice of type depends on the context — the fewer steps required from the user, the higher the conversion. Apple and Google recommend using buttons for confirmation, input fields for replies, and media for content preview.

Action Buttons

The most common type is a notification with one or more buttons, each performing a predefined action. For example, “Accept” and “Decline” buttons for a calendar event, “Like” and “Reply” for a message. iOS supports up to four buttons, Android — up to three. Buttons can be grouped by priority: normal and destructive (with confirmation). Apple recommends no more than two main buttons for user convenience on the lock screen.

Text Input

RemoteInput is a technology that allows the user to enter text directly in the notification without opening the app. On iOS, UNTextInputNotificationAction is used for this, on Android — RemoteInput.Builder with a key to extract the entered text. It is most often used in messengers for quick reply to a message. The entered text is passed to the app through the notification service or local handler. The limitation is that the text cannot contain formatting, only plain string.

Media Content

Notifications with media attachments allow displaying images, audio, and video directly in the notification shade. On iOS, this is implemented through UNNotificationAttachment, on Android — through NotificationCompat.MessagingStyle with BigPictureStyle. The media is loaded by the push provider server and sent along with the notification as an attachment. The attachment size is limited — Apple recommends no more than 10 MB, Google — no more than 1 MB for images. Media content increases the informativeness of notifications for news, marketplaces, and social networks.

Implementation on iOS

On iOS, Interactive Notification is implemented through the UserNotifications framework using UNNotificationCategory and UNNotificationAction. The app registers categories at startup, and when a notification is received, the system automatically displays the corresponding buttons. To handle actions, you need to implement the userNotificationCenter:didReceiveNotificationResponse:withCompletionHandler method. Below is an example of registering a category with a button and text input in Swift.

Registering Notification Categories

import UserNotifications

let replyAction = UNTextInputNotificationAction(
    identifier: "reply",
    title: "Reply",
    options: [.authenticationRequired],
    textInputButtonTitle: "Send",
    textInputPlaceholder: "Enter message…"
)

let category = UNNotificationCategory(
    identifier: "message",
    actions: [replyAction],
    intentIdentifiers: [],
    options: []
)

UNUserNotificationCenter.current()
    .setNotificationCategories([category])

After calling setNotificationCategories, the system saves the categories and uses them for all subsequent notifications. The code should be called at every app launch to synchronize categories with new versions. Response handling is performed in the notification center delegate — the app receives the action identifier and the entered text for further processing.

Handling Button Press

func userNotificationCenter(
    _ center: UNUserNotificationCenter,
    didReceive response: UNNotificationResponse,
    withCompletionHandler completion: @escaping VoidBlock
) {
    if response.actionIdentifier == "reply" {
        let textResponse = response as! UNTextInputNotificationResponse
        let message = textResponse.userText
        sendMessage(message)
    }
    completion()
}

The userNotificationCenter method is called by the system after the user taps a button or submits text. Inside the handler, the actionIdentifier is checked — if it matches the registered identifier, the app extracts the entered text from userText and sends it to the server. For regular buttons without text input, UNNotificationResponse is used without type casting.

Implementation on Android

On Android, interactive notifications are created through the NotificationCompat class with addAction and RemoteInput methods. Unlike iOS, Android does not require pre-registration of categories — actions are added directly to each notification through the Builder. This provides more flexibility: each notification can have a unique set of buttons. Below is an example of a notification with a reply button in Java using RemoteInput.

Creating a Notification with RemoteInput

RemoteInput remoteInput = new RemoteInput.Builder("key_reply")
    .setLabel("Reply")
    .build();

PendingIntent replyIntent = PendingIntent.getBroadcast(
    this, 1001,
    new Intent("ACTION_REPLY"),
    PendingIntent.FLAG_UPDATE_CURRENT
);

NotificationCompat.Action action =
    new NotificationCompat.Action.Builder(
        R.drawable.ic_reply,
        "Reply", replyIntent
    )
    .addRemoteInput(remoteInput)
    .build();

NotificationCompat.Builder builder =
    new NotificationCompat.Builder(this, "messages")
    .setContentTitle("New message")
    .setContentText("Hello! How are you?")
    .setSmallIcon(R.drawable.ic_notification)
    .addAction(action);

NotificationManagerCompat.from(this)
    .notify(100, builder.build());

The key element is RemoteInput, which connects the input field with the action. When the user taps the “Reply” button, the system opens a text input dialog inside the notification. After submission, the text is passed via Intent to a BroadcastReceiver or Activity through the specified PendingIntent. To get the text in the receiver, RemoteInput.getResultsFromIntent(intent) is used with the “key_reply” key.

Extracting Entered Text

Bundle results = RemoteInput.getResultsFromIntent(intent);
if (results != null) {
    CharSequence reply = results.getCharSequence("key_reply");
    if (reply != null) {
        sendReplyToServer(reply.toString());
    }
}

The getResultsFromIntent method extracts the text entered by the user from the Intent passed by the system when submitting the response. The result is returned as a CharSequence, which is converted to a string for sending to the server. If the user closed the input dialog without submitting, results will be empty — this should be taken into account during processing. This approach allows implementing quick reply without launching an Activity.

Use Cases

Interactive Notification is used in applications of any type where a quick user action is required. The most effective scenarios are messengers for replying to a message, e-commerce for order confirmation, and calendars for accepting an invitation. According to Localytics (2025), apps with interactive notifications show 28% higher 7-day retention. Below is a table with popular scenarios and platform features.

When designing interactive notifications, it is important to consider the limitation — the user can perform an action only once. After pressing a button, the notification disappears or transitions to a “done” state. Therefore, each action should be irreversible or have a confirmation on the second step.