Live Activities let your iOS app show real-time updates directly on the lock screen and Dynamic Island. Ideal for delivery tracking, sports scores, or time-sensitive transactional updates, they keep users informed without opening the app.

​

Requirements

• Follow the iOS SDK setup if using native iOS (Swift/Objective-C).
  • If using a wrapper SDK (React Native, Flutter, Unity, etc.) follow Mobile SDK setup and then Cross-platform Live Activity SDK Setup.
• OneSignal iOS SDK version 5.2.0+ for push-to-start support (see release notes).
• iOS 16.1+ and iPadOS 17+
• Use a .p8 APNs key. Apple doesn’t support p12 certificates with Live Activities.
• Xcode 14 or higher

​

Setup

These steps walk you through setting up Live Activities quickly. For more details and design customizations, see Apple’s Live Activities Developer docs.

​

1. Add a Widget Extension

In Xcode, go to File > New > Target… > Widget Extension.

Select and press Next.

Configure the Widget Extension by providing a name (example: OneSignalWidget) and ensure Include Live Activity is selected. Then click Finish.

Click Don’t Activate if prompted to activate the scheme.

​

2. Update Info.plist

In your main target’s Info.plist, add the key Supports Live Activities as Boolean, and set it to YES.

If you set it programmatically, it should look like this:

<key>NSSupportsLiveActivities</key>
<true/>

​

3. Add SDK

target 'OneSignalWidgetExtension' do
  use_frameworks!
  pod 'OneSignal/OneSignal', '>= 5.0.0', '< 6.0'
end

​

4. Define widget attributes and UI

Open the your-nameLiveActivity.swift file (example: OneSignalWidgetLiveActivity.swift) to define the properties of the struct and to make changes to the widget UI.

• your-nameAttributes describes the static content of your Live Activity.
• ContentState describes the dynamic content of your Live Activity.

If you are following the example, copy-paste the code below into your OneSignalWidgetLiveActivity.swift file.

import ActivityKit
import WidgetKit
import SwiftUI
// Import the OneSignalLiveActivities module
// If you get an error about the module not being found, return to step 3 and ensure you have added the OneSignalLiveActivities pod correctly.
import OneSignalLiveActivities

// Update to inherit from OneSignalLiveActivityAttributes
// This will be used in your API requests to start a Live Activity
struct OneSignalWidgetAttributes: OneSignalLiveActivityAttributes  {
    // Update to inherit from OneSignalLiveActivityContentState
    public struct ContentState: OneSignalLiveActivityContentState {
        // Dynamic stateful properties about your activity go here!
        var emoji: String
        // Add a reference to OneSignalLiveActivityContentStateData?
        var onesignal: OneSignalLiveActivityContentStateData?
    }
    // Fixed non-changing properties about your activity go here!
    var name: String
    // Add a reference to OneSignalLiveActivityAttributeData
    var onesignal: OneSignalLiveActivityAttributeData
}

struct OneSignalWidgetLiveActivity: Widget {
    var body: some WidgetConfiguration {
      // Update to use `for: the-name-of-your-attributes-struct`
      // This will be used in your API requests to start a Live Activity
        ActivityConfiguration(for: OneSignalWidgetAttributes.self) { context in
            // Lock screen/banner UI goes here
            // Update to show the attributes sent via the payload
            VStack {
                Text("Hello \(context.attributes.name) \(context.state.emoji)")
            }
            .activityBackgroundTint(Color.cyan)
            .activitySystemActionForegroundColor(Color.black)

        } dynamicIsland: { context in
            DynamicIsland {
                // Expanded UI goes here.  Compose the expanded UI through
                // various regions, like leading/trailing/center/bottom
                DynamicIslandExpandedRegion(.leading) {
                    Text("Leading")
                }
                DynamicIslandExpandedRegion(.trailing) {
                    Text("Trailing")
                }
                DynamicIslandExpandedRegion(.bottom) {
                    Text("Bottom \(context.state.emoji)")
                    // more content
                }
            } compactLeading: {
                Text("L")
            } compactTrailing: {
                Text("T \(context.state.emoji)")
            } minimal: {
                Text(context.state.emoji)
            }
            .widgetURL(URL(string: "http://www.apple.com"))
            .keylineTint(Color.red)
        }
    }
}

