Use this page with AI

Copy this into your coding assistant and add your request.

Read https://openiap.dev/docs/getting-started and https://openiap.dev/llms.txt. Follow the reading instructions, detailed reference, and linked guides relevant to my task before making changes.
Inspect my existing project and reuse its framework and conventions. Ask me for missing product decisions. Implement the requested behavior and run the applicable checks.
Show the working result, the commands and actual test results, and any remaining limitations. Keep your explanation brief.

My request: [describe what customers should be able to do]

Getting Started

Add purchases to your existing app with the OpenIAP SDK for your framework. Customers can buy products, restore purchases, and use the features they paid for.

Build with AI → Give your assistant the references and a product request; review its running result. For manual integration, start with your framework’s setup guide.

Choose your store, products, and what each purchase unlocks.
Connect purchases to your existing login and paid features.
Try buying, restoring, and canceling in the store sandbox.

Manual setup, code examples, and reference

1. Configure the store#

Every framework wraps the same store APIs, so the platform setup comes first. Finish these before installing any SDK:

iOS Setup — App Store Connect agreement, capability, sandbox testers
Android Setup — Play Console account, license testers, test track
Store Setup — Horizon OS, Fire OS, Vega OS, and alternative marketplaces

2. Pick a framework#

Use your app’s existing framework. SDKs share the purchase contract; types and lifecycle patterns follow each language.

expo-iap — Expo SDK projects
react-native-iap — bare React Native CLI projects (RN 0.79+)
flutter_inapp_purchase — Flutter / Dart
kmp-iap — Kotlin Multiplatform / Compose Multiplatform
maui-iap — .NET MAUI / C#
godot-iap — Godot 4.x

3. Your first purchase flow#

Connect, load products, listen for results, then request a purchase. The examples below outline that flow; add your backend verification and access logic. Read Features → Purchase for a full walkthrough with verification, error handling, and consumable/non-consumable nuances.

swift

import OpenIap

let store = OpenIapModule.shared

// 1. Open the store connection on app start.
let connected = try await store.initConnection()
precondition(connected, "Store connection failed")

// 2. Fetch products by SKU.
let products = try await store.fetchProducts(
    ProductRequest(skus: ["com.app.premium"], type: .inApp)
)

// 3. Listen for purchase results — requestPurchase is event-based.
// Keep this token alive for as long as purchases should be observed.
let purchaseSubscription = store.purchaseUpdatedListener { purchase in
    Task {
        // Verify on your backend, grant entitlement, then finish.
        do {
            try await store.finishTransaction(
                purchase: purchase,
                isConsumable: false
            )
        } catch {
            print("Failed to finish transaction: \(error)")
        }
    }
}

// On app shutdown:
// store.removeListener(purchaseSubscription)

// 4. Initiate a purchase.
try await store.requestPurchase(
    RequestPurchaseProps(
        request: .purchase(RequestPurchasePropsByPlatforms(
            apple: RequestPurchaseIosProps(sku: "com.app.premium")
        )),
        type: .inApp
    )
)

Kotlin example

import dev.hyo.openiap.store.OpenIapStore
import dev.hyo.openiap.*
import dev.hyo.openiap.listener.OpenIapPurchaseUpdateListener

val store = OpenIapStore(context)

// 1. Open the store connection on app start.
check(store.initConnection(null)) { "Store connection failed" }

// 2. Fetch products by SKU.
val products = store.fetchProducts(
    ProductRequest(
        skus = listOf("com.app.premium"),
        type = ProductQueryType.InApp
    )
)

// 3. Listen for purchase results.
val purchaseListener = OpenIapPurchaseUpdateListener { purchase ->
    scope.launch {
        // Verify on your backend, grant entitlement, then finish.
        store.finishTransaction(purchase, isConsumable = false)
    }
}
store.addPurchaseUpdateListener(purchaseListener)

// 4. Initiate a purchase.
store.requestPurchase(
    RequestPurchaseProps(
        request = RequestPurchaseProps.Request.Purchase(
            RequestPurchasePropsByPlatforms(
                google = RequestPurchaseAndroidProps(skus = listOf("com.app.premium"))
            )
        ),
        type = ProductQueryType.InApp
    )
)

// Call when the owning lifecycle ends.
fun disposePurchaseListener() {
    store.removePurchaseUpdateListener(purchaseListener)
}

TypeScript example

