Skip to main content
Push notifications reach contacts on their devices even when they are not reading email. Sequenzy sends three kinds of push from one place:
Sequenzy Push settings with callouts showing the platform switcher and the Turn on web push button
Push is unlimited on every plan, including Free. Sending a push does not use email credits. Switching from another provider? Import your existing iOS and Android devices. A device receives push only after the person allowed notifications in their browser or in your app. Each allowed browser or app install is a device linked to a contact. Push is independent of email: a contact who unsubscribed from email still receives push on their devices, and a contact with no email address can still be reached. A device stops receiving push when:
  • The person unsubscribes the browser or you unregister the device.
  • The push service reports the token as expired or uninstalled. Sequenzy marks the device invalid automatically.
  • The contact is signed out on a shared browser (see Linking browsers to contacts).

Web push

Set it up with an AI coding tool

In Settings → Push → Web, choose Copy prompt. The prompt contains your site key, the service worker file, the subscribe button and the sign-in steps, with your values filled in. Paste it into Cursor, Claude Code, or Codex, or send it to your developer. The iOS and Android tabs have the same button for your apps.

1. Turn on web push

Go to Settings → Push → Web and turn on web push. Sequenzy generates your workspace’s VAPID keys. If you have no web tracking key yet and your company website is set, Sequenzy also creates a site key allowed for that website (and its www or apex twin), so the snippet is ready to paste. Turning web push on through the API, CLI, or MCP does the same and returns the key and snippet. Turning web push off later keeps the keys, so existing subscribers keep working when you turn it back on. Notifications use your company logo as the icon. Change it under Notification icon if you want a different one.

2. Install the tracking snippet

Push uses the same browser SDK and publishable key as web tracking. If the snippet is already on your site, skip this step.

3. Add the service worker file

Browsers only run service workers from the site that asks for permission. Serve a file at /sequenzy-sw.js on your domain containing:
The settings page has a Download sequenzy-sw.js button. Put the file in the folder served from your site root, such as public/ in Next.js, Vite, Astro, or Nuxt. The file never needs updating: the hosted worker shows Sequenzy notifications, reports when they are displayed and clicked, and opens the link. It ignores pushes from other senders. If your site already has a service worker at its root (for example a PWA or Workbox setup), add the importScripts line to that worker instead of serving /sequenzy-sw.js. A site has one service worker per scope, so the SDK subscribes through the worker that already controls your pages, and pushes arrive there.

4. Add a subscribe button

Browsers block permission prompts that the visitor did not trigger, and a declined prompt cannot be shown again. Add a button with the data-sequenzy-push attribute:
No script is needed. Once the SDK loads, it shows the button only in browsers that can subscribe, asks for permission when it is clicked, and hides it again once the browser is subscribed, blocked, or web push is off. Buttons rendered later by a single-page app work too. To build your own flow instead, call subscribeToPush() from a click. The tracking snippet loads the SDK asynchronously, so push methods only work after the page’s load event:
With a bundler:
isPushSupported() and getPushPermission() let you decide whether to show the button at all. Pass { serviceWorkerPath: "/path/to/sw.js" } if your worker lives somewhere other than /sequenzy-sw.js.

Linking browsers to contacts

A browser that subscribes before the visitor signs in is anonymous and does not receive campaigns yet. When your site calls sequenzy.identify(email, identityToken) (see web tracking), the SDK re-registers the subscription with that identity and the device is linked to the contact. The SDK also refreshes the registration once a day and whenever the browser’s push endpoint changes. When a visitor signs out, call sequenzy.reset(). The SDK unregisters the browser and drops the contact link, so the next person on a shared computer does not receive the previous person’s notifications.

iOS and Android apps

Credentials

In the iOS and Android tabs of Settings → Push, pick what your app is built with (Swift, Kotlin, React Native, Flutter, or No SDK when your backend registers device tokens). Copy prompt gives your AI coding tool or developer the app-side steps with your bundle ID or Firebase project filled in. Then add credentials:
  • iOS: upload the .p8 auth key from Apple Developer (Keys, with Apple Push Notifications service enabled) and enter the key ID, team ID, and bundle ID. Choose Sandbox for Xcode development builds and Production for App Store and TestFlight builds.
  • Android: upload the service account JSON from Firebase project settings (Service accounts, Generate new private key). The account needs the Firebase Cloud Messaging API Admin role.