​

5. Allow main target membership

Add your main app target to the Target Membership list in the your-nameLiveActivity.swift file.

In Xcode, open the Inspector panel on the right side of the screen. Within Target Membership, click the + button and select your main app target containing the ContentView and your OneSignal initialization code.

​

6. Add the setup method to your AppDelegate

Call OneSignal.LiveActivities.setup in your AppDelegate, after OneSignal SDK initialization.

Replace OneSignalWidgetAttributes with the name of your Live Activity attributes struct.

// Import the OneSignalLiveActivities module
import OneSignalLiveActivities

// This should be added after initializing the OneSignal SDK
if #available(iOS 16.1, *) {
	OneSignal.LiveActivities.setup(OneSignalWidgetAttributes.self)
  // If you have multiple Live Activities, you can add them here with the setup method
  // OneSignal.LiveActivities.setup(LiveActivityWidgetAttributes-2.self)
}

This manages and reports updates using ActivityKit async sequences.

​

Starting a Live Activity

There are 2 options to start a Live Activity on a device:

import SwiftUI
import ActivityKit
import OneSignalFramework
import OneSignalLiveActivities

struct ContentView: View {
  @StateObject private var viewModel = LiveActivityViewModel()

  var body: some View {
    VStack {
      Button("Start Live Activity") {
        viewModel.startLiveActivity()
      }
    }
  }
}

class LiveActivityViewModel: ObservableObject {

  func startLiveActivity() {
    let osAttributes = OneSignalLiveActivityAttributeData.create(activityId: "click-to-start")
    let attributes = OneSignalWidgetAttributes(name: "OneSignal", onesignal: osAttributes)
    let contentState = OneSignalWidgetAttributes.ContentState(emoji:"🤩", onesignal: nil)
    do {
        let activity = try Activity<OneSignalWidgetAttributes>.request(
            attributes: attributes,
            contentState: contentState,
            pushType: .token)
    } catch {
        print(error.localizedDescription)
    }
  }
}

​

Updating a Live Activity

Use the Update Live Activity API to update active widgets.

Match the activity_id used when starting the activity.

This example request will update the push-to-start widget because it has the activity_id titled push-to-start that we defined. To update the click-to-start widget, update the request path to use click-to-start instead of push-to-start.

curl --location 'https://api.onesignal.com/apps/YOUR_APP_ID/live_activities/push-to-start/notifications' \
--header 'Content-Type: application/json' \
--header 'Accept: application/json' \
--header 'Authorization: key YOUR_API_KEY' \
--data '{
    "event": "update",
    "event_updates": {
        "emoji": "😎"
    },
    "contents": {
        "en": "A push updated this Live Activity"
    },
    "name": "Live Activity Updated"
}'

​

Ending a Live Activity

Using the same Update Live Activity API, we can end a Live Activity by setting "event": "end".

curl --location 'https://api.onesignal.com/apps/YOUR_APP_ID/live_activities/my_activity_id/notifications' \
--header 'Content-Type: application/json' \
--header 'Accept: application/json' \
--header 'Authorization: key YOUR_API_KEY' \
--data '{
    "event": "end",
    "event_updates": {
        "emoji": "👋"
    },
    "contents": {
        "en": "A push ended this Live Activity"
    },
    "name": "Live Activity Ended"
}'

Other ways a Live Activity can end:

• Use our SDK exit() method.
• User manually swipes the Live Activity away.
• User revokes permission for Live Activities in their iOS Settings.

​

Best practices & recommendations

​

Design considerations

• Follow Apple’s Live Activities Human Interface Guidelines.
  • Prioritize important information to make it easy to understand at a quick glance.
  • Don’t add elements to your app that draw attention to the Dynamic Island.
  • Use margins and maintain space between elements.
  • Use a bold color for the background. Design for both Light and Dark mode.

​

Functionality

• Apple requires each Live Activity presentation to be supported.
  • Compact
  • Minimal
  • Expanded
  • Lock Screen
