How to detect refunded/revoked IAPs (Google Play)

Unity 2019.4.3
Unity IAP 1.23.4
Platform Android/Google

We are trying to check on startup if the IAPs a user has purchased are still valid and have not been revoked (via refund).

We tried to refresh the receipts by calling

UnityPurchasing.ClearTransactionLog();
UnityPurchasing.Initialize(this, builder);

but the receipts stays the same with purchaseState=0 and isOwned=true after refund with revoke.

What would be the proper way to check the status of an IAP on Google Play (e.g.on Apple there is a refresh receipt method)?

I’m afraid Google doesn’t provide the feature to check if the product has been refunded. Refunds a user’s subscription purchase, the subscription still remains valid until its expiration time and it will continue to recur.

You can check Google’s subscription filed here:
https://developers.google.com/android-publisher/api-ref/purchases/subscriptions

Thank you for your fast reply!

We are currently not using subscriptions.

Our products are non-consumable managed products.

Is there a way to check, if the user has purchased them?

E.g. in the native Google Play Billing Library one can use queryPurchases (String skuType) to query for purchases made with the app.

https://developer.android.com/reference/com/android/billingclient/api/BillingClient?hl=en#querypurchases

Please show the code that you are using, and where you call it during IAP initialization. Please show a screenshot of your Google dashboard with Revoke selected.

Below the code we are using for store interactions.

It is a straight forward adaption of the IAP example (older version, the app was created 2017).

I look at the receipts in the OnInitialized(IStoreController controller, IExtensionProvider extensions) callback, just printing them out the the console.

using System;
using System.Collections.Generic;
using FoxAndSheep.Services.Purchase;
using UnityEngine;
using UnityEngine.Purchasing;


// Deriving the Purchaser class from IStoreListener enables it to receive messages from Unity Purchasing.
public class PurchaseService : IStoreListener
{
    private static IStoreController m_StoreController;
    // The Unity Purchasing system.
    private static IExtensionProvider m_StoreExtensionProvider;
    // The store-specific Purchasing subsystems.

    // Product identifiers for all products capable of being purchased:
    // "convenience" general identifiers for use with Purchasing, and their store-specific identifier
    // counterparts for use with and outside of Unity Purchasing. Define store-specific identifiers
    // also on each platform's publisher dashboard (iTunes Connect, Google Play Developer Console, etc.)

    // General product identifiers for the consumable, non-consumable, and subscription products.
    // Use these handles in the code to reference which product to purchase. Also use these values
    // when defining the Product Identifiers on the store. Except, for illustration purposes, the
    // kProductIDSubscription - it has custom Apple and Google identifiers. We declare their store-
    // specific mapping to Unity Purchasing's AddProduct, below.

    //    // Apple App Store-specific product identifier for the subscription product.
    //    private static string kProductNameAppleSubscription = "com.unity3d.subscription.new";
    //
    //    // Google Play Store-specific product identifier subscription product.
    //    private static string kProductNameGooglePlaySubscription = "com.unity3d.subscription.original";

    private readonly List<IPurchaseResultListener> _purchaseResultListener = new List<IPurchaseResultListener>();

    public void Init(List<IAPStorePackageData> ids)
    {
        // If we haven't set up the Unity Purchasing reference
        if (m_StoreController == null)
        {
            // Begin to configure our connection to Purchasing
            InitializePurchasing(ids);
        }
    }

    public void InitializePurchasing(List<IAPStorePackageData> ids)
    {
        if (IsInitialized())
        {
            return;
        }

        // Create a builder, first passing in a suite of Unity provided stores.
        var builder = ConfigurationBuilder.Instance(StandardPurchasingModule.Instance());

        #if UNITY_IOS
        string storeId = AppleAppStore.Name;
        #else
        string storeId = GooglePlay.Name;
        #endif

        foreach (var id in ids)
        {
            builder.AddProduct(id.id, ProductType.NonConsumable, new IDs()
                {
                    { id.storeId, storeId }
                });
        }

        // Kick off the remainder of the set-up with an asynchrounous call, passing the configuration
        // and this class' instance. Expect a response either in OnInitialized or OnInitializeFailed.
        UnityPurchasing.Initialize(this, builder);       
    }

    public bool IsInitialized()
    {
        // Only say we are initialized if both the Purchasing references are set.
        return m_StoreController != null && m_StoreExtensionProvider != null;
    }

    public void BuyProductID(string productId)
    {
        // If Purchasing has been initialized ...
        if (IsInitialized())
        {
            // ... look up the Product reference with the general product identifier and the Purchasing
            // system's products collection.
            Product product = m_StoreController.products.WithID(productId);

            // If the look up found a product for this device's store and that product is ready to be sold ...
            if (product != null && product.availableToPurchase)
            {
                Debug.Log(string.Format("Purchasing product asychronously: '{0}'", product.definition.id));
                // ... buy the product. Expect a response either through ProcessPurchase or OnPurchaseFailed
                // asynchronously.
                m_StoreController.InitiatePurchase(product);
            }
                // Otherwise ...
                else
            {
                // ... report the product look-up failure situation 
                Debug.LogFormat("BuyProductID: FAIL. Not purchasing product, either is not found or is not available for purchase product={0}", product);
                BroadcastPurchaseResult(productId, PurchaseResult.Failure);               
            }
        }
            // Otherwise ...
            else
        {
            // ... report the fact Purchasing has not succeeded initializing yet. Consider waiting longer or
            // retrying initiailization.
            Debug.Log("BuyProductID FAIL. Not initialized.");
            BroadcastPurchaseResult(productId, PurchaseResult.Failure);           
        }
    }


