InAppPurchases.connectAsync()

Connects to the app store and performs all of the necessary initialization to prepare the module to accept payments. This method must be called before anything else, otherwise an error will be thrown.

• Promise<void>

Returns a Promise that fulfills when connection is established.

InAppPurchases.disconnectAsync()

Disconnects from the app store and cleans up memory internally. Call this when you are done using the In-App Purchases API in your app.

No other methods can be used until the next time you call connectAsync.

• Promise<void>

Returns a Promise that fulfils when disconnecting process is finished.

InAppPurchases.finishTransactionAsync(purchase, consumeItem)

Marks a transaction as completed. This must be called on successful purchases only after you have verified the transaction and unlocked the functionality purchased by the user.

On Android, this will either "acknowledge" or "consume" the purchase depending on the value of consumeItem. Acknowledging indicates that this is a one time purchase (e.g. premium upgrade), whereas consuming a purchase allows it to be bought more than once. You cannot buy an item again until it's consumed. Both consuming and acknowledging let Google know that you are done processing the transaction. If you do not acknowledge or consume a purchase within three days, the user automatically receives a refund, and Google Play revokes the purchase.

On iOS, this will mark the transaction as finished and prevent it from reappearing in the purchase listener callback. It will also let the user know their purchase was successful.

consumeItem is ignored on iOS because you must specify whether an item is a consumable or non-consumable in its product entry in App Store Connect, whereas on Android you indicate an item is consumable at runtime.

Make sure that you verify each purchase to prevent faulty transactions and protect against fraud before you call finishTransactionAsync. On iOS, you can validate the purchase's transactionReceipt with the App Store as described here. On Android, you can verify your purchase using the Google Play Developer API as described here.

if (!purchase.acknowledged) {
  await finishTransactionAsync(purchase, false); // or true for consumables
}

• Promise<void>

InAppPurchases.getBillingResponseCodeAsync()

Returns the last response code. This is more descriptive on Android since there is native support for retrieving the billing response code.

On Android, this will return IAPResponseCode.ERROR if you are not connected or one of the billing response codes found here if you are.

On iOS, this will return IAPResponseCode.OK if you are connected or IAPResponseCode.ERROR if you are not. Therefore, it's a good way to test whether or not you are connected and it's safe to use the other methods.

const responseCode = await getBillingResponseCodeAsync();
 if (responseCode !== IAPResponseCode.OK) {
  // Either we're not connected or the last response returned an error (Android)
}

• Promise<IAPResponseCode>

Returns a Promise that fulfils with an number representing the IAPResponseCode.

InAppPurchases.getProductsAsync(itemList)

Retrieves the product details (price, description, title, etc) for each item that you inputted in the Google Play Console and App Store Connect. These products are associated with your app's specific Application/Bundle ID and cannot be retrieved from other apps. This queries both in-app products and subscriptions so there's no need to pass those in separately.

You must retrieve an item's details before you attempt to purchase it via purchaseItemAsync. This is a prerequisite to buying a product even if you have the item details bundled in your app or on your own servers.

If any of the product IDs passed in are invalid and don't exist, you will not receive an IAPItemDetails object corresponding to that ID. For example, if you pass in four product IDs in but one of them has a typo, you will only get three response objects back.

// These product IDs must match the item entries you created in the App Store Connect and Google Play Console.
// If you want to add more or edit their attributes you can do so there.

const items = Platform.select({
  ios: [
    'dev.products.gas',
    'dev.products.premium',
    'dev.products.gold_monthly',
    'dev.products.gold_yearly',
  ],
  android: ['gas', 'premium', 'gold_monthly', 'gold_yearly'],
});

 // Retrieve product details
const { responseCode, results } = await getProductsAsync(items);
if (responseCode === IAPResponseCode.OK) {
  this.setState({ items: results });
}

• Promise<IAPQueryResponse<IAPItemDetails>>

Returns a Promise that resolves with an IAPQueryResponse containing IAPItemDetails objects in the results array.

InAppPurchases.getPurchaseHistoryAsync(options)

Retrieves the user's purchase history.

Please note that on iOS, StoreKit actually creates a new transaction object every time you restore completed transactions, therefore the purchaseTime and orderId may be inaccurate if it's a restored purchase. If you need the original transaction's information you can use originalPurchaseTime and originalOrderId, but those will be 0 and an empty string respectively if it is the original transaction.

You should not call this method on launch because restoring purchases on iOS prompts for the user’s App Store credentials, which could interrupt the flow of your app.

• Promise<IAPQueryResponse<InAppPurchase>>

Returns a Promise that fulfills with an IAPQueryResponse that contains an array of InAppPurchase objects.

InAppPurchases.purchaseItemAsync(itemId, details)

Initiates the purchase flow to buy the item associated with this productId. This will display a prompt to the user that will allow them to either buy the item or cancel the purchase. When the purchase completes, the result must be handled in the callback that you passed in to setPurchaseListener.

Remember, you have to query an item's details via getProductsAsync and set the purchase listener before you attempt to buy an item.

Apple and Google both have their own workflows for dealing with subscriptions. In general, you can deal with them in the same way you do one-time purchases but there are caveats including if a user decides to cancel before the expiration date. To check the status of a subscription, you can use the Google Play Developer API on Android and the Status Update Notifications service on iOS.

• Promise<void>

Returns a Promise that resolves when the purchase is done processing. To get the actual result of the purchase, you must handle purchase events inside the setPurchaseListener callback.

InAppPurchases.setPurchaseListener(callback)

Sets a callback that handles incoming purchases. This must be done before any calls to purchaseItemAsync are made, otherwise those transactions will be lost. You should set the purchase listener globally, and not inside a specific screen, to ensure that you receive incomplete transactions, subscriptions, and deferred transactions.

Purchases can either be instantiated by the user (via purchaseItemAsync) or they can come from subscription renewals or unfinished transactions on iOS (e.g. if your app exits before finishTransactionAsync was called).

Note that on iOS, the results array will only contain one item: the one that was just purchased. On Android, it will return both finished and unfinished purchases, hence the array return type. This is because the Google Play Billing API detects purchase updates but doesn't differentiate which item was just purchased, therefore there's no good way to tell but in general it will be whichever purchase has acknowledged set to false, so those are the ones that you have to handle in the response. Consumed items will not be returned however, so if you consume an item that record will be gone and no longer appear in the results array when a new purchase is made.

// Set purchase listener
 setPurchaseListener(({ responseCode, results, errorCode }) => {
  // Purchase was successful
  if (responseCode === IAPResponseCode.OK) {
    results.forEach(purchase => {
      if (!purchase.acknowledged) {
        console.log(`Successfully purchased ${purchase.productId}`);
        // Process transaction here and unlock content...

        // Then when you're done
        finishTransactionAsync(purchase, true);
      }
    });
  } else if (responseCode === IAPResponseCode.USER_CANCELED) {
    console.log('User canceled the transaction');
  } else if (responseCode === IAPResponseCode.DEFERRED) {
    console.log('User does not have permissions to buy but requested parental approval (iOS only)');
  } else {
    console.warn(`Something went wrong with the purchase. Received errorCode ${errorCode}`);
  }
});

• void