• Test your deep links.
• Review Apple’s guide on Displaying Live Data with Live Activities.
• Avoid displaying sensitive information in a Live Activity.

​

FAQ

​

What is the budget for high-priority updates?

Apple does not provide a fixed limit for high-priority (priority: 10) updates, but they do enforce a dynamic system-level budget. Sending too many high-priority updates in a short period may result in throttling, where updates are delayed or dropped.

To reduce the risk of throttling:

• Use a mix of priority levels: Apple recommends using both priority: 5 (standard) and priority: 10 (high) for balance.
• Reserve priority: 10 for time-sensitive or critical updates only (e.g., order status changes, game scores).

If your use case requires frequent updates:

• Add the key NSSupportsLiveActivitiesFrequentUpdates to your app’s Info.plist file, set as a Boolean YES.
• When this budget is exceeded, iOS may prompt the user to allow additional updates. If the user agrees, Apple will automatically expand the allowed update limit to maintain a seamless experience.

For more details, refer to Apple’s Developer Docs.

​

Can I read Live Activity updates from the main app?

Yes. You can observe updates for debugging or UI sync:

Task {
    for await content in activity.contentUpdates {
        print("LA activity id: \(activity.id), content update: \(content.state)")
    }
}
// Example output:
// LA activity id: EFE6D54D-F7E1-45EF-9514-4C2598F8DED2, content update: ContentState(message: "My message from payload")

Track lifecycle changes:

Task {
    for await state in activity.activityStateUpdates {
        print("LA state update: \(state)")
        //If you wanted to do something based on the state, you would use this:
      	if state != ActivityState.active {
            //Do something here
        }
    }
}

// Example output 1 - LA ended, but still visible
// LA state update: active

/* State can be equal to 4 possible values on the ActivityState enum
active, dismissed, ended, and stale
*/

​

The API returned a 400 with an error message stating I’m over the subscriber limit. What do I do?

If your push subscriber count is greater than the Push Subscribers for your plan, please upgrade your account to the next plan, or reach out to support@onesignal.com. For the latest plan details, please see here.

​

How do I avoid sending both push and Live Activities?

Your application may already send a series of Push Notifications, where your designed Live Activity replaces the need for these Push Notifications. For example, if you send score updates via Push, you could replace this through a Live Activity.

In order to ensure your users are not getting too many messages, we recommend as your user opts in for a Live Activity, to add a data tag. By adding this data tag, you can exclude users with this data tag from push messages that may contain the same or similar content. Read more on Data Tags and Segments.

​

Troubleshooting

​

No recipients

In order for your users to be found when trying to start or update a Live Activity, you must ensure that the activity type, widget, and cURL request all have matching values.

1. Check the path parameters in your request to ensure that you are sending a correctly formatted request to the server. The App ID must match your App ID used in the OneSignal.Initialize method and the activity type must match that of the type you’ve defined in your Live Activity file.

2. In the body of the Push To Start API request, you should have the following parameters:

• event: "start"
• event_updates: The dynamic data you have defined in your struct under activity type and that is used in your widget. Ensure the letter casing and variables all match between the request, the type, and the widget.
• event_attributes: Static data follows the same logic as Event Updates and must include all variables in use, and must match across all parts of the live activity and the request
• activity_id: This will assign an ID to the widget and is what will be used to update the activity after it has been launched on the user’s device.
• name: The Live Activity Name.
• contents: The message content required for sending push.
• headings: The message heading required for sending push.
• A targeting parameter like included_segments. Available options.

​

Activity sent, but not received

1. Ensure that the request is formatted correctly. If any fields that are used in the Widget are omitted, the activity may not launch or update as expected.

2. In your API request, determine the priority level you are setting. If you are setting this to 10 (highest priority), try lowering it to 5 and test again. Apple will throttle requests being sent out too frequently per their own internal rate limits.

If your use case relies on more frequent updates, add the key NSSupportsLiveActivitiesFrequentUpdates to your Info.plist as a Boolean type set to YES as directed in Apple’s Developer Docs. User will be presented with a dialog when the Live Activity exceeds its push budget, and if they allow the Live Activity to continue, the budget will automatically be increased for a seamless user experience.