Keys are encrypted and never shown again. If Apple or Google rejects them, the settings page shows the error until a send succeeds or you replace the key.

Register device tokens

The Mobile SDKs register the token from your app, link the device to the contact on sign-in, unregister it on sign-out, show images, and report deliveries and opens. To register from your backend instead, send the token from APNs or Firebase Messaging to your server and call Register a push device:
Register the token again whenever the app receives a new one; the same token is updated rather than duplicated, and moves to the contact you pass. When a person signs out of your app, call Unsubscribe a push device. Each contact keeps up to 20 active devices; older ones are retired automatically.

What your app receives

Each notification carries a sequenzy object: in the APNs payload next to aps, and as string fields in the FCM data map.
  • Open url when the person taps the notification. It can be an https link or one of your app’s deep links.
  • iOS shows images only through a Notification Service Extension that downloads imageUrl. Sequenzy sets mutable-content whenever an image is present.
  • To report opens, POST to eventsUrl from the app:
Use "type": "delivered" from a Notification Service Extension (iOS) or when your Android app handles the message, to count displays. The token authenticates the report, so no API key belongs in your app.

Live Activities

Live Activities show live progress, such as a delivery, a ride, or a game score, on the Lock Screen and in the Dynamic Island. Your backend starts, updates and ends them through Sequenzy, which delivers them over APNs with the same .p8 key as your notifications. They work without notification permission. On Android, the same start, update and end calls drive Android Live Updates.

Before you start

  • Your APNs key is saved in Settings → Push → iOS (see Credentials).
  • Your app uses the Sequenzy iOS SDK: it calls Sequenzy.configure at launch and Sequenzy.identify (with an identity token) after sign-in. If you added the Sequenzy package before it had Live Activities, update it with File → Packages → Update to Latest Package Versions.
  • Live Activities need iOS 16.1 or later on the iPhone, and starting one from your backend needs iOS 17.2 or later. Your app can keep supporting older iOS versions; the code below checks the version. On iOS 16.1 to 17.1 your app starts the activity and your backend updates and ends it.
In Settings → Push → iOS, the Live Activities step has a Copy prompt button for coding agents (the agent writes the code and lists what to click in Xcode), and Do it by hand shows the same steps with copy buttons. Once devices report, the step shows each activity type and lets you send a test.

1. Add a widget extension

  1. In Xcode, choose File → New → Target → Widget Extension. Tick Include Live Activity, leave Include Configuration App Intent and Include Control unticked, and finish. Xcode creates <Name>LiveActivity.swift and <Name>Bundle.swift, which you change in step 4, and a Home Screen widget in <Name>.swift.
  2. Select the new extension target and, in its General tab, set Minimum Deployments to iOS 16.1, or to your app’s minimum if that is higher. Xcode sets it to the newest iOS, and an iPhone on an older version then never shows the activity. The generated Home Screen widget needs iOS 17, so step 4 removes it.
  3. Select your app target, open its Info tab, and add Supports Live Activities (NSSupportsLiveActivities) with the value YES.
  4. Check that the app target has the Push Notifications capability under Signing & Capabilities. It does if your notifications already work.
Add SequenzyLiveActivities from the Sequenzy package to both targets. Click + under:
  • the app target’s General → Frameworks, Libraries, and Embedded Content.
  • the widget extension’s General → Frameworks and Libraries.
The widget extension needs it because the attributes type you write next is shared by both. It has no UIKit, so extensions can link it. If it is not in the list, update the package (see Before you start).

3. Describe your activity

Add a new Swift file, for example DeliveryAttributes.swift, and under Target Membership in the File inspector tick both the app and the widget extension. Your attributes adopt SequenzyLiveActivityAttributes:
DeliveryAttributes.swift
Your backend sends contentState and attributes as JSON whose keys are these property names, so {"status":"preparing","minutesAway":30} fills ContentState. Every field must be there with the right type, and every field of the attributes except sequenzy must be sent on start: if anything is missing, iOS drops the push without an error.

