Add a Tip Jar to a React Native App with Consumable Purchases
Some apps are too small to justify a subscription but still earn goodwill from the people who use them. A tip jar fits that gap: the user decides whether and how much to give, and each tip is a one-off purchase rather than a recurring commitment. This guide walks through a React Native implementation that starts with test products inside a billing platform, adds a dashboard-designed paywall, and finishes with the store-side configuration needed before release.
Why a tip jar suits lightweight apps
Timers, calculators, wallpapers and small games rarely persuade people to sign up for a monthly plan, and pushing a subscription into that kind of product tends to add friction instead of revenue. A tip jar reverses the pressure: support is optional, the amount is the user's choice, and nothing is locked away behind it.
Because tips are consumable purchases, the same product can be bought again and again. That is the key structural difference from a lifetime unlock or a subscription, and it is what makes a tip jar behave like a virtual coffee fund rather than a paywall gate.
The workflow below has four stages:
- Create consumable tip products and group them into an offering.
- Design the purchase screen in the dashboard paywall builder.
- Install the SDK packages and trigger the paywall from a button.
- Recreate the products in App Store Connect and Google Play, then swap in the production API key.
Choosing tip amounts and product IDs
The captured example uses three tiers — a small, medium and large tip — each with its own product identifier and price. The table below preserves those exact identifiers and prices as a starting reference; substitute your own app prefix and local pricing before launch. Keep the naming pattern consistent so the offering and the store listings stay easy to match later.
A useful rule when you extend the list: the product ID should describe the tier, not the price. If you later change a price in the store, the identifier still makes sense and no code has to change.
Stage 1 — Build with test products first
The billing platform's Test Store, as its documentation describes it, lets you define fake-but-functional products entirely inside the dashboard. They behave like real purchases: they return CustomerInfo, appear in dashboards and can trigger entitlements, but no App Store or Google Play configuration is required yet. That makes it the right place to settle pricing, copy and layout before touching store metadata.
Enable it from the Apps & providers section of the sidebar, click Create Test Store, and copy the testing API key — you will need it when configuring the SDK.
Then create each tip product from Product catalog → Products → + New Product, choosing Test Store as the store, entering the identifier, and setting a test price. Once all tiers exist, open Offerings, create one (for example, tips), and add every tip product to it. The offering is what the paywall will display.
Stage 2 — Design the paywall in the dashboard
Instead of hand-coding a purchase screen, you can build it in the dashboard paywall builder: layout, copy and the products shown are all configured there, and the SDK renders the result natively.
Go to Tools → Paywalls → + New Paywall, pick a template or start from a custom layout, select the Test Store products as paywall packages, then save and publish. The captured walkthrough reused the platform's virtual-currency sample paywall because it is already built around consumable products — a reasonable shortcut if you want a working layout quickly.
Stage 3 — Install the SDK and trigger the paywall
A React Native or Expo project needs two packages: the core purchase SDK and the UI package that renders paywalls and Customer Center. Install both with your package manager of choice.
Configure the SDK once at the root of the app — in an Expo Router project that means the root layout file. Use the Test Store API key while you are still iterating.
One environment detail matters a lot here. In Expo Go the SDK runs in Browser Mode, which means native paywalls cannot be displayed and real purchases cannot be made. To render the paywall you need a development build so the native code is present; running the iOS build from the command line produces that build.
With the SDK initialized, a single button press can open the paywall modal. The captured example wires a “Tip me” button to the paywall presenter, and the resulting screen matches whatever was published in the dashboard. In the Test Store you can simulate both a successful and a failed purchase, which is a convenient way to check what happens after a tip completes — for instance, routing to a thank-you screen.
Stage 4 — Move from test products to real stores
A passing simulator run is not the same as a working production purchase. Before release, recreate the products in the real stores and confirm that identifiers, pricing and configuration all behave as expected.
On iOS, the app must exist in App Store Connect with its bundle ID registered, and the billing platform needs permission to communicate with App Store Connect. After that, products can be created from the dashboard with App Store selected as the store; the dashboard prompts you to authorize creation of the matching product. Pricing, availability and screenshots still have to be completed in App Store Connect itself.
On Android, the app must already exist in the Play Console under the correct package name. Connecting the two requires Google Play Service Credentials so the platform can manage products and validate purchases; the captured walkthrough notes that activation of those credentials can take up to 36 hours. Once active, products can be created from the dashboard.
Finally, replace the Test Store API key with the App Store or Play key from the API Keys section, and build for a physical device rather than a simulator.
Pre-launch checklist
- Every tip tier has a stable, tier-based product ID.
- All tip products are attached to a single offering.
- The paywall is published and shows the intended packages.
- The app runs in a development build, not Expo Go, when testing the paywall.
- A successful test purchase and a cancelled test purchase both behave sensibly.
- Real-store products exist with matching identifiers and finalized pricing.
- The production API key has replaced the Test Store key.
- The release build has been tried on a physical device.
Frequently asked questions
Why use consumable purchases for a tip jar instead of a subscription?
Consumables can be bought repeatedly, so a user can tip once, twice or never. A subscription implies ongoing entitlement and commitment, which is the opposite of the low-pressure intent behind a tip jar.
Can I launch with Test Store products?
No. The Test Store is for local iteration and returns realistic purchase data without any store configuration, but production purchases must be backed by products created in App Store Connect and Google Play. Test in the real store environments before release.
Why doesn't the paywall appear in Expo Go?
Expo Go runs the SDK in Browser Mode, which cannot display native paywalls or complete real purchases. Switch to a development build so the native modules are compiled into the app.
How long do Google Play Service Credentials take to activate?
The captured walkthrough reports that activation can take up to 36 hours after the credentials are configured correctly. Product creation from the dashboard is available once activation completes.
| Level | Product ID | Price |
|---|---|---|
| Small tip / buy me a coffee | com.yourapp.tip.small | $1.99 |
| Medium tip / buy me two coffees | com.yourapp.tip.medium | $4.99 |
| Big tip / buy me a pizza | com.yourapp.tip.large | $9.99 |
Prices and identifiers are the captured example values; replace the app prefix and localize pricing before launch.