import {
  initConnection,
  fetchProducts,
  requestPurchase,
  finishTransaction,
  purchaseUpdatedListener,
  type Purchase,
} from 'expo-iap';

// 1. Open the store connection on app start.
const connected = await initConnection();
if (!connected) throw new Error('Store connection failed');

// 2. Fetch products by SKU.
const products = await fetchProducts({
  skus: ['com.app.premium'],
  type: 'in-app',
});

// 3. Listen for purchase results — requestPurchase is event-based.
async function handlePurchase(purchase: Purchase) {
  // Your backend verifies the store token/JWS and returns an entitlement decision.
  const { isValid } = await yourBackend.verifyPurchase(purchase);
  if (!isValid) return;

  await grantEntitlement(purchase.productId);
  await finishTransaction({ purchase, isConsumable: false });
}

const purchaseSubscription = purchaseUpdatedListener((purchase) => {
  void handlePurchase(purchase).catch((error) => {
    console.error('Purchase processing failed', error);
  });
});

// On app shutdown: purchaseSubscription.remove();

// 4. Initiate a purchase.
await requestPurchase({
  request: {
    apple: { sku: 'com.app.premium' },
    google: { skus: ['com.app.premium'] },
  },
  type: 'in-app',
});

Dart example

dart

import 'dart:async';
import 'package:flutter_inapp_purchase/flutter_inapp_purchase.dart';

final iap = FlutterInappPurchase.instance;

// 1. Open the store connection on app start.
final connected = await iap.initConnection();
if (!connected) throw StateError('Store connection failed');

// 2. Fetch products by SKU.
final products = await iap.fetchProducts<Product>(
  skus: ['com.app.premium'],
  type: ProductQueryType.InApp,
);

// 3. Listen for purchase results.
Future<void> handlePurchase(Purchase purchase) async {
  // Verify on your backend, grant entitlement, then finish.
  await iap.finishTransaction(purchase: purchase, isConsumable: false);
}

final purchaseSubscription = iap.purchaseUpdatedListener.listen((purchase) {
  unawaited(handlePurchase(purchase).catchError(
    (Object error) => print('Purchase processing failed: $error'),
  ));
});

// 4. Initiate a purchase.
await iap.requestPurchase(
  RequestPurchaseProps.inApp((
    apple: RequestPurchaseIosProps(sku: 'com.app.premium'),
    google: RequestPurchaseAndroidProps(skus: ['com.app.premium']),
  )),
);

// --- Or via the builder DSL ---
// requestPurchaseWithBuilder accepts a build closure; assign type and
// platform-specific fields fluently with cascade operators.
await iap.requestPurchaseWithBuilder(
  build: (builder) {
    builder
      ..type = ProductQueryType.InApp
      ..android.skus = ['com.app.premium']
      ..ios.sku = 'com.app.premium';
  },
);

// Call from State.dispose().
Future<void> disposePurchaseListener() => purchaseSubscription.cancel();

C# (MAUI) example

using OpenIap;
using OpenIap.Maui;

var query = (QueryResolver)OpenIapClient.Instance;
var mutation = (MutationResolver)OpenIapClient.Instance;

// 1. Open the store connection on app start.
var connected = await mutation.InitConnectionAsync();
if (!connected) throw new InvalidOperationException("Store connection failed");

// 2. Fetch products by SKU.
var products = await query.FetchProductsAsync(new ProductRequest
{
    Skus = new[] { "com.app.premium" },
    Type = ProductQueryType.InApp,
});