4. Draw it

Replace everything in the <Name>LiveActivity.swift file that Xcode generated, including its sample attributes struct and previews, with a widget for your type:
DeliveryLiveActivity.swift
Then, in <Name>Bundle.swift, list only DeliveryLiveActivity(), and delete the generated Home Screen widget file <Name>.swift (it needs iOS 17 and would not build with an older minimum). If you want a Home Screen widget too, keep it and mark it @available(iOS 17.0, *) instead. A widget that is not in the bundle never shows.

5. Observe the activity type at launch

In application(_:didFinishLaunchingWithOptions:), right after Sequenzy.configure, call observeLiveActivities once for each attributes type. With SwiftUI, do this in an AppDelegate added with @UIApplicationDelegateAdaptor, not in a view: iOS launches your app in the background when a push starts an activity, and the SDK reports the new activity from there.
AppDelegate.swift
That is all the app code. The SDK reports a push-to-start token for the type (iOS 17.2+) and an update token for every running activity, whether your backend or the app started it. It links them to the contact on identify, tells Sequenzy when an activity ends or is dismissed, and on reset ends the running activities on the device and unlinks the tokens, so the next person does not see the previous person’s activity.

6. Check that your iPhone reports

Run the app on an iPhone with iOS 17.2 or later and sign in, so the app calls Sequenzy.identify. In Settings → Push → iOS, the Live Activities step lists DeliveryAttributes with one device that can start it.

7. Send a test

Lock the iPhone first, or go to the Home Screen: while your app is open, iOS does not show its own activity in the Dynamic Island. The quickest test is in the dashboard. Under Settings → Push → iOS, the Live Activities step has Send a test once a device reports: enter the email you signed in with and choose Start test. It fills in the example’s attributes and content state, then shows Apple’s answer and whether the iPhone reported the running activity. End test removes it. If Apple accepts the start but the iPhone never reports it, iOS could not use the payload: see If a Live Activity does not show. From a terminal, start one with the CLI, using the email you signed in with and an API key that has the transactional:send scope (the Transactional only preset under Settings → API Keys & SMTP):
The activity appears with the alert. A few seconds later the app reports its update token, and you can update and end it:

8. Start, update and end from your backend

Your backend sends the same requests. activityType is the Swift type name. activityId is your own id for this activity, such as an order number: you use it to update and end the activity, and on start Sequenzy adds it to attributes.sequenzy for you.
The MCP tools (start_live_activity, update_live_activity, end_live_activity) take the same fields. Start, update and end need an API key with transactional:send; listing tokens needs subscribers:read.

One activity for a segment, list or tag

For a game, a live event or a flash sale that many people follow, start one activity for everyone in a segment, list or tag. Pass segmentId, listId or tag instead of a contact, and a shared activityId. Then update and end it with "broadcast": true: each update goes to every device running it, iOS and Android, in one request.
  • It reaches contacts the app signed in with Sequenzy.identify, whatever their email status, as push campaigns do. The response counts devices (tokenCount) and contacts (contactCount).
  • One start reaches up to 100,000 devices. Split a larger audience into segments with their own activityId.
  • A large start takes a few minutes to reach every device. Send the end after that: an end sent while the start is still going out misses the devices it has not reached yet.
  • A broadcast reaches every signed-in device running the activityId, of any contact, including copies your app started itself with that id, at most 10 devices per contact. Use it only for shared content, never for a per-person id like an order.
  • A request that names a contact goes to that contact: segmentId, listId, tag and broadcast are then ignored.
  • Starts for an audience and broadcasts also need campaigns:send on the API key, since they reach many people at once.
  • The CLI takes --segment, --list or --tag on start, and --broadcast on update and end.

Activities your app starts

To start an activity in the app and update it from your backend, request it while the app is in the foreground, with pushType: .token and your id in the sequenzy attribute:
The SDK reports its update token, and your backend updates and ends it with activityId: "order-1234". On iOS 16.1, use the older request(attributes:contentState:pushType:).

React Native and Flutter

