Add trial notifications to your subscriptions
A trial that converts without warning feels like a trap, even when the terms were clear at signup. A short, honest reminder sequence — sent before conversion — lets people decide with full information, cuts surprise-charge refunds and bad reviews, and turns a potentially adversarial moment into a trust-building one. This guide explains how to plan that sequence and implement it two ways in React Native: on-device local notifications, or server-driven remote notifications triggered by subscription webhooks.
Why remind people before a trial converts?
Free trials convert well, but a forgotten trial that suddenly charges feels deceptive. The user refunds, complains and may avoid subscription apps altogether. A reminder one or two days before conversion reframes the charge as an informed choice: people who would have cancelled anyway do so calmly, and people who stay do so knowingly. That transparency is the retention mechanism, not a dark pattern.
Plan a three-message reminder sequence
Keep the sequence light but complete. First, on day one, point to a feature the user has not tried yet — this confirms notifications work and helps them reach an early moment of value. Second, two days before the end, give a plain heads-up that the trial is still running and will expire soon; expect some cancellations here and treat them as a chance to offer a win-back. Third, on the morning of the final day, state the choice plainly: staying keeps access, cancelling is available anytime. Three touchpoints remove uncertainty without nagging.
Local notifications: simple, device-bound
Local notifications keep all logic on the device. At trial start you read the expiry from the active entitlement and schedule reminders relative to that date. This is the fastest path — little code, no backend — but the schedule only refreshes when the app is opened. A cancellation made in the App Store settings, or a switch to a non-trial plan, will not unschedule reminders until the next open. Local delivery also fails when the device is powered off, exact-time delivery is limited on some Android phones, and adding email alongside push is awkward.
Remote notifications: server-driven and more reliable
Remote notifications move the logic to a small backend that listens for subscription webhook events and schedules or cancels reminders accordingly. Setup takes more effort, but reliability is higher: content can change without shipping an app update, push and email can run together, and cancellation takes effect immediately without requiring an app open. The backend can stay minimal — one endpoint that receives webhooks, stores scheduled reminders, and a periodic job that sends what is due. On the client, your only job is storing the user's push token, which the subscription SDK can help manage through its attributes, readable later via API or webhooks.
Choosing a notification package
React Native ships without notifications, so you must add a library. Three options support both local and remote delivery: Expo Notifications, a natural fit for Expo projects and used in the accompanying examples; react-native-notifications from Wix, maintained for over a decade and feature-complete; and Notifee, which is especially strong for rich notifications with images, custom sounds and interactivity. Pick based on your project setup and how rich your messages need to be.
Local implementation: schedule, then unschedule
For the local path, first define a trial schedule object: three reminders, each with an identifier, timing relative to trial start or end, and title and body copy. The example schedule uses six hours after start for the activation nudge, two days before end for the mid-trial reminder, and the morning of the last day for the final alert. Next, at subscription time, fetch customer info, confirm the subscription is in a trial period, will renew, and is not a sandbox purchase, then schedule each reminder whose trigger time is still in the future. Finally, handle subscription changes: if an entitlement that was previously active is no longer in a trial — converted, cancelled or expired — cancel all pending reminders, while leaving fresh users with no entitlement untouched. The protected modules code0001, code0002 and code0003 contain the exact schedule, scheduling and cancellation implementations.
Remote implementation: tokens, backend, webhooks
For the remote path, start on the client by requesting permission, obtaining the device push token and storing it through the SDK, plus an optional Expo token stored as a custom attribute. That completes the client work. On the server, build an endpoint that authenticates incoming webhook requests, unwraps the event payload, and acts on the fields that matter: period type to detect trials, purchase and expiration timestamps to compute timing, and subscriber attributes to retrieve the push token. Schedule the three reminders when a trial purchase begins — in the example, the first reminder goes six hours after purchase if bought before noon, otherwise the next day, with the final reminder moved to the previous evening if the trial expires in the morning. Cancel pending reminders on unsubscribe cancellation, expiration, or successful trial conversion. A scheduled hourly job then sends notifications that are due. The protected modules code0004 and code0005 contain the exact token registration and backend handler.
Enable webhooks in the dashboard
To connect the backend, open the subscription dashboard, go to Integrations, choose Webhooks under Core Tools, and add a webhook whose delivery URL points to your backend endpoint. Set the authorization header to match the secret configured on your backend, and enable at least the initial purchase, cancellation, expiration and trial-converted event types so every state change that should schedule or cancel reminders reaches your endpoint.
Wrap-up
Trial notifications are a low-effort, high-trust improvement: you already have purchase and expiry dates, and a small amount of client code is enough to start. Launch with the three-message sequence, keep the wording honest and user-centred, then iterate on timing and copy based on how people respond. The protected code modules listed with this page carry the exact implementations to adapt.
| Local notifications | Remote notifications | |
|---|---|---|
| Where logic lives | On the device, scheduled at trial start | On a small backend, driven by webhook events |
| Setup effort | Little code, no backend to maintain | More setup: endpoint, storage, periodic sender |
| Updates without app open | No — schedule refreshes only when app opens | Yes — cancellations and changes apply immediately |
| Works if app was killed | No | Yes |
| Device powered off | Delivery fails | Server-side scheduling unaffected |
| Content changes | Require an app update | Can change without an app update |
| Other channels (e.g. email) | Harder to orchestrate | Can combine push and email |
Comparison of the two approaches described in the guide; reliability and control trade-offs as stated there.
| Reminder | Timing | Purpose |
|---|---|---|
| Activation nudge | Same day as trial start | Highlight an untried feature; confirm notifications work |
| Mid-trial reminder | Two days before trial ends | Warn that expiry is near; surface cancellations early |
| Trial-ending alert | Morning of the last day | State plainly: stay to keep access, or cancel anytime |
Recommended three-notification pattern; exact offsets in the example schedule are six hours after start, two days before end, and morning of the last day.
Frequently asked questions
Should I use local or remote notifications for trial reminders?
Local notifications are scheduled on the device when the trial starts, need no server, and are simpler, but they only update when the app is opened and can fail if the device is off. Remote notifications are driven server-side from webhook events, work even if the app was killed, allow content changes without an app update and multi-channel delivery, and can be cancelled immediately, but require a small backend and token storage.
What trial reminder sequence works best?
Use a three-message pattern: an activation nudge on day one highlighting an untried feature, a mid-trial reminder two days before the end, and a final alert on the morning of the last day stating clearly that access continues if the user stays on the plan or they can cancel anytime.
How do I store push tokens for remote trial reminders?
On the client, request permission, obtain the device push token and store it through the subscription SDK's push-token and attributes APIs, including reserved token attributes and an optional Expo token. The server then reads the token from subscriber attributes in webhook payloads to dispatch reminders.