Same iOS receipt after second requestPurchase

[idlework]

Recently I upgraded the package version from 13.0.2 to 14.4.26. Android works great, but with iOS I get duplicate receipt Data. The first purchase goes well, but when I purchase a second time the same product or an other product, I get the receipt data from the previous purchase.

Closing the app and re-opening it and purchasing the product again results in the same issue.

Or finishTransaction does not correctly finish the transaction and consumes the consumable. Or the something in the useIAP hook is not correctly resets. Or my implementation is incorrect?

Implementation is as followed:

requestPurchase is called with a button touch

await requestPurchase({
	type: "in-app",
	request: {
		ios: {
			sku: "product-id-1",
			quantity: 1,
		},
	},
});

then the onPurchaseSuccess picks up the purchase.

const { finishTransaction } = useIAP({
  onPurchaseSuccess: async (purchase: Purchase) => {
      const receipt = await getReceiptDataIOS();
      assert(receipt, "Unable to retrieve receipt data");
      await validateReceiptwithBackendEndpoint({ receipt });
      await finishTransaction({
        purchase,
        isConsumable: true,
      });
  },
  onPurchaseError: (purchaseError: PurchaseError) => {
    console.log("purchaseError", purchaseError);
  },
});

[idlework]

Maybe this error has something to do with it. I got this a few times when calling getReceiptDataIOS.

[idlework]

I have a little reproduction:

1. Clean install app
2. purchase in-app item
3. getReceiptDataIOS results in an error (as seen in the error image)
4. re-initialize useIAP hook (by restarting the app)
5. onPurchaseSuccess gets called and handles the purchase correctly
6. Purchase another in-app item
7. getReceiptDataIOS returns receipt from previous purchase

[hyochan]

@idlework After investigating, I can confirm this is not a bug but rather the expected behavior of iOS App Store receipts. Let me explain what's happening:

Why You're Seeing the Same Receipt

iOS App Store receipts are cumulative - they contain ALL transactions for your app, not just the most recent one. This is by design in Apple's receipt system.

Here's what happens in your flow:

1. First purchase ✅ - Receipt contains Transaction A
2. finishTransaction() called ✅ - Transaction is finished
3. Second purchase ✅ - Receipt now contains Transaction A + Transaction B
4. getReceiptDataIOS() returns - The same receipt blob (which now includes both transactions)

The receipt data itself doesn't "change" in a way that makes it look different - it's still the same cumulative receipt file, just with more transactions inside.

About the receipt-failed Error

The error you're seeing happens because:

1. Immediately after purchase: iOS may not have updated the receipt file yet
2. getReceiptDataIOS() fails: The receipt is empty or unavailable (throws receipt-failed)
3. On app restart: The unfinished transaction triggers onPurchaseSuccess again
4. syncIOS() is called (internally by getReceiptIOS): This refreshes the receipt from Apple's servers
5. Now it works: Receipt is available

Solutions

You have several options to fix this issue:

✅ Solution 1: Use getTransactionJwsIOS (Recommended)

Instead of using the legacy receipt, use the individual transaction's JWS (JSON Web Signature):

import { useIAP, getTransactionJwsIOS } from 'react-native-iap';

const { finishTransaction } = useIAP({
  onPurchaseSuccess: async (purchase: Purchase) => {
    try {
      // Get the specific transaction's JWS representation
      const jws = await getTransactionJwsIOS(purchase.productId);

      if (!jws) {
        console.error("No JWS found for transaction");
        return;
      }

      // Validate THIS specific transaction with your backend
      await validateTransactionWithBackend({
        jws,
        transactionId: purchase.id,
        productId: purchase.productId
      });

      await finishTransaction({
        purchase,
        isConsumable: true,
      });
    } catch (error) {
      console.error("Validation failed:", error);
    }
  },
  onPurchaseError: (purchaseError: PurchaseError) => {
    console.log("purchaseError", purchaseError);
  },
});

Why this is better:

• ✅ Each transaction has its own unique JWS
• ✅ Contains ONLY that specific purchase (not all historical purchases)
• ✅ Available immediately after purchase
• ✅ Simpler to validate on your backend
• ✅ Cryptographically signed by Apple

Solution 2: Use Transaction ID for Server-Side Deduplication

If you must use getReceiptDataIOS(), send the transaction ID along with it:

const { finishTransaction } = useIAP({
  onPurchaseSuccess: async (purchase: Purchase) => {
    try {
      const receipt = await getReceiptDataIOS();

      // Send BOTH the receipt AND the transaction ID
      await validateReceiptWithBackend({
        receipt,
        transactionId: purchase.id, // Backend uses this to find the specific transaction
        productId: purchase.productId
      });

      await finishTransaction({
        purchase,
        isConsumable: true,
      });
    } catch (error) {
      if (error.code === ErrorCode.ReceiptFailed) {
        // Receipt not ready yet - transaction will retry on next app start
        console.warn("Receipt not available, will retry on next launch");
        return; // Don't finish transaction yet
      }
      console.error("Validation failed:", error);
    }
  },
});

Backend handling: Your server should:

1. Parse the receipt to extract all transactions
2. Find the transaction matching transactionId
3. Validate only that specific transaction
4. Track processed transaction IDs to prevent duplicate validation

Solution 3: Handle receipt-failed Gracefully

To avoid the receipt-failed error, implement a retry mechanism:

const { finishTransaction } = useIAP({
  onPurchaseSuccess: async (purchase: Purchase) => {
    try {
      // Try JWS first (more reliable)
      const jws = await getTransactionJwsIOS(purchase.productId);

      if (jws) {
        await validateWithBackend({ jws });
        await finishTransaction({ purchase, isConsumable: true });
        return;
      }

      // Fallback to receipt if JWS unavailable
      const receipt = await getReceiptDataIOS();
      await validateWithBackend({ receipt, transactionId: purchase.id });
      await finishTransaction({ purchase, isConsumable: true });

    } catch (error) {
      if (error.code === ErrorCode.ReceiptFailed) {
        console.log("Receipt not ready, transaction will retry on next launch");
        // Don't finish - let it retry automatically
        return;
      }

      // Other errors - still finish to prevent retry loop
      console.error("Validation error:", error);
      await finishTransaction({ purchase, isConsumable: true });
    }
  },
});

Code Improvements Made

I've improved the library to help prevent this confusion in the future:

1. Enhanced Documentation

Added clear warnings to the API documentation:

/**
 * ⚠️ **IMPORTANT**: iOS receipts are cumulative and contain ALL transactions for the app,
 * not just the most recent one. The receipt data does not change between purchases.
 *
 * **For individual purchase validation, use `getTransactionJwsIOS(productId)` instead.**
 */

2. Runtime Warnings

Added console warnings when using receipt functions:

[getReceiptDataIOS] ⚠️ iOS receipts contain ALL transactions, not just the latest one.
For individual purchase validation, use getTransactionJwsIOS(productId) instead.

These warnings will appear in the console to alert developers about the correct usage.

Summary

• ✅ This is expected iOS behavior, not a bug
• ✅ Use getTransactionJwsIOS(productId) instead of getReceiptDataIOS() for individual purchase validation
• ✅ The library now includes warnings to help developers avoid this confusion
• ✅ Your backend should track transaction IDs to prevent duplicate processing

[idlework]

Thank you for pointing me in the right direction. I didn't know about the new JWS token, and I wasn't aware of the name change and the change in how it works. We had to refactor the backend for the JWS token, and now everything is working correctly.