The widget and attributes are Swift in every app. In the ios/ project, add the Swift package https://github.com/Sequenzy/sequenzy-swift and link only SequenzyLiveActivities, then do steps 1 to 4. Instead of step 5, write a small native module that passes the ActivityKit tokens to Sequenzy.registerLiveActivityToken and Sequenzy.liveActivityEnded, and end the running activities on sign-out before Sequenzy.reset(). See Mobile SDKs for the code.

How delivery works

  • Every start, update and end names the contact (email or subscriberId), unless it is for an audience. Any install of your app can report a token under any activityId, so Sequenzy only sends to tokens linked to that contact. Tokens link once the app calls identify, so an activity the app starts before sign-in can be updated only after it.
  • End always carries the final contentState, as Apple’s end payloads do.
  • Date fields in contentState and attributes decode as seconds since 2001-01-01, not Unix time, unless your structs decode them differently. staleDate and dismissalDate are Unix seconds or ISO dates; milliseconds are rejected.
  • Each request returns tokenCount. 0 means nothing was sent: no device linked to the contact can start this type, or the activity has not reported an update token yet.
  • Updates carry the time of your request, and iOS ignores a push older than the last one it applied, so a retried or late update never replaces newer content, as long as you send at most one push per activity per second (the timestamp has one-second resolution). A start that you send twice starts two activities.
  • Use "priority": "low" for frequent updates that can wait. Apple limits how many high-priority updates an app gets; add NSSupportsLiveActivitiesFrequentUpdates to Info.plist if you need more.
  • The whole APNs payload must fit in 4 KB.
  • List Live Activity tokens (or sequenzy push live-activities list --email ...) shows which devices can start each type, the running activities, and the last APNs result for each token.

If a Live Activity does not show

  • tokenCount is 0 on start: the device has not reported, or it is not linked to the contact. Check that the app calls identify with an identity token after sign-in, and that the iPhone runs iOS 17.2 or later.
  • tokenCount is 0 on update or end: the activity’s update token has not arrived yet. Wait a few seconds after the start, and check that observeLiveActivities runs at launch.
  • The widget extension does not build (for example “containerBackground(_:for:) is only available in iOS 17.0 or newer”): delete the generated <Name>.swift, AppIntent.swift or <Name>Control.swift, or mark them @available(iOS 17.0, *) (controls need iOS 18), and list only your widgets in <Name>Bundle.swift.
  • The type never appears in Settings: observeLiveActivities is not running at launch, or the iPhone runs an iOS older than 17.2 (the type then shows only while an activity runs).
  • APNs accepted it but nothing appears: lock the iPhone and try again. If it still does not show, the JSON does not match your Swift structs (a missing key, a wrong type, or a Unix timestamp in a Date), activityType is not the exact Swift type name, the widget is not in your widget bundle, the widget extension’s minimum iOS is newer than the iPhone, or Live Activities are turned off in the iPhone’s Settings for your app.
  • The last push says TopicDisallowed: the bundle ID in Settings → Push → iOS does not match the app, the App ID does not have Push Notifications enabled, or the APNs key is restricted to other apps or environments.
  • The last push says BadDeviceToken: the APNs environment does not match the build. Builds run from Xcode need Sandbox; TestFlight and App Store builds need Production. After you fix it, relaunch the app so it reports a new token.
Find the last push result for each token with sequenzy push live-activities list --email ....

Android Live Updates

Android Live Updates are the Android side of Live Activities: a delivery, a ride or a score that your backend starts, updates and ends with the same start, update and end calls. One call reaches the contact’s iPhones and Android devices at once, when both apps use the same activity type name. How they look depends on the Android version:
  • Android 16 and later: a Live Update with a segmented progress bar and milestones (ProgressStyle). From the Android 16 update that added promotion (API 36.1), it is promoted: it sits at the top of the notification shade and on the lock screen, can’t be collapsed, and shows a chip in the status bar with a short text (such as 5 min) or a countdown. On the first Android 16 release it shows as an ongoing notification with that progress bar. People can turn promotion off for your app in the system settings; the notification is then shown as a regular ongoing notification.
  • Earlier Android versions: an ongoing notification, with a plain progress bar when you send progress, that updates in place. There is no status bar chip, so the chip text is shown as the notification’s subtext. Segment colors and milestones are not shown.
