Skills cover SDK integration, building flows and paywalls, pre-publish audits, placement migration, and more. Describe the task in plain language and your agent picks the skill.
You don’t have to move your purchases to Adapty to use its flows. In Observer mode, your code keeps making every purchase, while Adapty renders the paywall or onboarding, decides who sees it, A/B tests it, and reports on the result.
This guide covers what changes, what doesn’t, and what the setup takes.
Nothing about your billing changes. Adapty renders the flow and hands the purchase tap to your code, which makes the charge.
Create your products in Adapty
Skip this section if nothing in your flow shows a price or takes a purchase — a flow of onboarding screens alone needs no products in Adapty.
As soon as a screen presents products, create a product in Adapty for each subscription or one-time purchase it offers. A flow reads the price on the card from the product, so the card shows the current store price, you can A/B test that price, and Adapty groups revenue by product in analytics.
A product in Adapty points at the store product you already sell, so creating one doesn’t move billing: your code still makes every charge. Each product names an access level, and in Observer mode Adapty doesn’t grant it — your code keeps owning access — but a product needs one.
The Adapty CLI creates products without opening the dashboard. Install it (Node.js 18 or later) and sign in:
npm install -g adapty
adapty auth login
Get your app ID, then the access level to attach — every new app starts with a premium one:
adapty apps list
adapty access-levels list --app <app-id>
Then create one Adapty product for each store product you sell, using the product IDs from App Store Connect and Google Play Console:
Pass --period lifetime for a one-time purchase, and --stripe-product-id with --stripe-price-id (or the Paddle pair) for something you sell on the web. products create lists every flag. Store product IDs can’t be changed after creation, so pointing a product at a different store product means creating a new product.
Warning
A product element with nothing assigned blocks saving and publishing, so you find out in the builder. A Purchase action with no product set saves fine and fails on the device — the button does nothing. Set a product on every Purchase action.
Or skip products and write prices as static text
A flow with no product element saves and publishes, so you can type prices into the text and have your own code decide what a tap buys. What it costs you:
You keep every price in two places — the store and the flow’s text — and they drift as soon as you change one.
No price A/B tests, which is most of what a flow is for.
Charts and integrations group revenue less cleanly, since Adapty only learns the product from the transaction you report.
Your code maps each tapped element to a product, instead of receiving one from the flow.
Present the flow and make the purchase in your own code. Adapty hands the purchase tap to a handler you register.
Report the transaction with the paywall variation ID of the purchased product, so the purchase reaches analytics attributed to the paywall that sold it.
Steps 4 and 5 differ per platform. In every snippet, flow is the AdaptyFlow you fetched for the placement, product is the AdaptyPaywallProduct the user tapped, and myPurchaseApi or yourBillingClient stands in for the purchase code you already have.
Pass an AdaptyObserverModeResolver to getFlowConfiguration(forFlow:observerModeResolver:). Adapty calls the resolver on a purchase tap instead of making the purchase itself.
final class MyObserverModeResolver: AdaptyObserverModeResolver { func observerMode( didInitiatePurchase product: AdaptyPaywallProduct, onStartPurchase: @MainActor @Sendable @escaping () -> Void, onFinishPurchase: @MainActor @Sendable @escaping () -> Void ) { Task { @MainActor in onStartPurchase() // the flow shows its loading indicator do { // your own purchase code, returning StoreKit's VerificationResult<Transaction> let verificationResult = try await myPurchaseApi.purchase(product.vendorProductId) try await Adapty.reportTransaction(verificationResult, withVariationId: product.variationId) } catch { // handle the error } onFinishPurchase() // the flow hides the loading indicator } } func observerModeDidInitiateRestorePurchases( onStartRestore: @MainActor @Sendable @escaping () -> Void, onFinishRestore: @MainActor @Sendable @escaping () -> Void ) { Task { @MainActor in onStartRestore() try? await myPurchaseApi.restore() onFinishRestore() } }}
Then present the flow with the resolver attached:
do { let flowConfiguration = try await AdaptyUI.getFlowConfiguration( forFlow: flow, observerModeResolver: MyObserverModeResolver() ) let visualFlow = try AdaptyUI.flowController( with: flowConfiguration, delegate: self // an AdaptyFlowControllerDelegate ) present(visualFlow, animated: true)} catch { // handle the error}
Pass an AdaptyUiObserverModeHandler when you create the flow view — the handler is a parameter of AdaptyUI.getFlowView, AdaptyFlowScreen, and AdaptyFlowView. Its onPurchaseInitiated receives the purchase tap. getRestoreHandler is optional — skip it and restore stays with the SDK.
Warning
Always pass the handler. Without it, the SDK completes the purchase itself — the user is charged through Adapty, and only a log warning says so. On iOS the same omission fails the purchase instead.
Pass onObserverPurchaseInitiated and onObserverRestoreInitiated as props on AdaptyFlowView, or register them with view.setEventHandlers.
import React, { useCallback } from 'react';import { AdaptyFlowView, adapty } from 'react-native-adapty';import type { FlowEventHandlers } from 'react-native-adapty';function MyFlow({ flow }) { const onObserverPurchaseInitiated = useCallback< FlowEventHandlers['onObserverPurchaseInitiated'] >((product, onStartPurchase, onFinishPurchase) => { onStartPurchase(); // the flow shows its loading indicator myPurchaseApi(product.vendorProductId) .then((transactionId) => adapty.reportTransaction(transactionId, product.variationId)) .finally(() => onFinishPurchase()); // the flow hides the loading indicator }, []); const onObserverRestoreInitiated = useCallback< FlowEventHandlers['onObserverRestoreInitiated'] >((onStartRestore, onFinishRestore) => { onStartRestore(); myRestoreApi().finally(() => onFinishRestore()); }, []); return ( <AdaptyFlowView flow={flow} onObserverPurchaseInitiated={onObserverPurchaseInitiated} onObserverRestoreInitiated={onObserverRestoreInitiated} // ... your other event handlers /> );}
In the embedded component, the value a handler returns does not close the flow — unmount the component yourself after a successful purchase or restore.
Register the resolver with AdaptyUI().setObserverModeResolver — on AdaptyUI(), not on Adapty. Implement both observerModeDidInitiatePurchase and observerModeDidInitiateRestore; both are required, and each receives the flow view as its first argument.
Register the resolver with Adapty.SetObserverModeResolver — on Adapty, not on AdaptyUI. Implement IAdaptyUIObserverModeResolver with FlowViewDidInitiatePurchase and FlowViewDidInitiateRestore; Unity’s callback names differ from the other platforms.
using System;using AdaptySDK;public class MyObserverModeResolver : IAdaptyUIObserverModeResolver{ public void FlowViewDidInitiatePurchase( AdaptyUIFlowView view, AdaptyPaywallProduct product, Action onStartPurchase, Action onFinishPurchase ) { onStartPurchase(); // the flow shows its loading indicator MyPurchaseApi.Purchase(product.VendorProductId, (transactionId, purchaseError) => { if (purchaseError != null) { onFinishPurchase(); return; } Adapty.ReportTransaction(transactionId, product.PaywallVariationId, (reportError) => { onFinishPurchase(); // the flow hides the loading indicator }); }); } public void FlowViewDidInitiateRestore( AdaptyUIFlowView view, Action onStartRestore, Action onFinishRestore ) { onStartRestore(); MyPurchaseApi.Restore((restoreError) => onFinishRestore()); }}
Register the resolver once, before you present any flow:
Register the resolver with AdaptyUI.setObserverModeResolver. Implement both observerModeDidInitiatePurchase and observerModeDidInitiateRestore; both are required, and each receives the flow view as its first argument.
import com.adapty.kmp.Adaptyimport com.adapty.kmp.AdaptyUIObserverModeResolverimport com.adapty.kmp.models.AdaptyPaywallProductimport com.adapty.kmp.models.AdaptyUIFlowViewimport com.adapty.kmp.models.onErrorimport kotlinx.coroutines.CoroutineScopeimport kotlinx.coroutines.launchclass MyObserverModeResolver( private val scope: CoroutineScope,) : AdaptyUIObserverModeResolver { override fun observerModeDidInitiatePurchase( view: AdaptyUIFlowView, product: AdaptyPaywallProduct, onStartPurchase: () -> Unit, onFinishPurchase: () -> Unit, ) { onStartPurchase() // the flow shows its loading indicator scope.launch { val transactionId = myPurchaseApi(product.vendorProductId) Adapty.reportTransaction( transactionId = transactionId, variationId = product.paywallVariationId, ).onError { error -> // handle the error } onFinishPurchase() // the flow hides the loading indicator } } override fun observerModeDidInitiateRestore( view: AdaptyUIFlowView, onStartRestore: () -> Unit, onFinishRestore: () -> Unit, ) { onStartRestore() scope.launch { myRestoreApi() onFinishRestore() } }}
Register the resolver once, before you present any flow:
Set onObserverPurchaseInitiated and onObserverRestoreInitiated with view.setEventHandlers on every flow view you create — Capacitor has no separate resolver object, and the two handlers are part of the regular event handlers.
import { adapty, createFlowView } from '@adapty/capacitor';const view = await createFlowView(flow);const unsubscribe = await view.setEventHandlers({ onObserverPurchaseInitiated(product, onStartPurchase, onFinishPurchase) { onStartPurchase(); // the flow shows its loading indicator myPurchaseApi(product.vendorProductId) .then((transactionId) => adapty.reportTransaction({ transactionId, variationId: product.variationId }), ) .finally(() => onFinishPurchase()); // the flow hides the loading indicator return false; // keep the flow open; dismiss it yourself after success }, onObserverRestoreInitiated(onStartRestore, onFinishRestore) { onStartRestore(); myRestoreApi().finally(() => onFinishRestore()); return false; },});
Adapty doesn’t grant access: It doesn’t respond to purchase events by giving or restricting paid access, and it doesn’t handle renewals or billing retries. Your own code owns access levels.
Your code finishes its own transactions: Adapty doesn’t finish or acknowledge the purchases your code makes, so closing each one stays your job.
Reporting isn’t optional: The variationId you pass with a report is the only link between a purchase and the flow that produced it. Report every transaction, or your flow metrics and A/B test results are wrong.
If you’re already using another vendor
Observer mode only requires that your code makes the purchase — not whose SDK that code calls. Flows work the same on top of RevenueCat, Superwall, or Qonversion as on top of your own StoreKit or Billing Library code.
Three decisions to make before you ship:
One system finishes each transaction: Two SDKs both finishing the same purchase is the most common failure here.
One system owns access: Adapty grants nothing in Observer mode, so keep access levels where they are.
Report each purchase once: Reporting the same transaction from two places distorts your analytics.
Observer mode is the quick way in. If you want to keep RevenueCat’s analytics but avoid the Observer mode limits, invert the two: Adapty runs in full mode and completes every purchase, while RevenueCat runs in its own observer mode and records the purchases Adapty makes.
Adapty then knows which flow, placement, and A/B test variation produced each charge, and it grants access levels and handles renewals, billing retries, and refunds.
On the RevenueCat side, set purchasesAreCompletedBy to your app when you configure its SDK — .myApp on iOS, MY_APP on Android. RevenueCat’s Using the SDK with your own IAP code has the configuration for each platform, the StoreKit version iOS requires, and the syncPurchases() call that pulls in purchases a customer already made. Give both SDKs the same user ID — Adapty’s customer user ID and RevenueCat’s appUserID — or the two dashboards describe different people.
Warning
This arrangement ends RevenueCat entitlements as your source of truth, and Adapty access levels take that role. RevenueCat keeps observing, and its dashboard keeps reporting, but it now learns of each purchase second-hand and within the coverage limits its own documentation lists. Anything that reads RevenueCat entitlements today — your app, your backend, a web or desktop build — either moves to Adapty or reads a copy. Settle that before you ship. Nothing else moves: the RevenueCat account, its history, and its integrations stay where they are.