Use this page with AI

Copy this into your coding assistant and add your request.

Read https://openiap.dev/docs/events/purchase-updated-listener 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]

purchaseUpdatedListener

Fired when a purchase is successful or when a pending purchase is completed.

Duplicate Transaction Replays on iOS

StoreKit can replay the same unfinished transaction through more than one native path during a single connection session. By default, OpenIAP delivers one purchaseUpdated event per iOS transaction ID to purchase-success listeners, while still keeping distinct transactions separate. This prevents entitlement delivery from running twice for the same purchase.

For diagnostics, register the purchase update listener with dedupeTransactionIOS: false. The flag belongs to the purchase update listener only; purchase error listeners do not receive successful StoreKit transactions. Android ignores this iOS-only option.

Listener Setup

swift

let subscription = OpenIapModule.shared.purchaseUpdatedListener(
    { purchase in
        print("Purchase updated: \(purchase.productId)")
    },
    options: nil
)

Kotlin example

// Flow approach
val purchaseUpdates: Flow<Purchase>

TypeScript example

purchaseUpdatedListener(
  listener: (purchase: Purchase) => void,
  options?: PurchaseUpdatedListenerOptions | null
): Subscription

Dart example

dart

Stream<Purchase> get purchaseUpdatedListener;

C# (MAUI) example

using OpenIap;
using OpenIap.Maui;
using System;

IObservable<Purchase> purchaseUpdates = OpenIapClient.Instance.PurchaseUpdated;

Kotlin (KMP) example

// Flow approach
val purchaseUpdates: Flow<Purchase> = kmpIAP.purchaseUpdatedListener

GDScript example

signal purchase_updated(purchase: Purchase)

Registers a listener for successful purchase events.

Opt In to iOS StoreKit Replays

swift

let subscription = OpenIapModule.shared.purchaseUpdatedListener(
    { purchase in
        print("StoreKit replay or first delivery: \(purchase.id)")
    },
    options: PurchaseUpdatedListenerOptions(
        dedupeTransactionIOS: false
    )
)

TypeScript example

const subscription = purchaseUpdatedListener(
  (purchase) => {
    console.log('StoreKit replay or first delivery:', purchase.id);
  },
  { dedupeTransactionIOS: false }
);

Dart example

dart

final updates = FlutterInappPurchase.instance
    .purchaseUpdatedListenerWithOptions(
  const PurchaseUpdatedListenerOptions(
    dedupeTransactionIOS: false,
  ),
);

C# (MAUI) example

var updates = OpenIapClient.Instance.PurchaseUpdatedWithOptions(
    new PurchaseUpdatedListenerOptions
    {
        DedupeTransactionIOS = false,
    });

Kotlin (KMP) example

val updates = kmpIAP.purchaseUpdatedListener(
    PurchaseUpdatedListenerOptions(
        dedupeTransactionIOS = false
    )
)

GDScript example

var options = Types.PurchaseUpdatedListenerOptions.new()
options.dedupe_transaction_ios = false
iap.set_purchase_updated_listener_options(options)

swift

import OpenIap

let subscription = OpenIapModule.shared.purchaseUpdatedListener { purchase in
    Task {
        print("Purchase updated: \(purchase.productId)")

        // Verify and deliver
        if await verifyPurchaseOnServer(purchase) {
            await deliverProduct(purchase.productId)
            try await OpenIapModule.shared.finishTransaction(
                purchase: purchase,
                isConsumable: false
            )
        }
    }
}

// Cleanup when done
OpenIapModule.shared.removeListener(subscription)

Kotlin example

import dev.hyo.openiap.store.OpenIapStore

// Using Flow
lifecycleScope.launch {
    openIapStore.currentPurchase.collect { purchase ->
        purchase ?: return@collect
        println("Purchase updated: ${purchase.productId}")

        // Verify and deliver
        if (verifyPurchaseOnServer(purchase)) {
            deliverProduct(purchase.productId)
            openIapStore.finishTransaction(purchase, isConsumable = false)
        }
    }
}

TypeScript example

import {
  finishTransaction,
  purchaseUpdatedListener,
  type Purchase,
} from 'expo-iap';
// Same API in react-native-iap:
// import { finishTransaction, purchaseUpdatedListener } from 'react-native-iap';

async function handlePurchase(purchase: Purchase) {
  console.log('Purchase updated:', purchase.productId);

  // Verify with your backend or IAPKit before granting content.
  const isValid = await verifyPurchaseOnServer(purchase);

  if (isValid) {
    // Deliver content to user
    await deliverProduct(purchase.productId);

    // Finish the transaction
    await finishTransaction({ purchase, isConsumable: false });
  }
}

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

// Cleanup when done
subscription.remove();

Dart example

dart

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

Future<void> handlePurchase(Purchase purchase) async {
  print('Purchase updated: ${purchase.productId}');

  // Verify with your backend or IAPKit before granting content.
  final isValid = await verifyPurchaseOnServer(purchase);

  if (isValid) {
    // Deliver content to user
    await deliverProduct(purchase.productId);

    // Finish the transaction
    await FlutterInappPurchase.instance.finishTransaction(purchase: purchase);
  }
}

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

// Cleanup when done
subscription.cancel();

C# (MAUI) example

using OpenIap;
using OpenIap.Maui;

async Task HandlePurchaseSafelyAsync(Purchase purchase)
{
    try
    {
        if (purchase is PurchaseCommon purchaseInfo)
        {
            Console.WriteLine(quot;Purchase updated: {purchaseInfo.ProductId}");
        }

        if (await VerifyPurchaseOnServerAsync(purchase))
        {
            if (purchase is PurchaseCommon validPurchase)
            {
                await DeliverProductAsync(validPurchase.ProductId);
            }

            await ((MutationResolver)OpenIapClient.Instance).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));

// Cleanup when done.
subscription.Dispose();

Kotlin (KMP) example

import io.github.hyochan.kmpiap.KmpIAP

val kmpIAP = KmpIAP()

// Using Flow
lifecycleScope.launch {
    kmpIAP.purchaseUpdatedListener.collect { purchase ->
        println("Purchase updated: ${purchase.productId}")

        // Verify and deliver
        if (verifyPurchaseOnServer(purchase)) {
            deliverProduct(purchase.productId)
            kmpIAP.finishTransaction(purchase, isConsumable = false)
        }
    }
}

GDScript example

# Connect to the signal
iap.purchase_updated.connect(_on_purchase_updated)

func _on_purchase_updated(purchase: Purchase):
    print("Purchase updated: %s" % purchase.product_id)

    # Verify with your backend or IAPKit before granting content.
    var is_valid = await verify_purchase_on_server(purchase)

    if is_valid:
        # Deliver content to user
        await deliver_product(purchase.product_id)

        # Finish the transaction
        await iap.finish_transaction(purchase, false)

# Cleanup when done
func _exit_tree():
    iap.purchase_updated.disconnect(_on_purchase_updated)

Event Payload

The purchase event delivers a Purchase object containing transaction details.

Purchase Update Flow

Receive Purchase object via listener
Validate receipt with backend service
Deliver purchased content to user
Finish transaction with finishTransaction (handles acknowledgment on both platforms)
Update application state