Sequenzy sends each start, update and end as an FCM data message, and the Sequenzy Android SDK draws the notification, also while your app is in the background. Unlike iOS, they need notification permission (Android 13+).

Before you start

  • Your Firebase service account key is saved in Settings → Push → Android (see Credentials).
  • Your app uses the Sequenzy Android SDK for push: it calls Sequenzy.configure in Application.onCreate, uses Firebase Messaging, and calls Sequenzy.identify (with an identity token) after sign-in.
In Settings → Push → Android, the Live Updates step has a Copy prompt button for coding agents and Do it by hand for the same steps. Once devices report, it shows each activity type and lets you send a test.

1. Draw it

In Application.onCreate, right after Sequenzy.configure, observe each activity type. Use the name of your iOS ActivityAttributes type. It must run at launch, because Android starts your app in the background when a push starts an activity:
The renderer receives the start’s attributes and the latest contentState with the keys your backend sends: the same JSON as on iOS. LiveUpdateContent also takes segments and points for the progress bar, countdownToMillis for a countdown, largeIcon, color and a url to open on tap. Keep these in mind:
  • A title is required: Android promotes only notifications with one.
  • shortCriticalText shows in full up to 7 characters.
  • Android doesn’t promote notifications with custom views or a colorized background, so the SDK uses neither.
  • Without a renderer, the SDK shows the title, body (or status) and progress keys of contentState.
The SDK adds the POST_PROMOTED_NOTIFICATIONS permission to your manifest. If your app has its own FirebaseMessagingService, call SequenzyMessagingService.handleMessage(this, message) from onMessageReceived.

2. Start one from your app (optional)

Your backend then updates and ends it by its activityId. SequenzyLiveUpdates.update and SequenzyLiveUpdates.end change it from the app.

3. Send a test

Run the app, allow notifications and sign in. The Live Updates step under Settings → Push → Android then lists your activity type and has Send a test. You can also use the same CLI command as for Live Activities. Check it the way people use your app, on a phone or an emulator with Google Play services:
  1. Open another app, then start an activity. It appears with its status bar chip on Android 16, or as an ongoing notification on earlier versions.
  2. Update it. It changes in place without alerting again.
  3. Swipe your app away from the recent apps and start another activity. Android starts your app in the background to draw it.
  4. End it. It becomes a regular notification that people can dismiss.
Android delivers no FCM message, Live Update or notification, to an app that was force stopped in the system settings until it is opened again. On some phones, swiping an app away from the recent apps works like force stopping it.

How delivery works

  • Start, update and end reach every platform whose credentials are set, and the response counts devices per platform in platforms. A start always needs an alert; on Android it alerts the person once, like a notification. Later updates update the notification silently unless they carry an alert.
  • Pushes carry the time of your request, and the SDK ignores one that is not newer than the last one it applied, so a late or repeated update never replaces newer content. As on iOS, send at most one push per activity per second: the time has one-second resolution. Changes your app makes with update and end don’t count, so they never hide your backend’s next push.
  • While the device is offline, FCM keeps only the newest update for each activity, for up to four activities per device. Starts and ends are never dropped for a newer message. "priority": "low" sends an update at normal FCM priority, which a dozing device may receive later.
  • When FCM accepts a start, Sequenzy already knows the activity is running on that device, so an update right after the start reaches it.
  • An end shows the final content as a regular notification that the person can swipe away. It goes away at dismissalDate, or after four hours.
  • When the person swipes a Live Update away, the SDK tells Sequenzy, and later pushes for it are not sent. Sequenzy.reset() removes the running Live Updates on sign-out.
  • staleDate is passed to your renderer as activity.staleDateMillis; Android has no stale state of its own. relevanceScore is iOS only.
  • The FCM message must fit in 4 KB, like the APNs payload.
  • Starts for a segment, list or tag and broadcast updates reach Android devices the same way, with one request for both platforms.

React Native and Flutter