    // Restore purchases previously made by this customer. Some platforms automatically restore purchases, like Google.
    // Apple currently requires explicit purchase restoration for IAP, conditionally displaying a password prompt.
    public void RestorePurchases()
    {
        // If Purchasing has not yet been set up ...
        if (!IsInitialized())
        {
            // ... report the situation and stop restoring. Consider either waiting longer, or retrying initialization.
            Debug.Log("RestorePurchases FAIL. Not initialized.");
            return;
        }

    // If we are running on an Apple device ...
    if (Application.platform == RuntimePlatform.IPhonePlayer ||
        Application.platform == RuntimePlatform.OSXPlayer) {
      // ... begin restoring purchases
      Debug.Log("RestorePurchases started ...");
   

            // Fetch the Apple store-specific subsystem.
            var apple = m_StoreExtensionProvider.GetExtension<IAppleExtensions>();
            // Begin the asynchronous process of restoring purchases. Expect a confirmation response in
            // the Action<bool> below, and ProcessPurchase if there are previously purchased products to restore.
            apple.RestoreTransactions((result) =>
                {
                    // The first phase of restoration. If no more responses are received on ProcessPurchase then
                    // no purchases are available to be restored.
                    Debug.Log("RestorePurchases continuing: " + result + ". If no further messages, no purchases available to restore.");
                });
           
        }
            // Otherwise ...
            else
        {
            BroadcastPurchaseResult(null, PurchaseResult.Failure);
            // We are not running on an Apple device. No work is necessary to restore purchases.
            Debug.Log("RestorePurchases FAIL. Not supported on this platform. Current = " + Application.platform);
        }

    }

    public void AddResultListener(IPurchaseResultListener resultListener)
    {
        if(_purchaseResultListener.Contains(resultListener))
            return;
       
        _purchaseResultListener.Add(resultListener);
    }

    public void RemovePurchaseResultListener(IPurchaseResultListener resultListener)
    {
        if(!_purchaseResultListener.Contains(resultListener))
            return;

        _purchaseResultListener.Remove(resultListener);
    }

    private void BroadcastPurchaseResult(string productId, PurchaseResult result)
    {
        foreach (var listener in _purchaseResultListener)
        {
            listener.HandlePurchaseFinished(productId, result);
        }
    }

    //
    // --- IStoreListener
    //

    public void OnInitialized(IStoreController controller, IExtensionProvider extensions)
    {
        // Purchasing has succeeded initializing. Collect our Purchasing references.
        Debug.Log("OnInitialized: PASS");

        // Overall Purchasing system, configured with products for this application.
        m_StoreController = controller;
        // Store specific subsystem, for accessing device-specific store features.
        m_StoreExtensionProvider = extensions;

        foreach(var item in controller.products.all)
        {
            Debug.LogFormat("receipt={0}", item.receipt);
            if(!string.IsNullOrEmpty(item.receipt))
                Debug.LogFormat("receipt={0}", item.receipt.Substring(item.receipt.Length -100,100));// To check for isOwned
        }
    }


    public void OnInitializeFailed(InitializationFailureReason error)
    {
        // Purchasing set-up has not succeeded. Check error for reason. Consider sharing this reason with the user.
        Debug.Log("OnInitializeFailed InitializationFailureReason:" + error);
    }


    public PurchaseProcessingResult ProcessPurchase(PurchaseEventArgs args)
    {
        // A consumable product has been purchased by this user.
        if (args.purchasedProduct.definition.id != null)
        {
            Debug.Log(string.Format("ProcessPurchase: PASS. Product: '{0}'", args.purchasedProduct.definition.id));
            BroadcastPurchaseResult(args.purchasedProduct.definition.id, PurchaseResult.Success);           

        }
        else
        {
            Debug.Log(string.Format("ProcessPurchase: FAIL. Unrecognized product: '{0}'", args.purchasedProduct.definition.id));
            BroadcastPurchaseResult(null, PurchaseResult.Success);
        }

        // Return a flag indicating whether this product has completely been received, or if the application needs
        // to be reminded of this purchase at next app launch. Use PurchaseProcessingResult.Pending when still
        // saving purchased products to the cloud, and when that save is delayed.
        return PurchaseProcessingResult.Complete;
    }


    public void OnPurchaseFailed(Product product, PurchaseFailureReason failureReason)
    {
        // A product purchase attempt did not succeed. Check failureReason for more detail. Consider sharing
        // this reason with the user to guide their troubleshooting actions.
        Debug.Log(string.Format("OnPurchaseFailed: FAIL. Product: '{0}', PurchaseFailureReason: {1}", product.definition.storeSpecificId, failureReason));

        if (failureReason == PurchaseFailureReason.UserCancelled)
        {
            BroadcastPurchaseResult(product.definition.storeSpecificId, PurchaseResult.Cancel);
        }
        else
        {
            BroadcastPurchaseResult(product.definition.storeSpecificId, PurchaseResult.Failure);
        }
    }

    public string GetPrice(string packId)
    {
        if (IsInitialized())
        {
            Product product = m_StoreController.products.WithID(packId);
            return product.metadata.localizedPriceString;
        }
        else
        {
            return null;
        }
    }
}

After an order has been refunded it does not show if has been revoked in the Google Play Console → Order Management.

Attached is a screenshot of an order that I refund (you can see the Revoke checkmark is set).

And here is the same order after refund in the order history:

No, that is not standard code, you have added your own listeners for example. Please add Debug.Log statements throughout your code as in the Sample IAP Project, and provide the device logs and specify the line numbers in the logs that are relevant to your Debug.Log output. Please show all the runtime property values of the receipt that you claim to be receiving of a revoked product during IAP initialization in the logs.

Our issue was solved in another thread.

The issue was that it took a long time for the revoke to propagate to the device (several hours ++).

Retesting the next day the revoked IAP did not have a receipt anymore.

Google is working to improve this in their latest billing library that we plan to use when available.