From fdc2099fb1d6d313c1de9f626e29c7a183ffe41a Mon Sep 17 00:00:00 2001
From: "mintlify[bot]" <109931778+mintlify[bot]@users.noreply.github.com>
Date: Tue, 10 Mar 2026 01:30:47 +0000
Subject: [PATCH 01/25] Update introduction/what-you-can-do.mdx
Co-Authored-By: mintlify[bot] <109931778+mintlify[bot]@users.noreply.github.com>
---
introduction/what-you-can-do.mdx | 28 ++++++++++++++++++++++++++++
1 file changed, 28 insertions(+)
create mode 100644 introduction/what-you-can-do.mdx
diff --git a/introduction/what-you-can-do.mdx b/introduction/what-you-can-do.mdx
new file mode 100644
index 0000000..3533446
--- /dev/null
+++ b/introduction/what-you-can-do.mdx
@@ -0,0 +1,28 @@
+---
+title: What you can do
+description: Explore the capabilities and features available with Helium
+---
+
+# What you can do
+
+Helium provides a comprehensive platform for managing in-app purchases and subscriptions. Here's what you can accomplish:
+
+## Paywall management
+
+Create and customize paywalls to present subscription offers to your users. Control when and how paywalls appear using triggers and workflows.
+
+## Revenue optimization
+
+Run experiments to test different pricing strategies, paywall designs, and messaging. Track revenue and conversion metrics to optimize your monetization strategy.
+
+## Audience targeting
+
+Segment your users into audiences and deliver personalized experiences based on user behavior, demographics, or custom attributes.
+
+## Analytics and insights
+
+Monitor subscription performance with built-in analytics or integrate with third-party analytics platforms to get a complete view of your business.
+
+## Cross-platform support
+
+Implement subscriptions across iOS, Android, React Native, and Flutter with consistent APIs and behavior.
From ea3c6f8dcbfe8216479b2c9c867dfa73b5745b10 Mon Sep 17 00:00:00 2001
From: "mintlify[bot]" <109931778+mintlify[bot]@users.noreply.github.com>
Date: Tue, 10 Mar 2026 01:30:53 +0000
Subject: [PATCH 02/25] Update introduction/billing-setup.mdx
Co-Authored-By: mintlify[bot] <109931778+mintlify[bot]@users.noreply.github.com>
---
introduction/billing-setup.mdx | 38 ++++++++++++++++++++++++++++++++++
1 file changed, 38 insertions(+)
create mode 100644 introduction/billing-setup.mdx
diff --git a/introduction/billing-setup.mdx b/introduction/billing-setup.mdx
new file mode 100644
index 0000000..79538e3
--- /dev/null
+++ b/introduction/billing-setup.mdx
@@ -0,0 +1,38 @@
+---
+title: How to get billing setup
+description: Set up billing and payment processing for your app
+---
+
+# How to get billing setup
+
+Before you can start accepting payments through Helium, you need to configure billing for your app.
+
+## Prerequisites
+
+- An active Helium account
+- Access to your app store developer accounts (Apple App Store Connect and/or Google Play Console)
+
+## Apple App Store setup
+
+1. Configure your app's in-app purchases in App Store Connect
+2. Create subscription groups and products
+3. Connect your App Store Connect account to Helium
+4. Verify that products are syncing correctly
+
+## Google Play Store setup
+
+1. Set up your app's billing in Google Play Console
+2. Create subscription products
+3. Connect your Google Play Console account to Helium
+4. Verify that products are syncing correctly
+
+## Testing billing
+
+Use sandbox environments to test your billing setup before going live:
+
+- For iOS, use StoreKit testing or sandbox accounts
+- For Android, use Google Play's test tracks and license testing
+
+## Next steps
+
+Once billing is configured, you can start creating paywalls and implementing subscription logic in your app.
From ceb3968347fd4f87c1acd3ef524b91299fc5e3ce Mon Sep 17 00:00:00 2001
From: "mintlify[bot]" <109931778+mintlify[bot]@users.noreply.github.com>
Date: Tue, 10 Mar 2026 01:30:59 +0000
Subject: [PATCH 03/25] Update introduction/contact.mdx
Co-Authored-By: mintlify[bot] <109931778+mintlify[bot]@users.noreply.github.com>
---
introduction/contact.mdx | 41 ++++++++++++++++++++++++++++++++++++++++
1 file changed, 41 insertions(+)
create mode 100644 introduction/contact.mdx
diff --git a/introduction/contact.mdx b/introduction/contact.mdx
new file mode 100644
index 0000000..fad373d
--- /dev/null
+++ b/introduction/contact.mdx
@@ -0,0 +1,41 @@
+---
+title: Who you can contact
+description: Get help and support for Helium
+---
+
+# Who you can contact
+
+Need help with Helium? Here are the ways to get in touch with our team.
+
+## Support channels
+
+### Email support
+
+For technical questions, billing inquiries, or general support, email us at:
+
+**support@tryhelium.com**
+
+### Community
+
+Join our community to connect with other Helium developers, share best practices, and get answers to common questions.
+
+### Documentation
+
+Browse our comprehensive documentation for guides, API references, and troubleshooting tips.
+
+## Response times
+
+- **Critical issues**: We aim to respond within 4 hours during business hours
+- **General inquiries**: We typically respond within 24 hours
+- **Feature requests**: We review and respond within 2-3 business days
+
+## What to include
+
+When contacting support, please include:
+
+- Your app name or Helium account ID
+- Platform (iOS, Android, React Native, Flutter)
+- SDK version
+- Detailed description of the issue
+- Steps to reproduce (if applicable)
+- Relevant error messages or logs
From 8225ac43bbafd5edc0d4ec8ba5a6b7f700af9f46 Mon Sep 17 00:00:00 2001
From: "mintlify[bot]" <109931778+mintlify[bot]@users.noreply.github.com>
Date: Tue, 10 Mar 2026 01:31:15 +0000
Subject: [PATCH 04/25] Update sdk-quickstarts/overview.mdx
Co-Authored-By: mintlify[bot] <109931778+mintlify[bot]@users.noreply.github.com>
---
sdk-quickstarts/overview.mdx | 49 ++++++++++++++++++++++++++++++++++++
1 file changed, 49 insertions(+)
create mode 100644 sdk-quickstarts/overview.mdx
diff --git a/sdk-quickstarts/overview.mdx b/sdk-quickstarts/overview.mdx
new file mode 100644
index 0000000..199fcdc
--- /dev/null
+++ b/sdk-quickstarts/overview.mdx
@@ -0,0 +1,49 @@
+---
+title: SDK quickstart
+description: Get started with Helium SDKs across all platforms
+---
+
+# SDK quickstart
+
+Choose your platform to get started with Helium. All SDKs provide consistent functionality with platform-specific implementations.
+
+## Supported platforms
+
+
+
+ Native iOS SDK for Swift and Objective-C
+
+
+ Native Android SDK for Kotlin and Java
+
+
+ Cross-platform SDK for React Native apps
+
+
+ Cross-platform SDK for Flutter apps
+
+
+
+## Common features
+
+All SDKs support:
+
+- Paywall presentation and customization
+- Product bucket management
+- Event tracking and analytics
+- Fallback handling for offline scenarios
+- StoreKit testing (iOS) and test environments (Android)
+- Third-party analytics integrations
+
+## Installation
+
+Each platform has specific installation instructions. Select your platform above to view detailed setup steps.
+
+## Next steps
+
+After installing the SDK:
+
+1. Configure your API keys
+2. Present your first paywall
+3. Set up event tracking
+4. Test with sandbox environments
From d77c70a37637ba88557729b274f9b9e92f6362be Mon Sep 17 00:00:00 2001
From: "mintlify[bot]" <109931778+mintlify[bot]@users.noreply.github.com>
Date: Tue, 10 Mar 2026 01:31:24 +0000
Subject: [PATCH 05/25] Update sdk-quickstarts/paywall-presentation.mdx
Co-Authored-By: mintlify[bot] <109931778+mintlify[bot]@users.noreply.github.com>
---
sdk-quickstarts/paywall-presentation.mdx | 71 ++++++++++++++++++++++++
1 file changed, 71 insertions(+)
create mode 100644 sdk-quickstarts/paywall-presentation.mdx
diff --git a/sdk-quickstarts/paywall-presentation.mdx b/sdk-quickstarts/paywall-presentation.mdx
new file mode 100644
index 0000000..4230398
--- /dev/null
+++ b/sdk-quickstarts/paywall-presentation.mdx
@@ -0,0 +1,71 @@
+---
+title: Paywall presentation notes
+description: Best practices and considerations for presenting paywalls
+---
+
+# Paywall presentation notes
+
+Learn how to effectively present paywalls in your app to maximize conversions while maintaining a great user experience.
+
+## When to show paywalls
+
+Consider these common trigger points:
+
+- **App launch**: Show to new users or after trial expiration
+- **Feature access**: Gate premium features behind subscriptions
+- **Usage limits**: Present when users hit free tier limits
+- **Onboarding completion**: Show after users understand your app's value
+- **Custom events**: Trigger based on specific user actions
+
+## Presentation styles
+
+### Modal presentation
+
+Full-screen or sheet-style paywalls that require user interaction to dismiss.
+
+```swift
+// iOS example
+Helium.shared.presentPaywall(style: .modal)
+```
+
+### Inline presentation
+
+Embed paywalls within your existing UI flow.
+
+```swift
+// iOS example
+let paywallView = Helium.shared.getPaywallView()
+containerView.addSubview(paywallView)
+```
+
+## User experience considerations
+
+### Don't interrupt critical flows
+
+Avoid showing paywalls during:
+- Active user tasks
+- Form completion
+- Content consumption
+
+### Provide clear value
+
+Before presenting a paywall:
+- Demonstrate your app's value
+- Explain what users get with a subscription
+- Show social proof or testimonials
+
+### Allow dismissal
+
+Always provide a way to dismiss paywalls (except for hard paywalls where appropriate).
+
+## Testing presentation
+
+Use StoreKit testing (iOS) or test environments (Android) to verify:
+- Paywall loads correctly
+- Products display properly
+- Purchase flow works end-to-end
+- Dismissal behavior is correct
+
+## Fallback handling
+
+Always implement fallback paywalls for offline scenarios. See the fallback documentation for details.
From 0813768f167bf6e7c584ea401df83cb0b62062fd Mon Sep 17 00:00:00 2001
From: "mintlify[bot]" <109931778+mintlify[bot]@users.noreply.github.com>
Date: Tue, 10 Mar 2026 01:31:33 +0000
Subject: [PATCH 06/25] Update sdk-quickstarts/feature-availability.mdx
Co-Authored-By: mintlify[bot] <109931778+mintlify[bot]@users.noreply.github.com>
---
sdk-quickstarts/feature-availability.mdx | 61 ++++++++++++++++++++++++
1 file changed, 61 insertions(+)
create mode 100644 sdk-quickstarts/feature-availability.mdx
diff --git a/sdk-quickstarts/feature-availability.mdx b/sdk-quickstarts/feature-availability.mdx
new file mode 100644
index 0000000..a576cc4
--- /dev/null
+++ b/sdk-quickstarts/feature-availability.mdx
@@ -0,0 +1,61 @@
+---
+title: Feature availability
+description: Platform-specific feature support across Helium SDKs
+---
+
+# Feature availability
+
+Not all features are available on every platform. This guide outlines what's supported on each SDK.
+
+## Core features
+
+| Feature | iOS | Android | React Native | Flutter |
+|---------|-----|---------|--------------|---------|
+| Paywall presentation | ✅ | ✅ | ✅ | ✅ |
+| Product buckets | ✅ | ✅ | ✅ | ✅ |
+| Custom events | ✅ | ✅ | ✅ | ✅ |
+| Revenue tracking | ✅ | ✅ | ✅ | ✅ |
+| Fallback paywalls | ✅ | ✅ | ✅ | ✅ |
+
+## Advanced features
+
+| Feature | iOS | Android | React Native | Flutter |
+|---------|-----|---------|--------------|---------|
+| Workflows | ✅ | ✅ | ✅ | ✅ |
+| Triggers | ✅ | ✅ | ✅ | ✅ |
+| Experiments | ✅ | ✅ | ✅ | ✅ |
+| Audiences | ✅ | ✅ | ✅ | ✅ |
+| Localization | ✅ | ✅ | ✅ | ✅ |
+
+## Platform-specific features
+
+### iOS only
+
+- **StoreKit 2 support**: Native integration with Apple's latest StoreKit APIs
+- **App Store receipt validation**: Automatic receipt verification
+- **Family Sharing**: Support for subscription sharing
+
+### Android only
+
+- **Google Play Billing Library 5+**: Latest billing APIs
+- **Pending purchases**: Handle deferred payment methods
+- **Proration modes**: Subscription upgrade/downgrade handling
+
+### Cross-platform considerations
+
+React Native and Flutter SDKs provide unified APIs but rely on native platform capabilities underneath. Some platform-specific behaviors may differ slightly.
+
+## Version requirements
+
+- **iOS**: iOS 13.0+
+- **Android**: Android 5.0+ (API level 21+)
+- **React Native**: React Native 0.64+
+- **Flutter**: Flutter 2.0+
+
+## Coming soon
+
+Features currently in development:
+
+- Web SDK support
+- Advanced paywall customization
+- A/B testing enhancements
From 2c091493ab7ae6b2dae97659f7894022da294b98 Mon Sep 17 00:00:00 2001
From: "mintlify[bot]" <109931778+mintlify[bot]@users.noreply.github.com>
Date: Tue, 10 Mar 2026 01:31:47 +0000
Subject: [PATCH 07/25] Update sdk-quickstarts/fallbacks.mdx
Co-Authored-By: mintlify[bot] <109931778+mintlify[bot]@users.noreply.github.com>
---
sdk-quickstarts/fallbacks.mdx | 95 +++++++++++++++++++++++++++++++++++
1 file changed, 95 insertions(+)
create mode 100644 sdk-quickstarts/fallbacks.mdx
diff --git a/sdk-quickstarts/fallbacks.mdx b/sdk-quickstarts/fallbacks.mdx
new file mode 100644
index 0000000..bf67858
--- /dev/null
+++ b/sdk-quickstarts/fallbacks.mdx
@@ -0,0 +1,95 @@
+---
+title: Fallbacks
+description: Handle offline scenarios and network failures gracefully
+---
+
+# Fallbacks
+
+Fallback paywalls ensure your app can present subscription offers even when network connectivity is unavailable or Helium's servers are unreachable.
+
+## Why fallbacks matter
+
+Users may encounter paywalls when:
+- Device is offline
+- Network connection is poor
+- Helium's CDN is temporarily unavailable
+- Initial app launch before data is cached
+
+Without fallbacks, you risk losing conversion opportunities during these scenarios.
+
+## How fallbacks work
+
+1. **Primary attempt**: SDK tries to fetch the latest paywall from Helium
+2. **Cache check**: If network fails, SDK checks for cached paywall data
+3. **Fallback bundle**: If no cache exists, SDK uses the bundled fallback paywall
+4. **Graceful degradation**: User sees a functional paywall regardless of network state
+
+## Setting up fallbacks
+
+### Include fallback bundle
+
+Bundle a static paywall configuration with your app:
+
+```swift
+// iOS example
+Helium.configure(
+ apiKey: "your-api-key",
+ fallbackBundle: "helium-fallback"
+)
+```
+
+### Create fallback content
+
+In your Helium dashboard:
+
+1. Navigate to Paywalls
+2. Select the paywall to use as fallback
+3. Export the fallback bundle
+4. Add the bundle to your app's resources
+
+### Test fallback behavior
+
+Simulate offline scenarios:
+
+```swift
+// iOS example - Force fallback mode
+Helium.shared.setTestMode(.forceFallback)
+Helium.shared.presentPaywall()
+```
+
+## Fallback limitations
+
+Fallback paywalls have some constraints:
+
+- **Static content**: Cannot include dynamic experiments or personalization
+- **Fixed products**: Product offerings are predetermined
+- **No analytics**: Limited event tracking until connectivity is restored
+- **Stale data**: May show outdated pricing or features
+
+## Best practices
+
+### Keep fallbacks updated
+
+Update your fallback bundle with each app release to ensure:
+- Current pricing is displayed
+- Latest product offerings are available
+- Messaging aligns with your current marketing
+
+### Design for offline
+
+Create fallback paywalls that:
+- Work without images (or bundle images locally)
+- Don't rely on dynamic content
+- Include all essential products
+- Have clear, timeless messaging
+
+### Monitor fallback usage
+
+Track how often fallbacks are triggered to identify:
+- Network reliability issues
+- CDN performance problems
+- Opportunities to improve caching
+
+## Fallback causes
+
+See the [fallback causes reference](/sdk-reference/fallback-causes) for detailed information on why fallbacks are triggered.
From 870f0c1bec292dac029a5273c0c3fd2870c30c37 Mon Sep 17 00:00:00 2001
From: "mintlify[bot]" <109931778+mintlify[bot]@users.noreply.github.com>
Date: Tue, 10 Mar 2026 01:32:05 +0000
Subject: [PATCH 08/25] Update sdk-quickstarts/storekit-testing.mdx
Co-Authored-By: mintlify[bot] <109931778+mintlify[bot]@users.noreply.github.com>
---
sdk-quickstarts/storekit-testing.mdx | 124 +++++++++++++++++++++++++++
1 file changed, 124 insertions(+)
create mode 100644 sdk-quickstarts/storekit-testing.mdx
diff --git a/sdk-quickstarts/storekit-testing.mdx b/sdk-quickstarts/storekit-testing.mdx
new file mode 100644
index 0000000..c311e02
--- /dev/null
+++ b/sdk-quickstarts/storekit-testing.mdx
@@ -0,0 +1,124 @@
+---
+title: StoreKit testing
+description: Test in-app purchases on iOS without real transactions
+---
+
+# StoreKit testing
+
+StoreKit testing allows you to test in-app purchases and subscriptions on iOS without processing real transactions or using sandbox accounts.
+
+## StoreKit configuration files
+
+StoreKit configuration files define your products locally for testing.
+
+### Create a configuration file
+
+1. In Xcode, go to **File > New > File**
+2. Select **StoreKit Configuration File**
+3. Name it (e.g., `Products.storekit`)
+4. Add your subscription products
+
+### Configure products
+
+Define products matching your App Store Connect setup:
+
+```json
+{
+ "identifier": "premium_monthly",
+ "type": "auto-renewable-subscription",
+ "displayName": "Premium Monthly",
+ "description": "Monthly premium subscription",
+ "price": "9.99",
+ "familyShareable": false,
+ "subscriptionGroupIdentifier": "premium_group"
+}
+```
+
+## Enable StoreKit testing
+
+### In Xcode
+
+1. Select your scheme
+2. Edit Scheme > Run
+3. Options tab
+4. Set StoreKit Configuration to your `.storekit` file
+
+### In code
+
+```swift
+// No code changes needed - Helium SDK automatically works with StoreKit testing
+Helium.shared.presentPaywall()
+```
+
+## Testing scenarios
+
+### Purchase flows
+
+Test the complete purchase experience:
+- Product display
+- Purchase initiation
+- Transaction processing
+- Subscription activation
+
+### Subscription states
+
+Simulate different subscription states:
+- **Active**: User has valid subscription
+- **Expired**: Subscription lapsed
+- **In grace period**: Payment failed but access continues
+- **In billing retry**: Attempting to resolve payment issue
+
+### Renewals and cancellations
+
+StoreKit testing accelerates subscription timelines:
+- Monthly subscriptions renew every 5 minutes
+- Annual subscriptions renew every 1 hour
+- Test cancellations and resubscriptions
+
+## StoreKit testing vs sandbox
+
+| Feature | StoreKit Testing | Sandbox |
+|---------|------------------|---------|
+| Setup | Local configuration file | App Store Connect + test account |
+| Speed | Instant | Requires network |
+| Offline | ✅ Works offline | ❌ Requires connection |
+| Real receipts | ❌ Simulated | ✅ Real sandbox receipts |
+| Best for | Development | Pre-production testing |
+
+## Debugging
+
+### Transaction manager
+
+Use Xcode's Transaction Manager to:
+- View all transactions
+- Clear purchase history
+- Simulate renewal failures
+- Test refunds
+
+Access via: **Debug > StoreKit > Manage Transactions**
+
+### Console logs
+
+Enable verbose logging:
+
+```swift
+Helium.shared.setLogLevel(.verbose)
+```
+
+## Limitations
+
+StoreKit testing doesn't simulate:
+- App Store receipt validation
+- Server-to-server notifications
+- Promotional offers (some scenarios)
+- Family Sharing
+
+For these scenarios, use sandbox testing.
+
+## Best practices
+
+1. **Test early**: Use StoreKit testing during development
+2. **Sandbox before release**: Always test with sandbox before production
+3. **Clear state**: Reset transactions between test runs
+4. **Match production**: Keep StoreKit config in sync with App Store Connect
+5. **Test edge cases**: Simulate failures, cancellations, and upgrades
From e781d2ce81bfabc8f6abed0a684d9d610226d328 Mon Sep 17 00:00:00 2001
From: "mintlify[bot]" <109931778+mintlify[bot]@users.noreply.github.com>
Date: Tue, 10 Mar 2026 01:32:29 +0000
Subject: [PATCH 09/25] Update primitives/paywalls.mdx
Co-Authored-By: mintlify[bot] <109931778+mintlify[bot]@users.noreply.github.com>
---
primitives/paywalls.mdx | 117 ++++++++++++++++++++++++++++++++++++++++
1 file changed, 117 insertions(+)
create mode 100644 primitives/paywalls.mdx
diff --git a/primitives/paywalls.mdx b/primitives/paywalls.mdx
new file mode 100644
index 0000000..4367013
--- /dev/null
+++ b/primitives/paywalls.mdx
@@ -0,0 +1,117 @@
+---
+title: Paywalls
+description: Create and customize subscription paywalls
+---
+
+# Paywalls
+
+Paywalls are the primary interface for presenting subscription offers to your users. Helium provides flexible paywall creation and customization options.
+
+## What are paywalls?
+
+Paywalls are screens that display your subscription products and encourage users to subscribe. They can include:
+
+- Product offerings and pricing
+- Feature comparisons
+- Promotional messaging
+- Social proof and testimonials
+- Call-to-action buttons
+
+## Creating paywalls
+
+Create paywalls in the Helium dashboard:
+
+1. Navigate to **Paywalls**
+2. Click **Create Paywall**
+3. Choose a template or start from scratch
+4. Customize design and content
+5. Assign products or product buckets
+
+## Paywall components
+
+### Header
+
+The top section typically includes:
+- App icon or logo
+- Headline
+- Subheadline or value proposition
+
+### Product display
+
+Show subscription options:
+- Product names and descriptions
+- Pricing and billing periods
+- Promotional badges (e.g., "Most Popular")
+- Free trial information
+
+### Features list
+
+Highlight what users get:
+- Feature bullets
+- Icons or checkmarks
+- Comparison tables
+
+### Footer
+
+Bottom section with:
+- Purchase button
+- Terms of service links
+- Privacy policy links
+- Restore purchases option
+
+## Customization
+
+### Visual design
+
+Customize appearance:
+- Colors and fonts
+- Spacing and layout
+- Images and icons
+- Button styles
+
+### Content
+
+Tailor messaging:
+- Localized text
+- Dynamic product information
+- Personalized offers
+- A/B test variations
+
+## Product assignment
+
+Assign products to paywalls:
+
+- **Direct assignment**: Specify exact products
+- **Product buckets**: Use dynamic product groups that can be updated without app releases
+
+See [Product buckets](/primitives/product-buckets) for more information.
+
+## Localization
+
+Support multiple languages and regions. See [Localization](/primitives/paywalls/localization) for details.
+
+## Best practices
+
+### Keep it simple
+
+- Focus on 2-3 product options
+- Use clear, concise copy
+- Avoid overwhelming users with information
+
+### Highlight value
+
+- Lead with benefits, not features
+- Use social proof
+- Show what users get immediately
+
+### Test and iterate
+
+- Run experiments to optimize conversion
+- Test different layouts and messaging
+- Monitor analytics to identify improvements
+
+## Next steps
+
+- Learn about [Localization](/primitives/paywalls/localization)
+- Explore [Product buckets](/primitives/paywalls/product-buckets)
+- Set up [Workflows](/primitives/workflows) to control when paywalls appear
From 15805a071e561f73c0d5d41c4bf462882ba053ec Mon Sep 17 00:00:00 2001
From: "mintlify[bot]" <109931778+mintlify[bot]@users.noreply.github.com>
Date: Tue, 10 Mar 2026 01:32:45 +0000
Subject: [PATCH 10/25] Update primitives/paywalls/localization.mdx
Co-Authored-By: mintlify[bot] <109931778+mintlify[bot]@users.noreply.github.com>
---
primitives/paywalls/localization.mdx | 142 +++++++++++++++++++++++++++
1 file changed, 142 insertions(+)
create mode 100644 primitives/paywalls/localization.mdx
diff --git a/primitives/paywalls/localization.mdx b/primitives/paywalls/localization.mdx
new file mode 100644
index 0000000..c342139
--- /dev/null
+++ b/primitives/paywalls/localization.mdx
@@ -0,0 +1,142 @@
+---
+title: Localization
+description: Localize paywalls for different languages and regions
+---
+
+# Localization
+
+Localize your paywalls to provide native experiences for users in different countries and languages.
+
+## Why localize?
+
+Localized paywalls can significantly improve conversion rates by:
+
+- Speaking users' native language
+- Showing appropriate currency and pricing
+- Respecting cultural norms and preferences
+- Building trust with local audiences
+
+## Supported languages
+
+Helium supports localization for:
+
+- English
+- Spanish
+- French
+- German
+- Italian
+- Portuguese
+- Japanese
+- Korean
+- Chinese (Simplified and Traditional)
+- And more...
+
+## Setting up localization
+
+### In the dashboard
+
+1. Navigate to your paywall
+2. Click **Localization**
+3. Add languages
+4. Translate content for each language
+
+### Content to localize
+
+Translate all user-facing text:
+
+- Headlines and subheadlines
+- Product descriptions
+- Feature lists
+- Button text
+- Legal links and disclaimers
+
+### Product information
+
+Product names and descriptions are automatically localized based on your App Store Connect or Google Play Console configuration.
+
+## Currency and pricing
+
+Pricing is automatically displayed in the user's local currency based on:
+
+- App Store or Google Play pricing tiers
+- User's device region
+- Store account settings
+
+## Automatic language detection
+
+The SDK automatically detects the user's preferred language:
+
+```swift
+// iOS - Automatic detection
+Helium.shared.presentPaywall() // Shows localized version
+
+// Override language
+Helium.shared.presentPaywall(language: "es")
+```
+
+## Fallback behavior
+
+If a localization isn't available:
+
+1. SDK checks for user's preferred language
+2. Falls back to user's region language
+3. Falls back to default language (typically English)
+
+## Testing localization
+
+Test different languages:
+
+### iOS
+
+Change device language in Settings > General > Language & Region
+
+### Android
+
+Change device language in Settings > System > Languages
+
+### Programmatically
+
+```swift
+// iOS example
+Helium.shared.setTestLanguage("es")
+Helium.shared.presentPaywall()
+```
+
+## Best practices
+
+### Professional translation
+
+- Use professional translators, not machine translation
+- Ensure cultural appropriateness
+- Test with native speakers
+
+### Consistent terminology
+
+- Maintain consistent product names
+- Use standard industry terms
+- Keep brand voice across languages
+
+### Layout considerations
+
+- Account for text expansion (some languages are longer)
+- Test UI with actual translated content
+- Ensure buttons and labels don't truncate
+
+### Regional variations
+
+Consider regional differences:
+
+- Spanish (Spain) vs Spanish (Latin America)
+- Portuguese (Portugal) vs Portuguese (Brazil)
+- Chinese (Simplified) vs Chinese (Traditional)
+
+## Localization checklist
+
+- [ ] All text content translated
+- [ ] Product information localized in store
+- [ ] Images with text localized or text-free
+- [ ] Legal links point to localized terms
+- [ ] Tested on devices in each language
+- [ ] Currency displays correctly
+- [ ] Layout works with longer text
+- [ ] Cultural appropriateness verified
From 4155b1bd748505c9d1fffa9184826920f5f86d5f Mon Sep 17 00:00:00 2001
From: "mintlify[bot]" <109931778+mintlify[bot]@users.noreply.github.com>
Date: Tue, 10 Mar 2026 01:33:03 +0000
Subject: [PATCH 11/25] Update primitives/paywalls/product-buckets.mdx
Co-Authored-By: mintlify[bot] <109931778+mintlify[bot]@users.noreply.github.com>
---
primitives/paywalls/product-buckets.mdx | 196 ++++++++++++++++++++++++
1 file changed, 196 insertions(+)
create mode 100644 primitives/paywalls/product-buckets.mdx
diff --git a/primitives/paywalls/product-buckets.mdx b/primitives/paywalls/product-buckets.mdx
new file mode 100644
index 0000000..f150cb1
--- /dev/null
+++ b/primitives/paywalls/product-buckets.mdx
@@ -0,0 +1,196 @@
+---
+title: Product buckets
+description: Dynamically manage product offerings in paywalls
+---
+
+# Product buckets
+
+Product buckets allow you to dynamically control which products appear in your paywalls without requiring app updates.
+
+## What are product buckets?
+
+Product buckets are named groups of products that can be updated remotely. Instead of hardcoding specific products in your paywalls, you reference a bucket, and Helium determines which products to show.
+
+## Benefits
+
+### No app updates required
+
+Change product offerings without:
+- Submitting new app versions
+- Waiting for app review
+- Forcing users to update
+
+### Dynamic pricing
+
+Easily:
+- Run promotional campaigns
+- Test different price points
+- Adjust offerings by region or audience
+
+### Simplified management
+
+- Update products in one place
+- Consistent across all platforms
+- Centralized control
+
+## Creating product buckets
+
+In the Helium dashboard:
+
+1. Navigate to **Product Buckets**
+2. Click **Create Bucket**
+3. Name your bucket (e.g., "premium_products")
+4. Add products to the bucket
+5. Set priority order
+
+## Using product buckets
+
+### In paywalls
+
+Assign a product bucket instead of specific products:
+
+1. Edit your paywall
+2. In product selection, choose **Product Bucket**
+3. Select your bucket
+4. Products will be dynamically loaded
+
+### In code
+
+Reference products by bucket:
+
+```swift
+// iOS example
+Helium.shared.presentPaywall(productBucket: "premium_products")
+```
+
+## Product selection logic
+
+When a paywall uses a product bucket, Helium:
+
+1. Fetches the current products in the bucket
+2. Filters by platform (iOS/Android)
+3. Filters by availability
+4. Returns products in priority order
+
+## Bucket strategies
+
+### Single bucket
+
+Use one bucket for all users:
+
+```
+premium_products:
+ - monthly_subscription
+ - annual_subscription
+```
+
+### Audience-specific buckets
+
+Create different buckets for different audiences:
+
+```
+premium_new_users:
+ - monthly_trial
+ - annual_discount
+
+premium_existing_users:
+ - monthly_standard
+ - annual_standard
+```
+
+### Regional buckets
+
+Customize offerings by region:
+
+```
+premium_us:
+ - monthly_9_99
+ - annual_99_99
+
+premium_eu:
+ - monthly_8_99
+ - annual_89_99
+```
+
+## Updating buckets
+
+Changes to product buckets take effect immediately:
+
+1. Edit the bucket in the dashboard
+2. Add, remove, or reorder products
+3. Save changes
+4. Next paywall load will use updated products
+
+## Fallback handling
+
+Always include product buckets in your fallback bundle to ensure offline functionality.
+
+## Best practices
+
+### Naming conventions
+
+Use clear, descriptive names:
+- `premium_products` not `bucket1`
+- `trial_offers` not `temp`
+- `regional_us` not `us`
+
+### Product ordering
+
+Order products strategically:
+- Most popular first
+- Highest value first
+- Or based on your conversion data
+
+### Testing
+
+Test bucket changes before rolling out:
+- Use test audiences
+- Verify products load correctly
+- Check pricing displays properly
+
+### Documentation
+
+Document your bucket strategy:
+- What each bucket contains
+- Which audiences see which buckets
+- When to use each bucket
+
+## Common patterns
+
+### Seasonal promotions
+
+```
+summer_sale:
+ - monthly_discounted
+ - annual_discounted
+```
+
+Switch paywalls to use `summer_sale` bucket during promotion, then switch back.
+
+### A/B testing
+
+```
+variant_a:
+ - monthly_standard
+ - annual_standard
+
+variant_b:
+ - monthly_premium
+ - annual_premium
+```
+
+Use experiments to test which bucket converts better.
+
+### Upgrade paths
+
+```
+basic_to_premium:
+ - premium_monthly
+ - premium_annual
+
+premium_to_pro:
+ - pro_monthly
+ - pro_annual
+```
+
+Show different buckets based on user's current subscription tier.
From 6ffaca48979327d94c668552e2e8cf11b1457662 Mon Sep 17 00:00:00 2001
From: "mintlify[bot]" <109931778+mintlify[bot]@users.noreply.github.com>
Date: Tue, 10 Mar 2026 01:33:20 +0000
Subject: [PATCH 12/25] Update primitives/workflows.mdx
Co-Authored-By: mintlify[bot] <109931778+mintlify[bot]@users.noreply.github.com>
---
primitives/workflows.mdx | 231 +++++++++++++++++++++++++++++++++++++++
1 file changed, 231 insertions(+)
create mode 100644 primitives/workflows.mdx
diff --git a/primitives/workflows.mdx b/primitives/workflows.mdx
new file mode 100644
index 0000000..857f1bb
--- /dev/null
+++ b/primitives/workflows.mdx
@@ -0,0 +1,231 @@
+---
+title: Workflows
+description: Orchestrate complex paywall presentation logic
+---
+
+# Workflows
+
+Workflows allow you to create sophisticated logic for when and how paywalls are presented to users.
+
+## What are workflows?
+
+Workflows are sequences of conditions and actions that determine paywall behavior. They let you:
+
+- Control when paywalls appear
+- Customize which paywall to show
+- Personalize based on user attributes
+- Implement complex business logic
+
+## Workflow components
+
+### Triggers
+
+Events that initiate a workflow:
+- App launch
+- Feature access attempt
+- Custom events
+- Time-based conditions
+
+### Conditions
+
+Rules that must be met:
+- User subscription status
+- Number of app sessions
+- Time since install
+- Custom user properties
+- Audience membership
+
+### Actions
+
+What happens when conditions are met:
+- Present specific paywall
+- Show different paywall variants
+- Track analytics event
+- Do nothing (suppress paywall)
+
+## Creating workflows
+
+In the Helium dashboard:
+
+1. Navigate to **Workflows**
+2. Click **Create Workflow**
+3. Define trigger conditions
+4. Add conditional logic
+5. Specify actions
+6. Activate workflow
+
+## Example workflows
+
+### New user onboarding
+
+```
+Trigger: App launch
+Conditions:
+ - Session count < 3
+ - Not subscribed
+Action: Present onboarding_paywall
+```
+
+### Feature gate
+
+```
+Trigger: Premium feature accessed
+Conditions:
+ - Not subscribed
+ - Feature access count > 2
+Action: Present feature_gate_paywall
+```
+
+### Win-back campaign
+
+```
+Trigger: App launch
+Conditions:
+ - Previously subscribed
+ - Subscription expired > 30 days ago
+ - Not seen paywall in 7 days
+Action: Present winback_paywall
+```
+
+### Trial expiration
+
+```
+Trigger: Daily check
+Conditions:
+ - Trial expires in 3 days
+ - Not converted to paid
+Action: Present trial_ending_paywall
+```
+
+## Workflow priority
+
+When multiple workflows could trigger:
+
+1. Workflows are evaluated in priority order
+2. First matching workflow executes
+3. Subsequent workflows are skipped
+
+Set priority in the dashboard to control execution order.
+
+## Testing workflows
+
+### Test mode
+
+Enable test mode to verify workflow logic:
+
+```swift
+// iOS example
+Helium.shared.setTestMode(.enabled)
+Helium.shared.triggerWorkflow("new_user_onboarding")
+```
+
+### Workflow logs
+
+View workflow execution logs in the dashboard:
+- Which workflows triggered
+- Which conditions were met
+- What actions were taken
+- Why workflows were skipped
+
+## Advanced features
+
+### Delays
+
+Add delays between trigger and action:
+
+```
+Trigger: App launch
+Delay: 5 seconds
+Action: Present paywall
+```
+
+### Frequency capping
+
+Limit how often workflows execute:
+
+```
+Max frequency: Once per 7 days
+```
+
+### Audience targeting
+
+Combine workflows with audiences:
+
+```
+Conditions:
+ - User in "high_value" audience
+ - Not subscribed
+```
+
+## Best practices
+
+### Start simple
+
+Begin with basic workflows:
+- One trigger
+- Few conditions
+- Single action
+
+Add complexity as needed.
+
+### Test thoroughly
+
+- Test all condition branches
+- Verify timing and delays
+- Check frequency caps
+- Monitor analytics
+
+### Document logic
+
+Maintain documentation of:
+- Workflow purpose
+- Expected behavior
+- Business rules
+- Edge cases
+
+### Monitor performance
+
+Track workflow metrics:
+- Trigger frequency
+- Conversion rates
+- User feedback
+- Technical errors
+
+## Common pitfalls
+
+### Over-complication
+
+Avoid:
+- Too many conditions
+- Complex nested logic
+- Unclear execution paths
+
+### Conflicting workflows
+
+Watch for:
+- Multiple workflows triggering simultaneously
+- Contradictory conditions
+- Priority conflicts
+
+### Poor timing
+
+Consider:
+- User context
+- App state
+- Network conditions
+- Previous interactions
+
+## Integration with other primitives
+
+Workflows work with:
+
+- **Triggers**: Define when workflows start
+- **Audiences**: Target specific user segments
+- **Experiments**: Test different workflow variants
+- **Product buckets**: Dynamically select products
+
+## Next steps
+
+- Learn about [Triggers](/primitives/triggers)
+- Explore [Experiments](/primitives/experiments)
+- Set up [Audiences](/primitives/audiences)
From 3f6ad51476cf86c32f656be044854393bcdf0eec Mon Sep 17 00:00:00 2001
From: "mintlify[bot]" <109931778+mintlify[bot]@users.noreply.github.com>
Date: Tue, 10 Mar 2026 01:33:44 +0000
Subject: [PATCH 13/25] Update primitives/triggers.mdx
Co-Authored-By: mintlify[bot] <109931778+mintlify[bot]@users.noreply.github.com>
---
primitives/triggers.mdx | 280 ++++++++++++++++++++++++++++++++++++++++
1 file changed, 280 insertions(+)
create mode 100644 primitives/triggers.mdx
diff --git a/primitives/triggers.mdx b/primitives/triggers.mdx
new file mode 100644
index 0000000..61c6c4f
--- /dev/null
+++ b/primitives/triggers.mdx
@@ -0,0 +1,280 @@
+---
+title: Triggers
+description: Define events that initiate paywall presentation
+---
+
+# Triggers
+
+Triggers are events that can initiate paywall presentation or workflow execution. They define when your monetization logic should activate.
+
+## What are triggers?
+
+Triggers are named events that occur in your app. When a trigger fires, Helium evaluates associated workflows and determines whether to present a paywall.
+
+## Built-in triggers
+
+Helium provides several built-in triggers:
+
+### App lifecycle
+
+- **app_launch**: App starts or returns to foreground
+- **app_install**: First app launch after installation
+- **app_update**: First launch after app update
+
+### Subscription events
+
+- **subscription_expired**: User's subscription has expired
+- **trial_started**: User started a free trial
+- **trial_ending**: Trial will expire soon (configurable threshold)
+- **subscription_renewed**: Subscription successfully renewed
+
+### User actions
+
+- **feature_accessed**: User attempts to access a feature
+- **content_viewed**: User views specific content
+- **limit_reached**: User hits usage limit
+
+## Custom triggers
+
+Create custom triggers for your specific use cases:
+
+```swift
+// iOS example
+Helium.shared.trigger("premium_feature_tapped")
+```
+
+```kotlin
+// Android example
+Helium.trigger("premium_feature_tapped")
+```
+
+## Trigger properties
+
+Attach additional data to triggers:
+
+```swift
+// iOS example
+Helium.shared.trigger("feature_accessed", properties: [
+ "feature_name": "advanced_editor",
+ "access_count": 3
+])
+```
+
+Use properties in workflow conditions:
+
+```
+Trigger: feature_accessed
+Conditions:
+ - feature_name == "advanced_editor"
+ - access_count > 2
+Action: Present paywall
+```
+
+## Creating triggers
+
+### In the dashboard
+
+1. Navigate to **Triggers**
+2. Click **Create Trigger**
+3. Name your trigger
+4. Define trigger properties (optional)
+5. Associate with workflows
+
+### In code
+
+Implement trigger calls at appropriate points:
+
+```swift
+// iOS example - Feature gate
+func openPremiumFeature() {
+ if !user.isSubscribed {
+ Helium.shared.trigger("premium_feature_accessed")
+ }
+ // Feature logic...
+}
+```
+
+## Trigger timing
+
+### Immediate triggers
+
+Fire as soon as the event occurs:
+
+```swift
+Helium.shared.trigger("button_tapped")
+```
+
+### Delayed triggers
+
+Fire after a delay:
+
+```swift
+// iOS example
+Helium.shared.trigger("app_launch", delay: 3.0)
+```
+
+### Scheduled triggers
+
+Fire at specific times (configured in dashboard):
+
+```
+Trigger: trial_reminder
+Schedule: Daily at 10:00 AM
+```
+
+## Trigger conditions
+
+Add conditions to triggers to control when they fire:
+
+### Frequency limits
+
+```
+Max frequency: Once per day
+```
+
+### User state
+
+```
+Only trigger if:
+ - Not subscribed
+ - Session count > 5
+```
+
+### Time windows
+
+```
+Only trigger between:
+ - 9:00 AM - 9:00 PM user local time
+```
+
+## Testing triggers
+
+### Manual triggering
+
+Test triggers manually:
+
+```swift
+// iOS example
+Helium.shared.setTestMode(.enabled)
+Helium.shared.trigger("test_trigger")
+```
+
+### Trigger logs
+
+View trigger activity in the dashboard:
+- When triggers fired
+- Associated properties
+- Which workflows executed
+- Resulting actions
+
+## Best practices
+
+### Naming conventions
+
+Use clear, descriptive names:
+- `premium_feature_accessed` not `trigger1`
+- `trial_ending_soon` not `temp_trigger`
+- `onboarding_completed` not `done`
+
+### Strategic placement
+
+Place triggers where they make sense:
+- Before showing premium features
+- After demonstrating value
+- At natural decision points
+
+### Don't over-trigger
+
+Avoid:
+- Triggering too frequently
+- Interrupting critical flows
+- Annoying users with repeated prompts
+
+### Include context
+
+Add relevant properties:
+
+```swift
+Helium.shared.trigger("content_viewed", properties: [
+ "content_type": "article",
+ "content_id": "123",
+ "view_duration": 45
+])
+```
+
+## Common patterns
+
+### Feature gating
+
+```swift
+func accessPremiumFeature() {
+ guard user.isSubscribed else {
+ Helium.shared.trigger("premium_feature_gate")
+ return
+ }
+ // Show feature
+}
+```
+
+### Usage limits
+
+```swift
+func performAction() {
+ usageCount += 1
+
+ if usageCount >= freeLimit && !user.isSubscribed {
+ Helium.shared.trigger("usage_limit_reached", properties: [
+ "limit": freeLimit,
+ "count": usageCount
+ ])
+ }
+}
+```
+
+### Onboarding completion
+
+```swift
+func completeOnboarding() {
+ // Onboarding logic...
+
+ Helium.shared.trigger("onboarding_completed", properties: [
+ "steps_completed": 5,
+ "time_spent": 120
+ ])
+}
+```
+
+### Time-based prompts
+
+```swift
+func checkTrialStatus() {
+ if let trialEndDate = user.trialEndDate {
+ let daysRemaining = trialEndDate.daysFromNow
+
+ if daysRemaining <= 3 {
+ Helium.shared.trigger("trial_ending_soon", properties: [
+ "days_remaining": daysRemaining
+ ])
+ }
+ }
+}
+```
+
+## Integration with workflows
+
+Triggers are the entry point for workflows:
+
+```
+Workflow: Premium feature gate
+Trigger: premium_feature_accessed
+Conditions:
+ - Not subscribed
+ - Access count > 2
+Action: Present feature_gate_paywall
+```
+
+## Next steps
+
+- Learn about [Workflows](/primitives/workflows)
+- Explore [Experiments](/primitives/experiments)
+- Set up [Audiences](/primitives/audiences)
From f737f699919d4f93a16157f8b5a318dafd616781 Mon Sep 17 00:00:00 2001
From: "mintlify[bot]" <109931778+mintlify[bot]@users.noreply.github.com>
Date: Tue, 10 Mar 2026 01:34:13 +0000
Subject: [PATCH 14/25] Update primitives/experiments.mdx
Co-Authored-By: mintlify[bot] <109931778+mintlify[bot]@users.noreply.github.com>
---
primitives/experiments.mdx | 324 +++++++++++++++++++++++++++++++++++++
1 file changed, 324 insertions(+)
create mode 100644 primitives/experiments.mdx
diff --git a/primitives/experiments.mdx b/primitives/experiments.mdx
new file mode 100644
index 0000000..60165ce
--- /dev/null
+++ b/primitives/experiments.mdx
@@ -0,0 +1,324 @@
+---
+title: Experiments
+description: Run A/B tests to optimize conversion rates
+---
+
+# Experiments
+
+Experiments allow you to test different paywall variations, pricing strategies, and messaging to optimize your subscription conversion rates.
+
+## What are experiments?
+
+Experiments (also called A/B tests) show different variations of your paywalls to different users and measure which performs better.
+
+## Why run experiments?
+
+Experiments help you:
+
+- **Increase conversions**: Find the most effective paywall design
+- **Optimize pricing**: Test different price points and offerings
+- **Improve messaging**: Discover which copy resonates with users
+- **Reduce churn**: Test retention strategies
+- **Make data-driven decisions**: Replace guesswork with evidence
+
+## Creating experiments
+
+In the Helium dashboard:
+
+1. Navigate to **Experiments**
+2. Click **Create Experiment**
+3. Define your hypothesis
+4. Create variations
+5. Set traffic allocation
+6. Configure success metrics
+7. Launch experiment
+
+## Experiment components
+
+### Control group
+
+The baseline variation (usually your current paywall):
+
+```
+Control: Current paywall design
+Traffic: 50%
+```
+
+### Variants
+
+Alternative versions to test:
+
+```
+Variant A: New headline and pricing
+Traffic: 25%
+
+Variant B: Different product order
+Traffic: 25%
+```
+
+### Success metrics
+
+What you're measuring:
+
+- Conversion rate
+- Revenue per user
+- Trial start rate
+- Subscription retention
+
+## Types of experiments
+
+### Design experiments
+
+Test visual elements:
+- Layout and spacing
+- Colors and fonts
+- Images and icons
+- Button styles
+
+### Pricing experiments
+
+Test different pricing strategies:
+- Price points
+- Product offerings
+- Free trial lengths
+- Promotional discounts
+
+### Messaging experiments
+
+Test different copy:
+- Headlines
+- Value propositions
+- Feature descriptions
+- Call-to-action text
+
+### Product experiments
+
+Test product configurations:
+- Number of options
+- Product ordering
+- Default selections
+- Product buckets
+
+## Traffic allocation
+
+Distribute users across variations:
+
+### Equal split
+
+```
+Control: 33%
+Variant A: 33%
+Variant B: 34%
+```
+
+### Weighted split
+
+```
+Control: 70%
+Variant A: 30%
+```
+
+### Gradual rollout
+
+```
+Week 1: Control 90%, Variant 10%
+Week 2: Control 70%, Variant 30%
+Week 3: Control 50%, Variant 50%
+```
+
+## Statistical significance
+
+Helium automatically calculates:
+
+- **Confidence level**: How certain we are about results
+- **Sample size**: Number of users in each variation
+- **P-value**: Statistical significance
+- **Lift**: Percentage improvement over control
+
+Wait for statistical significance before making decisions (typically 95% confidence).
+
+## Running experiments
+
+### Duration
+
+Run experiments long enough to:
+- Reach statistical significance
+- Account for weekly patterns
+- Include different user cohorts
+
+Typical duration: 1-4 weeks
+
+### Sample size
+
+Ensure adequate sample size:
+- Minimum: ~1000 users per variation
+- More for smaller effect sizes
+- Consider your traffic volume
+
+### Consistency
+
+Users always see the same variation:
+- Assigned on first view
+- Consistent across sessions
+- Tracked by user ID
+
+## Analyzing results
+
+### Key metrics
+
+Monitor:
+- **Conversion rate**: % of users who subscribe
+- **Revenue per user**: Average revenue generated
+- **Statistical significance**: Confidence in results
+- **Secondary metrics**: Trial starts, engagement, etc.
+
+### Dashboard view
+
+View experiment results:
+- Real-time metrics
+- Variation comparison
+- Statistical analysis
+- User segmentation
+
+## Implementing winners
+
+When a variation wins:
+
+1. Review results and confirm significance
+2. Stop the experiment
+3. Make the winning variation the default
+4. Document learnings
+5. Plan next experiment
+
+## Best practices
+
+### One variable at a time
+
+Test one thing per experiment:
+- ✅ Test headline only
+- ❌ Test headline + pricing + layout
+
+### Clear hypothesis
+
+Start with a hypothesis:
+- "Emphasizing the free trial will increase conversions"
+- "Showing annual savings will increase annual subscriptions"
+
+### Sufficient duration
+
+Don't stop too early:
+- Wait for statistical significance
+- Account for day-of-week effects
+- Include multiple user cohorts
+
+### Document everything
+
+Record:
+- Hypothesis
+- Variations tested
+- Results and insights
+- Next steps
+
+### Iterate continuously
+
+- Always have an experiment running
+- Build on previous learnings
+- Test incrementally
+
+## Common pitfalls
+
+### Stopping too early
+
+Avoid:
+- Declaring winners before significance
+- Reacting to early trends
+- Not accounting for variance
+
+### Testing too much
+
+Avoid:
+- Multiple changes in one experiment
+- Too many variations
+- Complex multivariate tests
+
+### Ignoring segments
+
+Consider:
+- Different user segments may respond differently
+- Regional variations
+- Platform differences (iOS vs Android)
+
+## Advanced techniques
+
+### Multivariate testing
+
+Test multiple variables simultaneously:
+
+```
+Headline A + Price A
+Headline A + Price B
+Headline B + Price A
+Headline B + Price B
+```
+
+Requires larger sample sizes.
+
+### Sequential testing
+
+Run experiments in sequence:
+
+```
+Experiment 1: Test headline → Winner: Headline B
+Experiment 2: Test pricing with Headline B → Winner: Price A
+Experiment 3: Test layout with Headline B + Price A
+```
+
+### Holdout groups
+
+Keep a control group long-term:
+
+```
+90% see optimized paywalls
+10% see original (for comparison)
+```
+
+## Integration with other features
+
+Experiments work with:
+
+- **Audiences**: Test variations on specific segments
+- **Workflows**: Experiment with different presentation logic
+- **Product buckets**: Test different product offerings
+- **Triggers**: Experiment with timing and context
+
+## Example experiments
+
+### Headline test
+
+```
+Control: "Unlock Premium Features"
+Variant A: "Start Your Free Trial"
+Variant B: "Join 1M+ Premium Users"
+```
+
+### Pricing test
+
+```
+Control: Monthly $9.99, Annual $99.99
+Variant A: Monthly $7.99, Annual $79.99
+Variant B: Monthly $12.99, Annual $119.99
+```
+
+### Product order test
+
+```
+Control: Monthly, Annual, Lifetime
+Variant A: Annual, Monthly, Lifetime
+Variant B: Annual (highlighted), Monthly, Lifetime
+```
+
+## Next steps
+
+- Set up [Audiences](/primitives/audiences) for targeted experiments
+- Learn about [Workflows](/primitives/workflows) for complex testing
+- Explore [Analytics](/analytics/overview) to track results
From 8c99e2a71ba4755b9dc6a6985282e9495e79a3b4 Mon Sep 17 00:00:00 2001
From: "mintlify[bot]" <109931778+mintlify[bot]@users.noreply.github.com>
Date: Tue, 10 Mar 2026 01:34:43 +0000
Subject: [PATCH 15/25] Update primitives/audiences.mdx
Co-Authored-By: mintlify[bot] <109931778+mintlify[bot]@users.noreply.github.com>
---
primitives/audiences.mdx | 337 +++++++++++++++++++++++++++++++++++++++
1 file changed, 337 insertions(+)
create mode 100644 primitives/audiences.mdx
diff --git a/primitives/audiences.mdx b/primitives/audiences.mdx
new file mode 100644
index 0000000..b1afa26
--- /dev/null
+++ b/primitives/audiences.mdx
@@ -0,0 +1,337 @@
+---
+title: Audiences
+description: Segment users for targeted experiences
+---
+
+# Audiences
+
+Audiences allow you to segment users into groups and deliver personalized paywall experiences based on user attributes and behavior.
+
+## What are audiences?
+
+Audiences are dynamic user segments defined by rules and conditions. They enable you to:
+
+- Target specific user groups
+- Personalize paywall content
+- Run targeted experiments
+- Optimize conversion by segment
+
+## Creating audiences
+
+In the Helium dashboard:
+
+1. Navigate to **Audiences**
+2. Click **Create Audience**
+3. Name your audience
+4. Define membership rules
+5. Save and activate
+
+## Audience rules
+
+Define who belongs to an audience using conditions:
+
+### User attributes
+
+```
+Country: United States
+Language: English
+Platform: iOS
+App version: >= 2.0
+```
+
+### Subscription status
+
+```
+Subscription status: Not subscribed
+Previous subscriber: Yes
+Trial status: Never started
+```
+
+### Behavior
+
+```
+Session count: > 10
+Days since install: > 7
+Feature usage: Used premium feature
+Last seen: Within 7 days
+```
+
+### Custom properties
+
+```
+User tier: "power_user"
+Referral source: "social_media"
+Lifetime value: > $50
+```
+
+## Audience types
+
+### Demographic audiences
+
+Based on user characteristics:
+
+```
+Audience: US iOS Users
+Rules:
+ - Country: US
+ - Platform: iOS
+```
+
+### Behavioral audiences
+
+Based on user actions:
+
+```
+Audience: Engaged Users
+Rules:
+ - Session count: > 20
+ - Days since install: > 14
+ - Feature usage: High
+```
+
+### Lifecycle audiences
+
+Based on user journey stage:
+
+```
+Audience: Trial Users
+Rules:
+ - Trial status: Active
+ - Days remaining: > 3
+```
+
+### Value-based audiences
+
+Based on revenue potential:
+
+```
+Audience: High Value Users
+Rules:
+ - Previous subscriber: Yes
+ - Lifetime value: > $100
+ - Engagement: High
+```
+
+## Using audiences
+
+### Targeted paywalls
+
+Show different paywalls to different audiences:
+
+```
+Audience: New Users
+Paywall: Onboarding paywall with trial emphasis
+
+Audience: Returning Users
+Paywall: Feature-focused paywall
+```
+
+### Experiments
+
+Run experiments on specific audiences:
+
+```
+Experiment: Pricing test
+Audience: US users only
+Variations: Test $9.99 vs $7.99
+```
+
+### Workflows
+
+Trigger workflows based on audience membership:
+
+```
+Workflow: Win-back campaign
+Trigger: App launch
+Conditions:
+ - User in "Lapsed Subscribers" audience
+Action: Present win-back paywall
+```
+
+### Product buckets
+
+Assign different products to different audiences:
+
+```
+Audience: Students
+Product bucket: Student discounts
+
+Audience: Professionals
+Product bucket: Premium offerings
+```
+
+## Dynamic audiences
+
+Audiences update automatically as users meet or no longer meet criteria:
+
+```
+User installs app → Joins "New Users" audience
+After 7 days → Leaves "New Users", joins "Active Users"
+After 30 days inactive → Joins "At Risk" audience
+```
+
+## Audience size
+
+Monitor audience size in the dashboard:
+
+- **Current size**: Number of users currently in audience
+- **Growth trend**: How audience size changes over time
+- **Overlap**: Users in multiple audiences
+
+## Testing audiences
+
+### Preview membership
+
+Check if specific users are in an audience:
+
+```swift
+// iOS example
+let isInAudience = Helium.shared.isUserInAudience("high_value_users")
+```
+
+### Test mode
+
+Simulate audience membership:
+
+```swift
+// iOS example
+Helium.shared.setTestAudience("power_users")
+```
+
+## Best practices
+
+### Clear definitions
+
+Define audiences with clear criteria:
+- ✅ "Users who completed onboarding and used app 5+ times"
+- ❌ "Good users"
+
+### Meaningful segments
+
+Create audiences that matter for your business:
+- Different conversion patterns
+- Different value propositions
+- Different pricing sensitivity
+
+### Avoid over-segmentation
+
+Don't create too many audiences:
+- Harder to manage
+- Smaller sample sizes
+- More complex logic
+
+### Regular review
+
+Periodically review audiences:
+- Are they still relevant?
+- Are sizes appropriate?
+- Are they performing as expected?
+
+## Common audience patterns
+
+### Onboarding stages
+
+```
+New Users: Days since install < 7
+Active Users: Session count > 10
+Power Users: Daily active for 30+ days
+```
+
+### Subscription lifecycle
+
+```
+Trial Users: Active trial
+Subscribers: Active subscription
+Lapsed: Subscription expired < 90 days ago
+Churned: Subscription expired > 90 days ago
+```
+
+### Engagement levels
+
+```
+High Engagement: Sessions > 50, Features used > 10
+Medium Engagement: Sessions 10-50, Features used 3-10
+Low Engagement: Sessions < 10, Features used < 3
+```
+
+### Geographic
+
+```
+North America: US, Canada, Mexico
+Europe: EU countries
+Asia Pacific: APAC countries
+```
+
+### Platform
+
+```
+iOS Users: Platform = iOS
+Android Users: Platform = Android
+Cross-platform: Used both iOS and Android
+```
+
+## Advanced features
+
+### Nested conditions
+
+Combine multiple conditions:
+
+```
+Audience: High-value iOS users
+Rules:
+ - Platform: iOS
+ - AND (
+ Lifetime value > $50
+ OR Previous subscriber: Yes
+ )
+ - AND Session count > 20
+```
+
+### Time-based rules
+
+Include time-based conditions:
+
+```
+Audience: Weekend users
+Rules:
+ - Last active: Weekend
+ - Session count: > 5 on weekends
+```
+
+### Exclusion rules
+
+Define who should NOT be in audience:
+
+```
+Audience: Potential subscribers
+Rules:
+ - Include: All users
+ - Exclude: Current subscribers
+ - Exclude: Trial users
+```
+
+## Analytics
+
+Track audience performance:
+
+- **Conversion rate**: By audience
+- **Revenue**: By audience
+- **Retention**: By audience
+- **Engagement**: By audience
+
+Use insights to refine audience definitions and targeting strategies.
+
+## Integration with other features
+
+Audiences work with:
+
+- **Experiments**: Test variations on specific segments
+- **Workflows**: Trigger different flows for different audiences
+- **Product buckets**: Show different products to different audiences
+- **Paywalls**: Customize content by audience
+
+## Next steps
+
+- Set up [Experiments](/primitives/experiments) with audience targeting
+- Create [Workflows](/primitives/workflows) for different audiences
+- Configure [Product buckets](/primitives/product-buckets) by audience
From b40fc8d199600ae4f382df1192dde1f41b2c46c7 Mon Sep 17 00:00:00 2001
From: "mintlify[bot]" <109931778+mintlify[bot]@users.noreply.github.com>
Date: Tue, 10 Mar 2026 01:35:13 +0000
Subject: [PATCH 16/25] Update primitives/product-buckets.mdx
Co-Authored-By: mintlify[bot] <109931778+mintlify[bot]@users.noreply.github.com>
---
primitives/product-buckets.mdx | 372 +++++++++++++++++++++++++++++++++
1 file changed, 372 insertions(+)
create mode 100644 primitives/product-buckets.mdx
diff --git a/primitives/product-buckets.mdx b/primitives/product-buckets.mdx
new file mode 100644
index 0000000..7a87827
--- /dev/null
+++ b/primitives/product-buckets.mdx
@@ -0,0 +1,372 @@
+---
+title: Product buckets
+description: Dynamically manage product offerings across your app
+---
+
+# Product buckets
+
+Product buckets are dynamic groups of subscription products that can be updated remotely without requiring app updates.
+
+## What are product buckets?
+
+Product buckets allow you to:
+
+- Group related products together
+- Update product offerings remotely
+- Assign products to paywalls dynamically
+- Run pricing experiments
+- Customize offerings by audience or region
+
+## Why use product buckets?
+
+### Flexibility
+
+Change products without app updates:
+- Add new subscription tiers
+- Remove discontinued products
+- Adjust product ordering
+- Run limited-time promotions
+
+### Consistency
+
+Manage products in one place:
+- Single source of truth
+- Consistent across platforms
+- Centralized control
+
+### Experimentation
+
+Test different product combinations:
+- A/B test pricing
+- Try different product orders
+- Test promotional offerings
+
+## Creating product buckets
+
+In the Helium dashboard:
+
+1. Navigate to **Product Buckets**
+2. Click **Create Bucket**
+3. Name your bucket
+4. Add products
+5. Set product order
+6. Save
+
+## Bucket structure
+
+A product bucket contains:
+
+```
+Bucket: premium_subscriptions
+Products:
+ 1. monthly_premium ($9.99/month)
+ 2. annual_premium ($99.99/year)
+ 3. lifetime_premium ($299.99 one-time)
+```
+
+## Using product buckets
+
+### In paywalls
+
+Assign a bucket to a paywall:
+
+1. Edit your paywall
+2. Select **Product Bucket** as product source
+3. Choose your bucket
+4. Products will load dynamically
+
+### In code
+
+Reference products by bucket:
+
+```swift
+// iOS example
+Helium.shared.presentPaywall(productBucket: "premium_subscriptions")
+```
+
+```kotlin
+// Android example
+Helium.presentPaywall(productBucket = "premium_subscriptions")
+```
+
+## Product selection
+
+When a paywall uses a product bucket, Helium:
+
+1. Fetches current products in the bucket
+2. Filters by platform (iOS/Android)
+3. Filters by availability
+4. Returns products in specified order
+
+## Bucket strategies
+
+### Single default bucket
+
+One bucket for all users:
+
+```
+default_products:
+ - monthly_standard
+ - annual_standard
+```
+
+### Audience-specific buckets
+
+Different buckets for different audiences:
+
+```
+new_user_products:
+ - monthly_with_trial
+ - annual_with_discount
+
+existing_user_products:
+ - monthly_standard
+ - annual_standard
+```
+
+### Regional buckets
+
+Customize by region:
+
+```
+us_products:
+ - monthly_9_99
+ - annual_99_99
+
+eu_products:
+ - monthly_8_99
+ - annual_89_99
+```
+
+### Promotional buckets
+
+Special offers:
+
+```
+black_friday_products:
+ - monthly_discounted
+ - annual_50_off
+```
+
+## Updating buckets
+
+Changes take effect immediately:
+
+1. Edit bucket in dashboard
+2. Add, remove, or reorder products
+3. Save changes
+4. Next paywall load uses updated products
+
+No app update or review required.
+
+## Product ordering
+
+Order matters for display:
+
+### Most popular first
+
+```
+1. annual_premium (Most popular)
+2. monthly_premium
+3. lifetime_premium
+```
+
+### Highest value first
+
+```
+1. lifetime_premium
+2. annual_premium
+3. monthly_premium
+```
+
+### Strategic ordering
+
+```
+1. annual_premium (Highlighted)
+2. monthly_premium (Default)
+3. weekly_premium (Budget option)
+```
+
+## Platform-specific products
+
+Include products for specific platforms:
+
+```
+cross_platform_bucket:
+ - monthly_ios (iOS only)
+ - monthly_android (Android only)
+ - annual_ios (iOS only)
+ - annual_android (Android only)
+```
+
+Helium automatically filters by platform.
+
+## Fallback handling
+
+Include buckets in fallback bundles:
+
+1. Export bucket configuration
+2. Include in app bundle
+3. SDK uses local copy when offline
+
+## Best practices
+
+### Naming conventions
+
+Use descriptive names:
+- ✅ `premium_subscriptions`
+- ✅ `trial_offers`
+- ✅ `regional_us`
+- ❌ `bucket1`
+- ❌ `temp`
+
+### Product limits
+
+Keep buckets focused:
+- 2-4 products per bucket (optimal)
+- Maximum 6-8 products
+- Too many options reduce conversion
+
+### Documentation
+
+Document your buckets:
+- Purpose of each bucket
+- Which audiences see it
+- When to use it
+- Product details
+
+### Testing
+
+Test bucket changes:
+- Verify products load correctly
+- Check pricing displays properly
+- Test on all platforms
+- Validate fallback behavior
+
+### Version control
+
+Track bucket changes:
+- Document what changed
+- When it changed
+- Why it changed
+- Expected impact
+
+## Common patterns
+
+### Seasonal promotions
+
+```
+# Normal times
+default_bucket: standard_products
+
+# Holiday season
+default_bucket: holiday_sale_products
+```
+
+### A/B testing
+
+```
+experiment_control: standard_products
+experiment_variant_a: premium_products
+experiment_variant_b: budget_products
+```
+
+### Upgrade paths
+
+```
+free_to_basic: basic_products
+basic_to_premium: premium_products
+premium_to_pro: pro_products
+```
+
+### Trial strategies
+
+```
+new_users: products_with_7day_trial
+returning_users: products_with_3day_trial
+previous_subscribers: products_no_trial
+```
+
+## Analytics
+
+Track bucket performance:
+
+- **Conversion rate**: By bucket
+- **Revenue**: By bucket
+- **Product selection**: Which products users choose
+- **Bucket usage**: How often each bucket is shown
+
+## Integration with other features
+
+Product buckets work with:
+
+- **Paywalls**: Dynamic product assignment
+- **Audiences**: Show different buckets to different segments
+- **Experiments**: Test different product combinations
+- **Workflows**: Conditionally select buckets
+
+## Advanced usage
+
+### Dynamic bucket selection
+
+Select bucket based on user attributes:
+
+```swift
+// iOS example
+let bucket = user.isNewUser ? "trial_products" : "standard_products"
+Helium.shared.presentPaywall(productBucket: bucket)
+```
+
+### Fallback chains
+
+Specify fallback buckets:
+
+```
+Primary: regional_us_products
+Fallback: default_products
+```
+
+### Product filtering
+
+Filter products within a bucket:
+
+```swift
+// iOS example
+Helium.shared.presentPaywall(
+ productBucket: "all_products",
+ filter: { product in
+ product.price < 10.0
+ }
+)
+```
+
+## Troubleshooting
+
+### Products not showing
+
+Check:
+- Products exist in App Store Connect / Google Play
+- Products are active and available
+- Platform filter is correct
+- Bucket is assigned to paywall
+
+### Wrong products displaying
+
+Verify:
+- Correct bucket is referenced
+- Product order is as expected
+- Platform-specific products are filtered
+- Cache is up to date
+
+### Fallback not working
+
+Ensure:
+- Fallback bundle is included in app
+- Bucket is exported to fallback
+- Fallback configuration is valid
+
+## Next steps
+
+- Learn about [Paywalls](/primitives/paywalls)
+- Explore [Experiments](/primitives/experiments) with product buckets
+- Set up [Audiences](/primitives/audiences) for targeted product offerings
From 092535319512a10e37b3d253b0529543c206afbb Mon Sep 17 00:00:00 2001
From: "mintlify[bot]" <109931778+mintlify[bot]@users.noreply.github.com>
Date: Tue, 10 Mar 2026 01:35:59 +0000
Subject: [PATCH 17/25] Update events/custom-paywall-events.mdx
Co-Authored-By: mintlify[bot] <109931778+mintlify[bot]@users.noreply.github.com>
---
events/custom-paywall-events.mdx | 337 +++++++++++++++++++++++++++++++
1 file changed, 337 insertions(+)
create mode 100644 events/custom-paywall-events.mdx
diff --git a/events/custom-paywall-events.mdx b/events/custom-paywall-events.mdx
new file mode 100644
index 0000000..d36b775
--- /dev/null
+++ b/events/custom-paywall-events.mdx
@@ -0,0 +1,337 @@
+---
+title: Custom paywall events
+description: Track custom events from your paywalls
+---
+
+# Custom paywall events
+
+Custom paywall events allow you to track user interactions and behaviors within your paywalls beyond the standard events Helium automatically tracks.
+
+## What are custom paywall events?
+
+Custom events are user-defined tracking points that capture specific interactions or milestones in your paywall experience.
+
+## Why track custom events?
+
+Custom events help you:
+
+- **Understand user behavior**: See how users interact with paywalls
+- **Optimize conversion**: Identify friction points
+- **Measure engagement**: Track which elements users interact with
+- **Debug issues**: Identify where users drop off
+- **Inform decisions**: Make data-driven improvements
+
+## Automatic events
+
+Helium automatically tracks these events:
+
+- `paywall_viewed`: Paywall was displayed
+- `paywall_dismissed`: User closed the paywall
+- `product_selected`: User tapped a product
+- `purchase_started`: Purchase flow initiated
+- `purchase_completed`: Subscription purchased
+- `purchase_failed`: Purchase encountered an error
+- `restore_started`: User tapped restore purchases
+- `restore_completed`: Restore purchases succeeded
+
+## Creating custom events
+
+Track custom events from your paywalls:
+
+```swift
+// iOS example
+Helium.shared.trackPaywallEvent("feature_comparison_viewed")
+```
+
+```kotlin
+// Android example
+Helium.trackPaywallEvent("feature_comparison_viewed")
+```
+
+## Event properties
+
+Add context with event properties:
+
+```swift
+// iOS example
+Helium.shared.trackPaywallEvent("video_played", properties: [
+ "video_id": "intro_video",
+ "duration": 30,
+ "completed": false
+])
+```
+
+```kotlin
+// Android example
+Helium.trackPaywallEvent("video_played", mapOf(
+ "video_id" to "intro_video",
+ "duration" to 30,
+ "completed" to false
+))
+```
+
+## Common custom events
+
+### User interactions
+
+```swift
+// User tapped FAQ
+Helium.shared.trackPaywallEvent("faq_tapped")
+
+// User expanded feature details
+Helium.shared.trackPaywallEvent("feature_details_expanded", properties: [
+ "feature": "advanced_editor"
+])
+
+// User watched testimonial video
+Helium.shared.trackPaywallEvent("testimonial_video_viewed")
+```
+
+### Navigation
+
+```swift
+// User scrolled to bottom
+Helium.shared.trackPaywallEvent("paywall_scrolled_to_bottom")
+
+// User switched between tabs
+Helium.shared.trackPaywallEvent("tab_changed", properties: [
+ "from_tab": "monthly",
+ "to_tab": "annual"
+])
+```
+
+### Engagement
+
+```swift
+// User spent significant time
+Helium.shared.trackPaywallEvent("paywall_engaged", properties: [
+ "time_spent": 45
+])
+
+// User interacted with calculator
+Helium.shared.trackPaywallEvent("savings_calculator_used", properties: [
+ "calculated_savings": 120
+])
+```
+
+## Event naming conventions
+
+Use clear, consistent names:
+
+### Good names
+
+- `feature_comparison_viewed`
+- `testimonial_video_played`
+- `faq_item_expanded`
+- `pricing_calculator_used`
+
+### Avoid
+
+- `event1`
+- `click`
+- `thing_happened`
+- `test`
+
+## Event properties best practices
+
+### Use consistent types
+
+```swift
+// ✅ Good
+properties: [
+ "duration": 30, // Number
+ "completed": true, // Boolean
+ "video_id": "intro" // String
+]
+
+// ❌ Avoid
+properties: [
+ "duration": "30 seconds", // Should be number
+ "completed": "yes", // Should be boolean
+]
+```
+
+### Keep properties relevant
+
+```swift
+// ✅ Good - relevant properties
+Helium.shared.trackPaywallEvent("product_selected", properties: [
+ "product_id": "monthly_premium",
+ "price": 9.99,
+ "position": 1
+])
+
+// ❌ Too much - irrelevant properties
+Helium.shared.trackPaywallEvent("product_selected", properties: [
+ "product_id": "monthly_premium",
+ "user_name": "John",
+ "device_model": "iPhone 14",
+ "battery_level": 85
+])
+```
+
+## Viewing custom events
+
+### In the dashboard
+
+View custom events in the Helium dashboard:
+
+1. Navigate to **Events**
+2. Filter by event name
+3. View event properties
+4. Analyze trends over time
+
+### Event analytics
+
+Track metrics for custom events:
+
+- **Event count**: How many times event fired
+- **Unique users**: How many users triggered event
+- **Conversion correlation**: How events relate to conversions
+- **Property distribution**: Common property values
+
+## Integration with analytics
+
+Custom events can be forwarded to third-party analytics platforms. See [Third-party analytics integrations](/analytics/third-party-integrations).
+
+## Use cases
+
+### Optimize paywall design
+
+Track which elements users interact with:
+
+```swift
+Helium.shared.trackPaywallEvent("feature_bullet_tapped", properties: [
+ "feature": "unlimited_exports"
+])
+```
+
+Analyze which features resonate most with users.
+
+### Measure content effectiveness
+
+Track engagement with different content:
+
+```swift
+Helium.shared.trackPaywallEvent("testimonial_viewed", properties: [
+ "testimonial_id": "user_123",
+ "position": 2
+])
+```
+
+See which testimonials drive conversions.
+
+### Identify friction points
+
+Track where users hesitate:
+
+```swift
+Helium.shared.trackPaywallEvent("terms_link_tapped")
+Helium.shared.trackPaywallEvent("privacy_policy_viewed")
+```
+
+Understand what concerns users have.
+
+### A/B test insights
+
+Track variant-specific interactions:
+
+```swift
+Helium.shared.trackPaywallEvent("cta_button_tapped", properties: [
+ "variant": "variant_a",
+ "button_text": "Start Free Trial"
+])
+```
+
+## Performance considerations
+
+### Event volume
+
+Be mindful of event volume:
+- Don't track every pixel scroll
+- Focus on meaningful interactions
+- Batch events when possible
+
+### Property size
+
+Keep properties concise:
+- Avoid large strings
+- Don't include sensitive data
+- Limit number of properties
+
+## Privacy and compliance
+
+### User consent
+
+Ensure you have user consent for tracking:
+- Follow GDPR requirements
+- Respect user privacy settings
+- Provide opt-out mechanisms
+
+### Sensitive data
+
+Never track:
+- Personal identifying information
+- Payment details
+- Passwords or credentials
+- Health information
+
+## Testing custom events
+
+### Debug mode
+
+Enable debug logging to verify events:
+
+```swift
+// iOS example
+Helium.shared.setLogLevel(.verbose)
+Helium.shared.trackPaywallEvent("test_event")
+// Check console for event confirmation
+```
+
+### Event validation
+
+Verify events in dashboard:
+1. Trigger event in test environment
+2. Check dashboard for event appearance
+3. Verify properties are correct
+4. Confirm event timing
+
+## Best practices
+
+### Track meaningful events
+
+Focus on events that:
+- Inform product decisions
+- Correlate with conversions
+- Identify user pain points
+- Measure engagement
+
+### Consistent naming
+
+Use a naming convention:
+- `object_action` format (e.g., `video_played`)
+- Lowercase with underscores
+- Descriptive and specific
+
+### Document events
+
+Maintain documentation of:
+- Event names and purposes
+- Property definitions
+- When events fire
+- How to interpret data
+
+### Regular review
+
+Periodically review:
+- Which events are still useful
+- Event volume and performance
+- Data quality
+- New events needed
+
+## Next steps
+
+- Learn about [Revenue tracking](/events/revenue-tracking)
+- Explore [Third-party analytics integrations](/analytics/third-party-integrations)
+- Set up [Experiments](/primitives/experiments) using event data
From 3f9e5481c1114be8117bfac0879d0df9d324041d Mon Sep 17 00:00:00 2001
From: "mintlify[bot]" <109931778+mintlify[bot]@users.noreply.github.com>
Date: Tue, 10 Mar 2026 01:36:29 +0000
Subject: [PATCH 18/25] Update events/revenue-tracking.mdx
Co-Authored-By: mintlify[bot] <109931778+mintlify[bot]@users.noreply.github.com>
---
events/revenue-tracking.mdx | 344 ++++++++++++++++++++++++++++++++++++
1 file changed, 344 insertions(+)
create mode 100644 events/revenue-tracking.mdx
diff --git a/events/revenue-tracking.mdx b/events/revenue-tracking.mdx
new file mode 100644
index 0000000..2abb19c
--- /dev/null
+++ b/events/revenue-tracking.mdx
@@ -0,0 +1,344 @@
+---
+title: Revenue tracking
+description: Track and analyze subscription revenue
+---
+
+# Revenue tracking
+
+Revenue tracking allows you to monitor subscription revenue, analyze trends, and measure the financial impact of your monetization strategies.
+
+## What is revenue tracking?
+
+Revenue tracking captures and reports all subscription-related financial events, including:
+
+- New subscriptions
+- Renewals
+- Upgrades and downgrades
+- Refunds
+- Trial conversions
+
+## Automatic revenue tracking
+
+Helium automatically tracks revenue events:
+
+### Purchase events
+
+- **Initial purchase**: First subscription purchase
+- **Renewal**: Automatic subscription renewal
+- **Upgrade**: User upgrades to higher tier
+- **Downgrade**: User downgrades to lower tier
+
+### Revenue events
+
+- **Trial started**: Free trial begins (no revenue)
+- **Trial converted**: Trial converts to paid subscription
+- **Refund**: Subscription refunded
+- **Cancellation**: Subscription cancelled (future revenue impact)
+
+## Revenue metrics
+
+### Key metrics tracked
+
+- **Total revenue**: All subscription revenue
+- **Monthly recurring revenue (MRR)**: Normalized monthly revenue
+- **Annual recurring revenue (ARR)**: Normalized annual revenue
+- **Average revenue per user (ARPU)**: Revenue divided by users
+- **Lifetime value (LTV)**: Predicted total revenue per user
+
+### Cohort analysis
+
+Track revenue by user cohorts:
+- Install date cohorts
+- Subscription start cohorts
+- Geographic cohorts
+- Platform cohorts
+
+## Viewing revenue data
+
+### Dashboard
+
+Access revenue analytics in the Helium dashboard:
+
+1. Navigate to **Analytics**
+2. Select **Revenue**
+3. Choose date range
+4. Filter by product, platform, or region
+
+### Reports
+
+Generate revenue reports:
+- Daily revenue trends
+- Product performance
+- Conversion funnels
+- Retention curves
+
+## Revenue attribution
+
+### Source attribution
+
+Track revenue by acquisition source:
+
+```swift
+// iOS example - Set attribution
+Helium.shared.setUserProperty("acquisition_source", value: "facebook_ads")
+```
+
+Analyze which sources drive highest revenue.
+
+### Campaign attribution
+
+Attribute revenue to specific campaigns:
+
+```swift
+// iOS example
+Helium.shared.setUserProperty("campaign", value: "summer_sale_2024")
+```
+
+### Experiment attribution
+
+Revenue is automatically attributed to experiments:
+- Control vs variant revenue
+- Statistical significance
+- Revenue lift calculations
+
+## Revenue events in code
+
+While Helium tracks revenue automatically, you can access revenue events:
+
+```swift
+// iOS example - Listen for revenue events
+Helium.shared.onRevenueEvent { event in
+ print("Revenue event: \(event.type)")
+ print("Amount: \(event.amount)")
+ print("Product: \(event.productId)")
+}
+```
+
+## Third-party integration
+
+Forward revenue events to analytics platforms:
+
+### Supported platforms
+
+- Google Analytics
+- Firebase Analytics
+- Mixpanel
+- Amplitude
+- Segment
+- Custom webhooks
+
+### Configuration
+
+Configure in the Helium dashboard:
+
+1. Navigate to **Integrations**
+2. Select analytics platform
+3. Enter API credentials
+4. Map revenue events
+5. Enable integration
+
+See [Third-party analytics integrations](/analytics/third-party-integrations) for details.
+
+## Revenue validation
+
+### Receipt validation
+
+Helium automatically validates receipts:
+
+- **iOS**: App Store receipt validation
+- **Android**: Google Play purchase verification
+
+This ensures revenue data is accurate and prevents fraud.
+
+### Server-to-server notifications
+
+Helium processes server notifications from app stores:
+
+- Real-time revenue updates
+- Renewal notifications
+- Cancellation alerts
+- Refund notifications
+
+## Revenue reconciliation
+
+### App store reports
+
+Compare Helium revenue data with app store reports:
+
+1. Export revenue from Helium dashboard
+2. Download app store financial reports
+3. Reconcile differences
+4. Investigate discrepancies
+
+### Common discrepancies
+
+- **Timing differences**: Events may be reported at different times
+- **Refunds**: May appear in different periods
+- **Currency conversion**: Exchange rate differences
+- **Tax handling**: Gross vs net revenue
+
+## Revenue forecasting
+
+### Predictive analytics
+
+Helium provides revenue forecasts based on:
+
+- Historical trends
+- Cohort behavior
+- Retention rates
+- Seasonal patterns
+
+### Scenario modeling
+
+Model revenue impact of changes:
+
+- Price adjustments
+- New product offerings
+- Conversion rate improvements
+- Retention improvements
+
+## Revenue optimization
+
+### Identify opportunities
+
+Use revenue data to find optimization opportunities:
+
+- **Low-converting products**: Consider pricing changes
+- **High-churn products**: Improve value proposition
+- **Seasonal trends**: Plan promotional campaigns
+- **Geographic variations**: Adjust regional pricing
+
+### A/B testing impact
+
+Measure revenue impact of experiments:
+
+```
+Experiment: Pricing test
+Control revenue: $10,000
+Variant revenue: $12,500
+Lift: +25%
+```
+
+## Revenue alerts
+
+Set up alerts for revenue events:
+
+### Threshold alerts
+
+```
+Alert: Daily revenue below $1,000
+Notification: Email to team
+```
+
+### Anomaly detection
+
+```
+Alert: Revenue drops >20% from average
+Notification: Slack message
+```
+
+### Milestone alerts
+
+```
+Alert: Monthly revenue exceeds $100,000
+Notification: Celebrate! 🎉
+```
+
+## Privacy and compliance
+
+### Data handling
+
+Revenue data is:
+- Encrypted in transit and at rest
+- Stored securely
+- Accessible only to authorized users
+- Retained per your data retention policy
+
+### Compliance
+
+Helium revenue tracking complies with:
+- GDPR
+- CCPA
+- App Store guidelines
+- Google Play policies
+
+## Best practices
+
+### Regular monitoring
+
+- Review revenue daily
+- Analyze trends weekly
+- Deep dive monthly
+- Strategic planning quarterly
+
+### Segment analysis
+
+Analyze revenue by:
+- Product
+- Platform
+- Region
+- User segment
+- Acquisition source
+
+### Combine with other metrics
+
+Don't look at revenue in isolation:
+- Conversion rates
+- Retention rates
+- User engagement
+- Customer satisfaction
+
+### Act on insights
+
+Use revenue data to:
+- Inform product decisions
+- Optimize pricing
+- Improve user experience
+- Guide marketing spend
+
+## Troubleshooting
+
+### Missing revenue events
+
+If revenue isn't tracking:
+
+1. Verify SDK integration
+2. Check receipt validation
+3. Confirm server notifications are enabled
+4. Review error logs
+
+### Incorrect amounts
+
+If revenue amounts are wrong:
+
+1. Check currency conversion settings
+2. Verify tax handling configuration
+3. Confirm product pricing in app stores
+4. Review refund processing
+
+### Delayed reporting
+
+Revenue may be delayed due to:
+- App store processing time
+- Server notification delays
+- Time zone differences
+- Batch processing schedules
+
+## API access
+
+Access revenue data programmatically:
+
+```bash
+# Example API request
+curl -X GET "https://api.helium.com/v1/revenue" \
+ -H "Authorization: Bearer YOUR_API_KEY" \
+ -H "Content-Type: application/json"
+```
+
+See API documentation for details.
+
+## Next steps
+
+- Set up [Third-party analytics integrations](/analytics/third-party-integrations)
+- Learn about [Custom paywall events](/events/custom-paywall-events)
+- Explore [Experiments](/primitives/experiments) to optimize revenue
From 1a0cc7071be66600d8600030359b109c49452d8a Mon Sep 17 00:00:00 2001
From: "mintlify[bot]" <109931778+mintlify[bot]@users.noreply.github.com>
Date: Tue, 10 Mar 2026 01:37:23 +0000
Subject: [PATCH 19/25] Update analytics/third-party-integrations.mdx
Co-Authored-By: mintlify[bot] <109931778+mintlify[bot]@users.noreply.github.com>
---
analytics/third-party-integrations.mdx | 460 +++++++++++++++++++++++++
1 file changed, 460 insertions(+)
create mode 100644 analytics/third-party-integrations.mdx
diff --git a/analytics/third-party-integrations.mdx b/analytics/third-party-integrations.mdx
new file mode 100644
index 0000000..6f072b2
--- /dev/null
+++ b/analytics/third-party-integrations.mdx
@@ -0,0 +1,460 @@
+---
+title: Third-party analytics integrations
+description: Connect Helium with your analytics platforms
+---
+
+# Third-party analytics integrations
+
+Integrate Helium with third-party analytics platforms to get a complete view of your app's performance and user behavior.
+
+## Why integrate analytics?
+
+Third-party integrations allow you to:
+
+- **Centralize data**: View subscription data alongside other app metrics
+- **Cross-reference events**: Correlate subscription events with user behavior
+- **Custom analysis**: Use your preferred analytics tools
+- **Data warehouse**: Export to your data infrastructure
+- **Attribution**: Connect revenue to acquisition sources
+
+## Supported platforms
+
+Helium integrates with popular analytics platforms:
+
+### Google Analytics
+
+Track subscription events in Google Analytics:
+- Purchase events
+- Revenue tracking
+- User properties
+- Custom dimensions
+
+### Firebase Analytics
+
+Send events to Firebase:
+- Automatic event mapping
+- User properties sync
+- Revenue events
+- Audience integration
+
+### Mixpanel
+
+Forward events to Mixpanel:
+- Event tracking
+- User profiles
+- Revenue analytics
+- Funnel analysis
+
+### Amplitude
+
+Integrate with Amplitude:
+- Event streaming
+- User properties
+- Revenue tracking
+- Cohort analysis
+
+### Segment
+
+Use Segment as a hub:
+- Single integration point
+- Forward to multiple destinations
+- Event transformation
+- Data governance
+
+### Custom webhooks
+
+Send events to your own endpoints:
+- Real-time event delivery
+- Custom payload format
+- Retry logic
+- Authentication support
+
+## Setting up integrations
+
+### In the dashboard
+
+1. Navigate to **Integrations**
+2. Select your analytics platform
+3. Enter API credentials
+4. Configure event mapping
+5. Test integration
+6. Enable
+
+### Configuration options
+
+For each integration, configure:
+
+- **Events to forward**: Select which events to send
+- **Event mapping**: Map Helium events to platform events
+- **User properties**: Sync user attributes
+- **Revenue tracking**: Enable revenue event forwarding
+
+## Event mapping
+
+### Automatic mapping
+
+Helium automatically maps common events:
+
+| Helium Event | Google Analytics | Firebase | Mixpanel |
+|--------------|------------------|----------|----------|
+| paywall_viewed | view_item | paywall_viewed | Paywall Viewed |
+| purchase_completed | purchase | in_app_purchase | Purchase |
+| trial_started | begin_checkout | trial_started | Trial Started |
+| subscription_renewed | purchase | subscription_renewed | Subscription Renewed |
+
+### Custom mapping
+
+Override default mappings:
+
+```json
+{
+ "paywall_viewed": {
+ "google_analytics": "view_subscription_offer",
+ "mixpanel": "Subscription Offer Viewed"
+ }
+}
+```
+
+## User properties
+
+Sync user properties to analytics platforms:
+
+### Standard properties
+
+- Subscription status
+- Product ID
+- Trial status
+- Revenue (lifetime value)
+- First purchase date
+
+### Custom properties
+
+Add custom user properties:
+
+```swift
+// iOS example
+Helium.shared.setUserProperty("user_tier", value: "premium")
+Helium.shared.setUserProperty("signup_source", value: "organic")
+```
+
+These sync to connected analytics platforms.
+
+## Revenue tracking
+
+### Automatic revenue forwarding
+
+Revenue events are automatically sent to analytics platforms with:
+
+- Transaction ID
+- Product ID
+- Revenue amount
+- Currency
+- Timestamp
+
+### Platform-specific formats
+
+Helium formats revenue data for each platform:
+
+#### Google Analytics
+
+```javascript
+{
+ event: "purchase",
+ transaction_id: "txn_123",
+ value: 9.99,
+ currency: "USD",
+ items: [{
+ item_id: "monthly_premium",
+ item_name: "Monthly Premium",
+ price: 9.99
+ }]
+}
+```
+
+#### Mixpanel
+
+```javascript
+{
+ event: "Purchase",
+ properties: {
+ "$transaction_id": "txn_123",
+ "$amount": 9.99,
+ "product_id": "monthly_premium"
+ }
+}
+```
+
+## Google Analytics setup
+
+### Prerequisites
+
+- Google Analytics 4 property
+- Measurement ID
+- API secret (for server-side events)
+
+### Configuration
+
+1. In Helium dashboard, go to **Integrations > Google Analytics**
+2. Enter Measurement ID
+3. Enter API Secret
+4. Select events to forward
+5. Test and enable
+
+### Recommended events
+
+Enable these events:
+- `purchase` - Subscription purchases
+- `begin_checkout` - Trial starts
+- `view_item` - Paywall views
+- `refund` - Subscription refunds
+
+## Firebase Analytics setup
+
+### Prerequisites
+
+- Firebase project
+- Firebase SDK integrated in app
+- Service account credentials
+
+### Configuration
+
+1. Download service account JSON from Firebase Console
+2. In Helium dashboard, go to **Integrations > Firebase**
+3. Upload service account credentials
+4. Select events to forward
+5. Test and enable
+
+### User properties
+
+Firebase user properties are automatically synced:
+- `subscription_status`
+- `product_id`
+- `trial_status`
+
+## Mixpanel setup
+
+### Prerequisites
+
+- Mixpanel project
+- Project token
+- API secret (for server-side events)
+
+### Configuration
+
+1. In Helium dashboard, go to **Integrations > Mixpanel**
+2. Enter Project Token
+3. Enter API Secret
+4. Select events to forward
+5. Test and enable
+
+### Revenue tracking
+
+Mixpanel revenue is tracked using:
+- `$transaction` special event
+- `$amount` property
+- User profile revenue updates
+
+## Amplitude setup
+
+### Prerequisites
+
+- Amplitude project
+- API key
+
+### Configuration
+
+1. In Helium dashboard, go to **Integrations > Amplitude**
+2. Enter API Key
+3. Select events to forward
+4. Test and enable
+
+### User properties
+
+Amplitude user properties include:
+- `subscription_status`
+- `ltv` (lifetime value)
+- `first_purchase_date`
+
+## Segment setup
+
+### Prerequisites
+
+- Segment workspace
+- Write key
+
+### Configuration
+
+1. In Helium dashboard, go to **Integrations > Segment**
+2. Enter Write Key
+3. Select events to forward
+4. Test and enable
+
+### Advantages
+
+Using Segment allows you to:
+- Forward to multiple destinations
+- Transform events
+- Manage data governance
+- Reduce integration complexity
+
+## Custom webhooks
+
+### Setup
+
+1. In Helium dashboard, go to **Integrations > Webhooks**
+2. Enter webhook URL
+3. Configure authentication (optional)
+4. Select events to forward
+5. Test and enable
+
+### Payload format
+
+Webhook payloads are sent as JSON:
+
+```json
+{
+ "event": "purchase_completed",
+ "user_id": "user_123",
+ "timestamp": "2024-03-10T12:00:00Z",
+ "properties": {
+ "product_id": "monthly_premium",
+ "price": 9.99,
+ "currency": "USD",
+ "transaction_id": "txn_123"
+ }
+}
+```
+
+### Authentication
+
+Secure webhooks with:
+- **API key**: Include in header
+- **HMAC signature**: Verify payload integrity
+- **OAuth**: Token-based authentication
+
+### Retry logic
+
+Failed webhook deliveries are retried:
+- Immediate retry
+- Exponential backoff
+- Up to 5 retry attempts
+- 24-hour retry window
+
+## Testing integrations
+
+### Test mode
+
+Test integrations before enabling:
+
+1. Enable test mode in integration settings
+2. Trigger test events in your app
+3. Verify events appear in analytics platform
+4. Check event properties and formatting
+5. Confirm revenue tracking
+
+### Debug logs
+
+View integration logs in dashboard:
+- Events sent
+- Delivery status
+- Error messages
+- Retry attempts
+
+## Best practices
+
+### Event selection
+
+Don't forward all events:
+- Select relevant events only
+- Avoid duplicate tracking
+- Consider data volume limits
+- Monitor analytics platform costs
+
+### User identification
+
+Ensure consistent user IDs:
+- Use same ID across platforms
+- Set user ID early in app lifecycle
+- Handle anonymous users appropriately
+
+### Data quality
+
+Maintain data quality:
+- Test integrations thoroughly
+- Monitor for errors
+- Validate event properties
+- Regular audits
+
+### Privacy compliance
+
+Respect user privacy:
+- Obtain necessary consents
+- Honor opt-out requests
+- Follow platform policies
+- Comply with regulations (GDPR, CCPA)
+
+## Troubleshooting
+
+### Events not appearing
+
+If events aren't showing in analytics platform:
+
+1. Check integration is enabled
+2. Verify API credentials
+3. Confirm event mapping
+4. Review error logs
+5. Check platform-specific delays
+
+### Incorrect data
+
+If data is incorrect:
+
+1. Verify event property mapping
+2. Check currency conversion
+3. Confirm user ID matching
+4. Review timestamp handling
+
+### Rate limiting
+
+If hitting rate limits:
+
+1. Reduce event volume
+2. Batch events if supported
+3. Implement sampling
+4. Contact platform support
+
+## Data privacy
+
+### User consent
+
+Obtain user consent before forwarding data:
+
+```swift
+// iOS example
+if user.hasAnalyticsConsent {
+ Helium.shared.enableAnalyticsIntegrations()
+} else {
+ Helium.shared.disableAnalyticsIntegrations()
+}
+```
+
+### Data minimization
+
+Only forward necessary data:
+- Essential event properties
+- Required user attributes
+- Relevant revenue information
+
+### Compliance
+
+Integrations comply with:
+- GDPR
+- CCPA
+- Platform-specific policies
+- Industry regulations
+
+## Next steps
+
+- Learn about [Custom paywall events](/events/custom-paywall-events)
+- Explore [Revenue tracking](/events/revenue-tracking)
+- Set up [Experiments](/primitives/experiments) with analytics data
From ce9bcade4ebc1499184b6af9a34a79e73d3cace5 Mon Sep 17 00:00:00 2001
From: "mintlify[bot]" <109931778+mintlify[bot]@users.noreply.github.com>
Date: Tue, 10 Mar 2026 01:37:53 +0000
Subject: [PATCH 20/25] Update migrations/overview.mdx
Co-Authored-By: mintlify[bot] <109931778+mintlify[bot]@users.noreply.github.com>
---
migrations/overview.mdx | 164 ++++++++++++++++++++++++++++++++++++++++
1 file changed, 164 insertions(+)
create mode 100644 migrations/overview.mdx
diff --git a/migrations/overview.mdx b/migrations/overview.mdx
new file mode 100644
index 0000000..a54a11c
--- /dev/null
+++ b/migrations/overview.mdx
@@ -0,0 +1,164 @@
+---
+title: Migrations
+description: Migrate between Helium SDK versions
+---
+
+# Migrations
+
+This guide helps you migrate between different versions of the Helium SDK.
+
+## Available migration guides
+
+Select your platform and version to view the migration guide:
+
+### iOS
+
+
+
+ Migrate from iOS SDK version 3.x to 4.x
+
+
+ Migrate from iOS SDK version 2.x to 3.x
+
+
+
+### Android
+
+
+ Migrate from Android SDK version 0.x to 4.x
+
+
+## Migration best practices
+
+### Before you migrate
+
+1. **Review changelog**: Read the full changelog for breaking changes
+2. **Test thoroughly**: Test migration in development environment first
+3. **Backup code**: Commit current working code before starting
+4. **Plan timing**: Schedule migration during low-traffic periods
+5. **Communicate**: Inform team members about upcoming changes
+
+### During migration
+
+1. **Follow guide**: Complete all steps in the migration guide
+2. **Update dependencies**: Ensure all dependencies are compatible
+3. **Fix deprecations**: Address all deprecation warnings
+4. **Test features**: Verify all features work as expected
+5. **Check analytics**: Confirm events are tracking correctly
+
+### After migration
+
+1. **Monitor errors**: Watch for crashes or errors in production
+2. **Verify revenue**: Ensure purchases are processing correctly
+3. **Check analytics**: Confirm data is flowing to analytics platforms
+4. **Update documentation**: Document any custom changes made
+5. **Plan next steps**: Consider adopting new features
+
+## Common migration tasks
+
+### Updating initialization
+
+Most migrations require updating SDK initialization:
+
+```swift
+// Old (example)
+Helium.configure(apiKey: "your-api-key")
+
+// New (example)
+Helium.configure(
+ apiKey: "your-api-key",
+ options: HeliumOptions()
+)
+```
+
+### Updating method calls
+
+Method signatures may change:
+
+```swift
+// Old (example)
+Helium.shared.presentPaywall()
+
+// New (example)
+Helium.shared.presentPaywall(completion: { result in
+ // Handle result
+})
+```
+
+### Updating event tracking
+
+Event tracking APIs may be updated:
+
+```swift
+// Old (example)
+Helium.shared.logEvent("custom_event")
+
+// New (example)
+Helium.shared.trackEvent("custom_event", properties: [:])
+```
+
+## Breaking changes
+
+Migration guides clearly identify breaking changes:
+
+- **API changes**: Method signatures or parameters changed
+- **Behavior changes**: Functionality works differently
+- **Removed features**: Features no longer supported
+- **New requirements**: Additional setup or configuration needed
+
+## Deprecation timeline
+
+Helium follows a deprecation policy:
+
+1. **Deprecation announced**: Feature marked as deprecated
+2. **Grace period**: Feature continues to work (typically 6-12 months)
+3. **Removal**: Feature removed in next major version
+
+Always address deprecation warnings promptly.
+
+## Getting help
+
+If you encounter issues during migration:
+
+1. **Check migration guide**: Ensure all steps were completed
+2. **Review changelog**: Look for additional context
+3. **Search documentation**: Look for related topics
+4. **Contact support**: Email support@tryhelium.com with details
+
+## Version compatibility
+
+### SDK versions
+
+Ensure SDK versions are compatible:
+
+- iOS SDK 4.x requires iOS 13.0+
+- Android SDK 4.x requires Android 5.0+ (API 21+)
+- React Native SDK requires React Native 0.64+
+- Flutter SDK requires Flutter 2.0+
+
+### Platform versions
+
+Check platform requirements:
+
+- Xcode version for iOS
+- Android Studio version for Android
+- Node version for React Native
+- Dart version for Flutter
+
+## Rollback plan
+
+If migration causes issues:
+
+1. **Revert code**: Return to previous version
+2. **Restore dependencies**: Downgrade SDK version
+3. **Redeploy**: Push previous working version
+4. **Investigate**: Determine root cause
+5. **Plan retry**: Address issues before retrying migration
+
+## Next steps
+
+Select your migration guide:
+
+- [iOS 3.x to 4.x](/migrations/ios-3-to-4)
+- [iOS 2.x to 3.x](/migrations/ios-2-to-3)
+- [Android 0.x to 4.x](/migrations/android-0-to-4)
From 87fbe4b63498463dc4c35ac8b215ccfe0613bb08 Mon Sep 17 00:00:00 2001
From: "mintlify[bot]" <109931778+mintlify[bot]@users.noreply.github.com>
Date: Tue, 10 Mar 2026 01:38:15 +0000
Subject: [PATCH 21/25] Update docs.json
Co-Authored-By: mintlify[bot] <109931778+mintlify[bot]@users.noreply.github.com>
---
docs.json | 56 +++++++++++++++++++++++++++++++++++--------------------
1 file changed, 36 insertions(+), 20 deletions(-)
diff --git a/docs.json b/docs.json
index d7f6f1e..8c27bc4 100644
--- a/docs.json
+++ b/docs.json
@@ -11,48 +11,64 @@
"navigation": {
"groups": [
{
- "group": "Getting Started",
+ "group": "Introduction",
"icon": "flag",
"pages": [
- "getting-started/introduction",
- "getting-started/quickstart"
+ "introduction/what-you-can-do",
+ "introduction/billing-setup",
+ "introduction/contact"
]
},
{
"group": "SDK Quickstarts",
"icon": "code",
"pages": [
- "sdk/quickstart-ios",
- "sdk/quickstart-android",
- "sdk/quickstart-react-native",
- "sdk/quickstart-flutter",
- "sdk/helium-events"
+ "sdk-quickstarts/overview",
+ "sdk-quickstarts/paywall-presentation",
+ "sdk-quickstarts/feature-availability",
+ "sdk-quickstarts/fallbacks",
+ "sdk-quickstarts/storekit-testing"
]
},
{
- "group": "Guides",
- "icon": "compass",
+ "group": "Primitives",
+ "icon": "cube",
"pages": [
- "guides/revenue-reporting",
- "guides/fallback-bundle",
- "guides/ways-to-show-paywall",
- "guides/third-party-analytics",
- "guides/custom-events",
- "guides/storekit-testing"
+ {
+ "group": "Paywalls",
+ "pages": [
+ "primitives/paywalls",
+ "primitives/paywalls/localization",
+ "primitives/paywalls/product-buckets"
+ ]
+ },
+ "primitives/workflows",
+ "primitives/triggers",
+ "primitives/experiments",
+ "primitives/audiences",
+ "primitives/product-buckets"
]
},
{
- "group": "SDK Reference",
- "icon": "book-open",
+ "group": "Events",
+ "icon": "chart-line",
"pages": [
- "sdk-reference/sdk-features",
- "sdk-reference/fallback-causes"
+ "events/custom-paywall-events",
+ "events/revenue-tracking"
+ ]
+ },
+ {
+ "group": "Analytics",
+ "icon": "chart-bar",
+ "pages": [
+ "analytics/third-party-integrations"
]
},
{
"group": "Migrations",
"icon": "arrow-up-right-dots",
"pages": [
+ "migrations/overview",
"migrations/ios-3-to-4",
"migrations/android-0-to-4",
"migrations/ios-2-to-3"
From d34fabe4b6ed39b9cc43f81ec86b7a1948413dc9 Mon Sep 17 00:00:00 2001
From: "mintlify[bot]" <109931778+mintlify[bot]@users.noreply.github.com>
Date: Fri, 13 Mar 2026 02:12:46 +0000
Subject: [PATCH 22/25] Restructure introduction and SDK quickstarts sections
---
docs.json | 37 +-
images/Screenshot2026-03-12at12.48.32PM.png | Bin 0 -> 183831 bytes
images/Screenshot2026-03-12at12.55.29PM.png | Bin 0 -> 115348 bytes
images/Screenshot2026-03-12at4.55.05PM-1.png | Bin 0 -> 274070 bytes
images/Screenshot2026-03-12at4.55.05PM.png | Bin 0 -> 274070 bytes
images/Screenshot2026-03-12at5.01.55PM.png | Bin 0 -> 222618 bytes
images/Screenshot2026-03-12at5.02.25PM.png | Bin 0 -> 259238 bytes
images/Screenshot2026-03-12at5.03.10PM.png | Bin 0 -> 121750 bytes
introduction/billing-setup.mdx | 38 --
introduction/contact.mdx | 41 --
introduction/introduction.mdx | 40 ++
introduction/quickstart.mdx | 93 ++++
introduction/what-you-can-do.mdx | 28 --
sdk-quickstarts/android.mdx | 387 +++++++++++++++++
sdk-quickstarts/feature-availability.mdx | 109 +++--
sdk-quickstarts/flutter.mdx | 334 ++++++++++++++
sdk-quickstarts/i-os.mdx | 434 +++++++++++++++++++
sdk-quickstarts/overview.mdx | 21 +-
sdk-quickstarts/paywall-presentation.mdx | 71 ---
sdk-quickstarts/react-native.mdx | 415 ++++++++++++++++++
sdk-quickstarts/storekit-testing.mdx | 124 ------
21 files changed, 1781 insertions(+), 391 deletions(-)
create mode 100644 images/Screenshot2026-03-12at12.48.32PM.png
create mode 100644 images/Screenshot2026-03-12at12.55.29PM.png
create mode 100644 images/Screenshot2026-03-12at4.55.05PM-1.png
create mode 100644 images/Screenshot2026-03-12at4.55.05PM.png
create mode 100644 images/Screenshot2026-03-12at5.01.55PM.png
create mode 100644 images/Screenshot2026-03-12at5.02.25PM.png
create mode 100644 images/Screenshot2026-03-12at5.03.10PM.png
delete mode 100644 introduction/billing-setup.mdx
delete mode 100644 introduction/contact.mdx
create mode 100644 introduction/introduction.mdx
create mode 100644 introduction/quickstart.mdx
delete mode 100644 introduction/what-you-can-do.mdx
create mode 100644 sdk-quickstarts/android.mdx
create mode 100644 sdk-quickstarts/flutter.mdx
create mode 100644 sdk-quickstarts/i-os.mdx
delete mode 100644 sdk-quickstarts/paywall-presentation.mdx
create mode 100644 sdk-quickstarts/react-native.mdx
delete mode 100644 sdk-quickstarts/storekit-testing.mdx
diff --git a/docs.json b/docs.json
index 8c27bc4..fd81a75 100644
--- a/docs.json
+++ b/docs.json
@@ -9,14 +9,22 @@
},
"favicon": "/favicon.svg",
"navigation": {
+ "global": {
+ "anchors": [
+ {
+ "anchor": "More Info",
+ "icon": "lightbulb",
+ "href": "https://tryhelium.com"
+ }
+ ]
+ },
"groups": [
{
"group": "Introduction",
"icon": "flag",
"pages": [
- "introduction/what-you-can-do",
- "introduction/billing-setup",
- "introduction/contact"
+ "introduction/introduction",
+ "introduction/quickstart"
]
},
{
@@ -24,10 +32,11 @@
"icon": "code",
"pages": [
"sdk-quickstarts/overview",
- "sdk-quickstarts/paywall-presentation",
- "sdk-quickstarts/feature-availability",
- "sdk-quickstarts/fallbacks",
- "sdk-quickstarts/storekit-testing"
+ "sdk-quickstarts/i-os",
+ "sdk-quickstarts/android",
+ "sdk-quickstarts/react-native",
+ "sdk-quickstarts/flutter",
+ "sdk-quickstarts/feature-availability"
]
},
{
@@ -39,7 +48,8 @@
"pages": [
"primitives/paywalls",
"primitives/paywalls/localization",
- "primitives/paywalls/product-buckets"
+ "primitives/paywalls/product-buckets",
+ "sdk-quickstarts/fallbacks"
]
},
"primitives/workflows",
@@ -74,16 +84,7 @@
"migrations/ios-2-to-3"
]
}
- ],
- "global": {
- "anchors": [
- {
- "anchor": "More Info",
- "href": "https://tryhelium.com",
- "icon": "lightbulb"
- }
- ]
- }
+ ]
},
"logo": {
"light": "/logo/LargeLogo-cropped.svg",
diff --git a/images/Screenshot2026-03-12at12.48.32PM.png b/images/Screenshot2026-03-12at12.48.32PM.png
new file mode 100644
index 0000000000000000000000000000000000000000..62687f0d5ea6cda8e06227e225d71b3225788e08
GIT binary patch
literal 183831
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