
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.
How consent works
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
invalidautomatically. - 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 itswww 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:
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 thedata-sequenzy-push attribute:
subscribeToPush() from a click. The
tracking snippet loads the SDK asynchronously, so push methods only work after
the page’s load event:
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 callssequenzy.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
.p8auth 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.
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:What your app receives
Each notification carries asequenzy object: in the APNs payload next to
aps, and as string fields in the FCM data map.
- Open
urlwhen 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 setsmutable-contentwhenever an image is present. - To report opens, POST to
eventsUrlfrom the app:
"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.configureat launch andSequenzy.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.
1. Add a widget extension
- 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.swiftand<Name>Bundle.swift, which you change in step 4, and a Home Screen widget in<Name>.swift. - 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.
- Select your app target, open its Info tab, and add Supports Live
Activities (
NSSupportsLiveActivities) with the valueYES. - Check that the app target has the Push Notifications capability under Signing & Capabilities. It does if your notifications already work.
2. Link SequenzyLiveActivities to both targets
AddSequenzyLiveActivities 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.
3. Describe your activity
Add a new Swift file, for exampleDeliveryAttributes.swift, and under
Target Membership in the File inspector tick both the app and the widget
extension. Your attributes adopt SequenzyLiveActivityAttributes:
DeliveryAttributes.swift
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
<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
Inapplication(_: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
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 callsSequenzy.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 thetransactional:send scope (the
Transactional only preset under Settings → API Keys & SMTP):
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.
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. PasssegmentId, 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,tagandbroadcastare then ignored. - Starts for an audience and broadcasts also need
campaigns:sendon the API key, since they reach many people at once. - The CLI takes
--segment,--listor--tagonstart, and--broadcastonupdateandend.
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, withpushType: .token and your id in the
sequenzy attribute:
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 theios/ 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 (
emailorsubscriberId), unless it is for an audience. Any install of your app can report a token under anyactivityId, so Sequenzy only sends to tokens linked to that contact. Tokens link once the app callsidentify, 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. Datefields incontentStateandattributesdecode as seconds since 2001-01-01, not Unix time, unless your structs decode them differently.staleDateanddismissalDateare Unix seconds or ISO dates; milliseconds are rejected.- Each request returns
tokenCount.0means 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; addNSSupportsLiveActivitiesFrequentUpdatestoInfo.plistif 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
tokenCountis0on start: the device has not reported, or it is not linked to the contact. Check that the app callsidentifywith an identity token after sign-in, and that the iPhone runs iOS 17.2 or later.tokenCountis0on update or end: the activity’s update token has not arrived yet. Wait a few seconds after the start, and check thatobserveLiveActivitiesruns 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.swiftor<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:
observeLiveActivitiesis 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),activityTypeis 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.
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 as5 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.
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.configureinApplication.onCreate, uses Firebase Messaging, and callsSequenzy.identify(with an identity token) after sign-in.
1. Draw it
InApplication.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:
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.
shortCriticalTextshows 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(orstatus) andprogresskeys ofcontentState.
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)
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:- 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.
- Update it. It changes in place without alerting again.
- Swipe your app away from the recent apps and start another activity. Android starts your app in the background to draw it.
- End it. It becomes a regular notification that people can dismiss.
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 analert; 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
updateandenddon’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. staleDateis passed to your renderer asactivity.staleDateMillis; Android has no stale state of its own.relevanceScoreis 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 orflutter_local_notifications) draws it.
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.androidis0on start: the device has not reported, or is not linked to the contact. Check thatobserveruns inApplication.onCreate, that the app registered its FCM token with Sequenzy, and that it callsidentifyafter sign-in.- FCM accepted it but nothing appears: the app can’t post notifications
(the permission is off), or the renderer returned
nullor threw. - It shows, but not promoted on Android 16: the person turned Live Updates
off for your app.
SequenzyLiveUpdates.canPostPromotedNotifications(context)tells you, andSequenzyLiveUpdates.promotionSettingsIntent(context)opens the setting. - The last push says
device_inactiveorUNREGISTERED: 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
|thereis 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.
- The contact’s language attribute (Settings > Localization), when it names one of your languages.
- 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.
- Your fallback language.
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
OpenCampaigns, 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
timezoneattribute. 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.
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 inlocalizations. - 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-optimizationfor delivery timing),push translate, andpush 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.
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.