---
title: "Enable purchases with Flow Builder in Android SDK"
description: "Quickstart guide to enabling in-app purchases with Adapty Flow Builder."
---
To enable in-app purchases, you need to understand three key concepts:
- [**Products**](product) – anything users can buy (subscriptions, consumables, lifetime access)
- [**Flows**](adapty-flow-builder) – screen sequences that present products to users, built in the no-code Flow Builder. The SDK retrieves them via `getFlow`. If you'd rather build the UI in your own code, use a paywall instead — see [Implement paywalls manually](android-quickstart-manual).
- [**Placements**](placements) – where and when you show flows in your app (like `main`, `onboarding`, `settings`). You attach flows to placements in the dashboard, then request them by placement ID in your code. This makes it easy to run A/B tests and show different flows to different users.
Adapty offers you three ways to enable purchases in your app. Select one of them depending on your app requirements:
| Implementation | Complexity | When to use |
|---|---|---|
| Adapty Flow Builder | ✅ Easy | You [create a complete, purchase-ready flow in the no-code builder](quickstart-paywalls). Adapty automatically renders it and handles all the complex purchase flow, receipt validation, and subscription management behind the scenes. |
| Manually created paywalls | 🟡 Medium | You implement your paywall UI in your app code, but still get the flow object from Adapty to maintain flexibility in product offerings. See the [guide](android-quickstart-manual). |
| Observer mode | 🔴 Hard | You already have your own purchase handling infrastructure and want to keep using it. Note that the observer mode has its limitations in Adapty. See the [article](observer-vs-full-mode). |
:::important
**The steps below show how to implement a flow created in the Adapty Flow Builder.**
If you'd rather build the paywall UI yourself, see [Implement paywalls manually](android-quickstart-manual).
:::
To display a flow created in the Adapty Flow Builder, in your app code, you only need to:
1. **Get the flow**: Get it from Adapty.
2. **Display it and Adapty will handle purchases for you**: Show the view in your app.
3. **Handle button actions**: Associate user interactions with your app's response to them. For example, open links or close the flow when users click buttons.
## Before you start
Before you start, complete these steps:
1. [Connect your app to Google Play](initial-android) in the Adapty Dashboard.
2. [Create your products](create-product) in Adapty.
3. [Create a flow and add products to it](create-paywall).
4. [Create a placement and add your flow to it](create-placement).
5. [Install and activate the Adapty SDK](sdk-installation-android) in your app code. This guide uses Adapty Android SDK v4 APIs.
:::tip
The fastest way to complete these steps is to follow the [quickstart guide](quickstart) or create flows and placements using the [Developer CLI](developer-cli-quickstart).
:::
## 1. Get the flow
Your flows are associated with placements configured in the dashboard. Placements allow you to run different flows for different audiences or to run [A/B tests](ab-tests).
To get a flow created in the Adapty Flow Builder, you need to:
1. Get the `flow` object by the [placement](placements) ID using the `getFlow` method and check whether it has a view configuration.
2. Get the view configuration using the `getFlowConfiguration` method. The view configuration contains the UI elements and styling needed to display the flow.
:::important
To get the view configuration, you must switch on the **Show on device** toggle in the Flow Builder. Otherwise, you will get an empty view configuration, and the flow won't be displayed.
:::
```kotlin showLineNumbers
Adapty.getFlow("YOUR_PLACEMENT_ID") { result ->
if (result is AdaptyResult.Success) {
val flow = result.value
if (!flow.hasViewConfiguration) {
return@getFlow
}
AdaptyUI.getFlowConfiguration(flow) { configResult ->
if (configResult is AdaptyResult.Success) {
val flowConfiguration = configResult.value
}
}
}
}
```
```java showLineNumbers
Adapty.getFlow("YOUR_PLACEMENT_ID", result -> {
if (result instanceof AdaptyResult.Success) {
AdaptyFlow flow = ((AdaptyResult.Success) result).getValue();
if (!flow.hasViewConfiguration()) {
return;
}
AdaptyUI.getFlowConfiguration(flow, configResult -> {
if (configResult instanceof AdaptyResult.Success) {
AdaptyUI.FlowConfiguration flowConfiguration =
((AdaptyResult.Success) configResult).getValue();
// use loaded configuration
}
});
}
});
```
## 2. Display the flow
Now, when you have the flow configuration, it's enough to add a few lines to display your flow.
In order to display the visual flow on the device screen, you must first configure it. To do this, call the method `AdaptyUI.getFlowView()` or create the `AdaptyFlowView` directly:
```kotlin showLineNumbers
val flowView = AdaptyUI.getFlowView(
activity,
flowConfiguration,
null, // products = null means auto-fetch
eventListener,
)
```
```kotlin showLineNumbers
val flowView =
AdaptyFlowView(activity) // or retrieve it from xml
...
with(flowView) {
showFlow(
flowConfiguration,
null, // products = null means auto-fetch
eventListener,
)
}
```
```java showLineNumbers
AdaptyFlowView flowView = AdaptyUI.getFlowView(
activity,
flowConfiguration,
null, // products = null means auto-fetch
eventListener
);
```
```java showLineNumbers
AdaptyFlowView flowView =
new AdaptyFlowView(activity); //add to the view hierarchy if needed, or you receive it from xml
...
flowView.showFlow(flowConfiguration, products, eventListener);
```
```xml showLineNumbers
```
After the view has been successfully created, you can add it to the view hierarchy and display it on the screen of the device.
:::tip
For more details on how to display a flow, see our [guide](android-present-paywalls).
:::
## 3. Handle button actions
When users click buttons in the flow, the Android SDK automatically handles purchases, restoration, closing the flow, and opening links.
However, other buttons have custom or pre-defined IDs and require handling actions in your code. Or, you may want to override their default behavior.
For example, here is the default behavior for the close button. You don't need to add it in the code, but here, you can see how it is done if needed.
:::tip
Read our guides on how to handle button [actions](android-handle-paywall-actions) and [events](android-handling-events).
:::
```kotlin showLineNumbers title="Kotlin"
override fun onActionPerformed(action: AdaptyUI.Action, context: Context) {
when (action) {
AdaptyUI.Action.Close -> (context as? Activity)?.onBackPressed() // default behavior
}
}
```
```java showLineNumbers
@Override
public void onActionPerformed(@NonNull AdaptyUI.Action action, @NonNull Context context) {
if (action instanceof AdaptyUI.Action.Close) {
if (context instanceof Activity) {
((Activity) context).onBackPressed();
}
}
}
```
## Next steps
:::tip
Have questions or running into issues? Check out our [support forum](https://adapty.featurebase.app/) where you can find answers to common questions or ask your own. Our team and community are here to help!
:::
Your flow is ready to be displayed in the app. [Test your purchases in Google Play Store](testing-on-android) to make sure you can complete a test purchase from the flow.
Now, you need to [check the users' access level](android-check-subscription-status) to ensure you display a flow or give access to paid features to right users.
## Full example
Here is how all those steps can be integrated in your app together.
```kotlin showLineNumbers title="Kotlin"
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
Adapty.getFlow("YOUR_PLACEMENT_ID") { flowResult ->
if (flowResult is AdaptyResult.Success) {
val flow = flowResult.value
if (!flow.hasViewConfiguration) {
// Use custom logic
return@getFlow
}
AdaptyUI.getFlowConfiguration(flow) { configResult ->
if (configResult is AdaptyResult.Success) {
val flowConfiguration = configResult.value
val flowView = AdaptyUI.getFlowView(
this,
flowConfiguration,
null, // products = null means auto-fetch
object : AdaptyFlowDefaultEventListener() {
override fun onActionPerformed(action: AdaptyUI.Action, context: Context) {
when (action) {
is AdaptyUI.Action.Close -> {
(context as? Activity)?.onBackPressed()
}
}
}
}
)
setContentView(flowView)
}
}
}
}
}
}
```
```java showLineNumbers
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Adapty.getFlow("YOUR_PLACEMENT_ID", flowResult -> {
if (flowResult instanceof AdaptyResult.Success) {
AdaptyFlow flow = ((AdaptyResult.Success) flowResult).getValue();
if (!flow.hasViewConfiguration()) {
// Use custom logic
return;
}
AdaptyUI.getFlowConfiguration(flow, configResult -> {
if (configResult instanceof AdaptyResult.Success) {
AdaptyUI.FlowConfiguration flowConfiguration =
((AdaptyResult.Success) configResult).getValue();
AdaptyFlowView flowView = AdaptyUI.getFlowView(
this,
flowConfiguration,
null, // products = null means auto-fetch
new AdaptyFlowDefaultEventListener() {
@Override
public void onActionPerformed(@NonNull AdaptyUI.Action action, @NonNull Context context) {
if (action instanceof AdaptyUI.Action.Close) {
if (context instanceof Activity) {
((Activity) context).onBackPressed();
}
}
}
}
);
setContentView(flowView);
}
});
}
});
}
}
```