The JavaScript and Dart SDKs keep the Live Update state and report the tokens; your notification library (for example Notifee or flutter_local_notifications) draws it.
Call Sequenzy.liveUpdateDismissed(activityId) when the person swipes one away, and cancel the ids that the onLiveUpdatesRemoved config option reports after sign-out. In Flutter the calls are the same, and a decision to show has shouldShow. Firebase runs Flutter’s onBackgroundMessage handler in its own isolate, so call Sequenzy.configure in that handler before handleLiveUpdate; the app sees what it stored. In React Native on Hermes, install react-native-get-random-values so Live Update tokens come from a secure random source. Android 16 promotes the notification only when your library requests promotion (android.requestPromotedOngoing); otherwise it shows as an ongoing notification, as on earlier versions.

If a Live Update does not show

  • platforms.android is 0 on start: the device has not reported, or is not linked to the contact. Check that observe runs in Application.onCreate, that the app registered its FCM token with Sequenzy, and that it calls identify after sign-in.
  • FCM accepted it but nothing appears: the app can’t post notifications (the permission is off), or the renderer returned null or threw.
  • It shows, but not promoted on Android 16: the person turned Live Updates off for your app. SequenzyLiveUpdates.canPostPromotedNotifications(context) tells you, and SequenzyLiveUpdates.promotionSettingsIntent(context) opens the setting.
  • The last push says device_inactive or UNREGISTERED: the app’s FCM token changed or the app was removed. The app links its Live Update tokens again when it registers its new FCM token.
  • The last push says SENDER_ID_MISMATCH: the app’s FCM token belongs to another Firebase project than the service account in push settings.

Writing a push

Merge tags work in the title, message, and link, for example Hi {{FIRST_NAME|there}}. If a merged message grows past the 4 KB limit push services accept, Sequenzy shortens the message rather than failing the send.

Languages

Push uses the languages from Settings > Localization, the same list as email localization. Once you have a second language, the push composer, in campaigns and in sequence push steps, shows a language picker above the title.
  • Pick a language and write its title and message, or choose Translate to translate every language that has no version yet with AI. Merge tags stay exactly as written, and their fallback text such as |there is translated.
  • A language can have its own link and image. Leave them empty to use the main ones. The icon and platforms are shared by every language.
  • If you change the main title or message after a language was translated, that language shows Outdated. It still sends as it is until you update it. Translate refreshes outdated AI translations but never replaces a version you wrote; use Translate again with AI in the language’s menu for that.
  • Languages without a version get the main title and message.
Each device gets the version for, in order:
  1. The contact’s language attribute (Settings > Localization), when it names one of your languages.
  2. The device’s language, which every Sequenzy SDK reports when it registers the device. This is per device, so a contact with a German phone and an English browser gets each in its own language.
  3. Your fallback language.
Language matching works like email: de-AT matches de, and pt-PT matches pt-BR when that is the only Portuguese. A version for a language you later remove from Settings > Localization is kept but not sent. The title and message are always the main language’s. Changing your main language in Settings > Localization does not swap a push’s versions, so rewrite or retranslate existing pushes after changing it. Adding a language in Settings > Localization translates your sequence push steps into it, next to your emails, and each language there shows how many pushes have it. Translate next to a language retries the missing ones. Push steps in sequences defined in code are left alone, since your next definition push would replace them; add their localizations in the definition. Push campaigns send once, so translate them in the campaign.

Push campaigns

Open Campaigns, switch to Push, and choose New Push Campaign. Write the notification, pick the audience, then send now or schedule it. Only contacts with an active device on a selected platform receive the campaign; the recipients step shows how many that is. The audience is re-evaluated when delivery starts, so contacts who subscribe before a scheduled send are included. A contact receives one notification per active device. If a push service is temporarily unavailable, Sequenzy retries only the devices that have not accepted the message yet.

Delivery timing

On the schedule step, choose how each contact’s notification is timed:
  • All at once: everyone gets it when delivery starts.
  • Optimal time: each contact gets it at the hour they tap your pushes most, within 12 hours of the start (the API, CLI and MCP can set 1 to 24 hours). A contact needs at least 3 taps in the last 90 days. Contacts without enough push history use the hour they open your emails most, then the hour your pushes are tapped most across the workspace (once it has at least 20 taps), then the start time.
  • Contact’s local time: needs a schedule. Each contact gets the scheduled wall-clock time in their own timezone, for example 9:00 for everyone. The timezone comes from the contact’s most recently seen device, which the mobile SDKs and the web SDK report when the device registers, and otherwise from the contact’s timezone attribute. Contacts whose 9:00 has already passed when delivery starts get it right away, and contacts with no known timezone get it at the scheduled time.