// 3. Listen for purchase results.
async Task HandlePurchaseSafelyAsync(Purchase purchase)
{
    try
    {
        await mutation.FinishTransactionAsync(
            new PurchaseInput(purchase),
            isConsumable: false);
    }
    catch (Exception error)
    {
        Console.WriteLine(quot;Purchase processing failed: {error.Message}");
    }
}

var subscription = OpenIapClient.Instance.PurchaseUpdated.Subscribe(
    purchase => _ = HandlePurchaseSafelyAsync(purchase));

// 4. Initiate a purchase.
await mutation.RequestPurchaseAsync(new RequestPurchaseProps
{
    RequestPurchase = new RequestPurchasePropsByPlatforms
    {
        Google = new RequestPurchaseAndroidProps
        {
            Skus = new[] { "com.app.premium" },
        },
    },
    Type = ProductQueryType.InApp,
});

// Call when the page goes away.
void DisposePurchaseListener() => subscription.Dispose();

Kotlin (KMP) example

import io.github.hyochan.kmpiap.KmpIAP
import io.github.hyochan.kmpiap.openiap.*

val kmpIAP = KmpIAP()

// 1. Open the store connection on app start.
check(kmpIAP.initConnection()) { "Store connection failed" }

// 2. Fetch products by SKU.
val products = kmpIAP.fetchProducts(
    ProductRequest(
        skus = listOf("com.app.premium"),
        type = ProductQueryType.InApp
    )
)

// 3. Listen for purchase results.
scope.launch {
    kmpIAP.purchaseUpdatedListener.collect { purchase ->
        // Verify on your backend, grant entitlement, then finish.
        kmpIAP.finishTransaction(purchase, isConsumable = false)
    }
}

// 4. Initiate a purchase.
kmpIAP.requestPurchase(
    RequestPurchaseProps(
        request = RequestPurchaseProps.Request.Purchase(
            RequestPurchasePropsByPlatforms(
                apple = RequestPurchaseIosProps(sku = "com.app.premium"),
                google = RequestPurchaseAndroidProps(skus = listOf("com.app.premium"))
            )
        ),
        type = ProductQueryType.InApp
    )
)

// --- Or via the DSL API ---
// Same flow, but platform options live inside apple { } / google { }
// blocks. The call returns the resulting Purchase, which you pipe through
// .toPurchaseInput() into finishTransaction.
val purchase = kmpIAP.requestPurchase {
    apple {
        sku = "com.app.premium"
        quantity = 1
    }
    google {
        skus = listOf("com.app.premium")
    }
}

kmpIAP.finishTransaction(
    purchase = purchase.toPurchaseInput(),
    isConsumable = false
)

GDScript example

# 1. Open the store connection on app start.
if not await iap.init_connection():
    push_error("Store connection failed")
    return

# 2. Fetch products by SKU.
var request = ProductRequest.new()
request.skus = ["com.app.premium"]
request.type = ProductQueryType.IN_APP
var products = await iap.fetch_products(request)

# 3. Listen for purchase results.
iap.purchase_updated.connect(func(purchase):
    # Verify on your backend, grant entitlement, then finish.
    await iap.finish_transaction(purchase, false)
)

# 4. Initiate a purchase.
var props = RequestPurchaseProps.new()
props.request = RequestPurchasePropsByPlatforms.new()
props.request.apple = RequestPurchaseIosProps.new()
props.request.apple.sku = "com.app.premium"
props.type = ProductQueryType.IN_APP
await iap.request_purchase(props)

4. Key concepts#

References for choosing an SDK and managing the purchase lifecycle:

Ecosystem — how OpenIAP, the native packages (Apple / Google), and each framework SDK fit together. Read this first if you're choosing a stack.
Life Cycle — when to call initConnection, where to mount listeners, and when to call finishTransaction after verification and delivery.

5. How the docs are organized#

Use a feature guide for a complete flow, APIs for calls, and Types for data fields.

Setup Guide — install + native config per framework (Expo, React Native, Flutter, Kotlin Multiplatform, .NET MAUI, Godot) plus the store-side configuration (iOS, Android, store setup).
Features — task-oriented walkthroughs, not reference. Each page covers a real flow end-to-end (Purchase, Subscription, Refund, Validation, Offer Code Redemption, …) with verification, edge cases, and platform notes. Open a Features page when you're shipping a flow, not just calling a function.
APIs — flat reference, one page per function (initConnection, fetchProducts, requestPurchase, …). Cross-platform symbols live at the root; iOS- and Android-only symbols are grouped under iOS Specific / Android Specific. Open a function page when you need its exact signature, params, and a copy-pasteable example.
Types — flat reference, one page per type (Product, Purchase, RequestPurchaseProps, …). Same iOS / Android grouping as APIs. Field tables auto-link to related types so you can chase a shape without leaving the docs.
Events & Errors — listener patterns and the unified PurchaseError codes that every SDK normalizes to.

6. Where to go next#

Purchase, Subscription, Refund — full feature walkthroughs
Validation — server-side verification (your own backend or IAPKit — open source under MIT, with hosted validation and analytics free at kit.openiap.dev or self-host from packages/kit)
API Reference — every function with cross-platform signatures
Types — every type with field tables
Errors — unified PurchaseError codes