Local-time delivery starts where the scheduled time first occurs (UTC+14), so a campaign can stay Sending for about 26 hours until the last timezone is delivered. Stopping it in the meantime skips every notification that has not gone out yet. The audience is read when delivery starts, so contacts who join it after that miss the campaign even if their local time has not come yet. Push campaigns have no spread option: pushes are not rate limited like email, and each timezone or hour group goes out together.

Segments

Push filters appear in the segment builder once any platform is set up: pushDevice (has an active device, on any platform or a specific one) and pushSent, pushDelivered, and pushClicked with a time window such as 30d or all. For example, combine pushDevice is ios with pushClicked is_not 30d to find iOS users who stopped opening your notifications. See segment filters. To find app users who haven’t allowed notifications, filter on the pushPermission attribute, which the mobile SDKs keep up to date, and show them a push primer.

Push steps in sequences

Add a Send Push step anywhere in a sequence. If the contact has no active device, the step is skipped by default; set If the contact has no push device to Exit the sequence to stop the journey instead. A workspace without push set up always skips the step, so a missing key never exits contacts in bulk. A sequence’s Working Hours hold push steps the same way they hold emails: a push due outside the window waits for the next allowed time.

Stats

Test sends are excluded from stats and from contact activity. Settings > Push also shows the app opt-in rate: the share of iOS and Android devices that allow notifications, from the permission each device’s SDK last reported, with counts of devices that allow them, turned them off and were not asked yet. Devices on SDK versions that don’t report permission are counted separately. The same numbers are in devices.permissions from Get Push Settings.

Test sends

Settings → Push → Send a test push sends to one device or to every device of a contact. You can send 200 test pushes per workspace in a rolling 24 hours.

API, CLI, and MCP

Everything in the dashboard is also available programmatically:
  • API: push settings, web, iOS, and Android credentials, devices, test sends, push campaigns, push translations, and Live Activities. Sequence steps use type: "push" in Create a sequence, with language versions in localizations.
  • CLI: sequenzy push settings, push web --enable, push ios set, push android set, push devices list|register|remove, push send-test, push campaigns estimate|create|update|translate|send|cancel|stats (with --in-recipient-timezone --scheduled-timezone <zone> or --send-time-optimization for delivery timing), push translate, and push live-activities list|start|update|end (start --segment|--list|--tag, update|end --broadcast).
  • MCP: get_push_settings, register_push_device, send_test_push, create_push_campaign, translate_push_campaign, translate_push_content, send_push_campaign, start_live_activity, update_live_activity, end_live_activity, and the other push tools listed in MCP.
Push campaign scopes reuse the campaign API key scopes (campaigns:read, campaigns:write, campaigns:send); test sends need campaigns:send; devices use subscribers:read and subscribers:write; Live Activity starts, updates and ends need transactional:send (plus campaigns:send for a segment, list or tag and for broadcasts), and listing their tokens needs subscribers:read; reading push settings needs account:read and changing credentials needs integrations:manage.

Browser endpoints

The web SDK calls these public endpoints with your publishable key and the allowed origins configured on it. You only need them if you build your own subscription flow: Send bodies as JSON with Content-Type: text/plain to avoid a CORS preflight.

Troubleshooting

  • Nobody is eligible: check Settings → Push for device counts. Browsers that subscribed before sign-in stay anonymous until your site calls identify.
  • iOS sends fail with “Key rejected”: the key ID, team ID, bundle ID, or environment does not match the app build. Development builds need Sandbox.
  • Android sends fail with “Key rejected”: the service account is missing the Firebase Cloud Messaging API Admin role, or the key was deleted in Google Cloud.
  • A browser never prompts: subscribeToPush() must run from a click, the page must be https, and the visitor must not have blocked notifications for your site.