After purchasing from a web paywall, the user will be presented with a link to install your app and another to redeem their purchase on device. This redeem link is a deep link that redirects to your app. Please follow our deep link setup guide to ensure everything is correctly configured.

Make sure you have configured the SDK inside application(_ application:didFinishLaunchingWithOptions:) before the deep link fires.

When your app opens via the deep link, we will call the delegate method willRedeemLink() before making a network call to redeem the code. At this point, you might wish to display a loading indicator in your app in case of network issues. After receiving a response from the network, we will call didRedeemLink(result:) with the result of redeeming the code. This is an enum that has the following cases:

  • success(code: String, redemptionInfo: RedemptionInfo): The redemption succeeded and redemptionInfo contains information about the redeemed code.
  • error(code: String, error: ErrorInfo): An error occurred while redeeming. You can check the error message via the error parameter.
  • expiredCode(code: String, expired: ExpiredCodeInfo): The code expired and ExpiredCodeInfo contains information about whether a redemption email has been resent and an optional obfuscated email address that the redemption email was sent to.
  • invalidCode(code: String): The code that was redeemed was invalid.
  • expiredSubscription(code: String, redemptionInfo: RedemptionInfo): The subscription that the code redeemed has expired.

On network failure, the SDK will retry up to 6 times before returning an error RedemptionResult in didRedeemLink(result:).

Superwall will automatically update the subscription status with the redeemed web entitlements. However, if you’re using a PurchaseController, you will need to handle this yourself.

​
Using a PurchaseController

If you’re using StoreKit in your PurchaseController, you’ll need to merge the web entitlements with the device entitlements before setting the subscription status. Here’s an example of how you might do this:

func syncSubscriptionStatus() async {
  var products: Set<String> = []

  // Get the device entitlements
  for await verificationResult in Transaction.currentEntitlements {
    switch verificationResult {
    case .verified(let transaction):
      products.insert(transaction.productID)
    case .unverified:
      break
    }
  }
  let storeProducts = await Superwall.shared.products(for: products)
  let deviceEntitlements = Set(storeProducts.flatMap { $0.entitlements })

  // Get the web entitlements from Superwall
  let webEntitlements = Superwall.shared.entitlements.web

  // Merge the two sets of entitlements
  let allEntitlements = deviceEntitlements.union(webEntitlements)

  await MainActor.run {
    Superwall.shared.subscriptionStatus = .active(allEntitlements)
  }
}

In addition to syncing the subscription status when purchasing and restoring, you’ll need to sync it whenever didRedeemLink(result:) is called:

final class Delegate: SuperwallDelegate {
  func didRedeemLink(result: RedemptionResult) {
    Task {
      await syncSubscriptionStatus()
    }
  }
}

​
Using a PurchaseController with RevenueCat

If you’re using RevenueCat, you’ll need to follow steps 1 to 4 in their guide to set up Stripe with RevenueCat. Then, you’ll need to associate the RevenueCat customer with the Stripe subscription IDs returned from redeeming the code. You can do this by extracting the ids from the RedemptionResult and sending them to RevenueCat’s API by using the didRedeemLink(result:) delegate method:

import Foundation
import RevenueCat

final class Delegate: SuperwallDelegate {
  // The user tapped on a deep link to redeem a code
  func willRedeemLink() {
    print("[!] willRedeemLink")
    // Optionally show a loading indicator here
  }

  // Superwall received a redemption result and validated the purchase with Stripe.
  func didRedeemLink(result: RedemptionResult) {
    print("[!] didRedeemLink", result)
    // Send Stripe IDs to RevenueCat to link purchases to the customer

    // Get a list of subscription ids tied to the customer.
    guard let stripeSubscriptionIds = result.stripeSubscriptionIds else { return }
    guard let url = URL(string: "https://api.revenuecat.com/v1/receipts") else { return }

    let revenueCatStripePublicAPIKey = "strp....." // replace with your RevenueCat Stripe Public API Key
    let appUserId = Purchases.shared.appUserID

    // In the background...
    Task.detached {
      await withTaskGroup(of: Void.self) { group in
        // For each subscription id, link it to the user in RevenueCat
        for stripeSubscriptionId in stripeSubscriptionIds {
          group.addTask {
            var request = URLRequest(url: url)
            request.httpMethod = "POST"
            request.setValue("application/json", forHTTPHeaderField: "Content-Type")
            request.setValue("application/json", forHTTPHeaderField: "Accept")
            request.setValue("stripe", forHTTPHeaderField: "X-Platform")
            request.setValue("Bearer \(revenueCatStripePublicAPIKey)", forHTTPHeaderField: "Authorization")

            do {
              request.httpBody = try JSONEncoder().encode([
                "app_user_id": appUserId,
                "fetch_token": stripeSubscriptionId
              ])

              let (data, _) = try await URLSession.shared.data(for: request)
              let json = try JSONSerialization.jsonObject(with: data, options: [])
              print("[!] Success: linked \(stripeSubscriptionId) to user \(appUserId)", json)
            } catch {
              print("[!] Error: unable to link \(stripeSubscriptionId) to user \(appUserId)", error)
            }
          }
        }
      }

      /// After all network calls complete, invalidate the cache without switching to the main thread.
      Purchases.shared.getCustomerInfo(fetchPolicy: .fetchCurrent) { customerInfo, error in
        /// If you're using `Purchases.shared.customerInfoStream`, or keeping Superwall Entitlements in sync
        /// via RevenueCat's `PurchasesDelegate` methods, you don't need to do anything here. Those methods will be
        /// called automatically when this call fetches the most up to customer info, ignoring any local caches.

        /// Otherwise, if you're manually calling `Purchases.shared.getCustomerInfo`  to keep Superwall's entitlements
        /// in sync, you should use the newly updated customer info here to do so.
      }

      /// You could always access web entitlements here as well
      /// `let webEntitlements = Superwall.shared.entitlements.web`

      // After all network calls complete...
      await MainActor.run {
        // Perform UI updates on the main thread, like letting the user know their subscription was redeemed
      }
    }
  }
}

If you call logIn from RevenueCat’s SDK, then you need to call the logic you’ve implemented inside didRedeemLink(result:) again. For example, that means if logIn was invoked from RevenueCat, you’d either abstract out this logic above into a function to call again, or simply call this function directly.

The web entitlements will be returned along with other existing entitlements in the CustomerInfo object accessible via RevenueCat’s SDK.

If you’re logging in and out of RevenueCat, make sure to resend the Stripe subscription IDs to RevenueCat’s endpoint after logging in.

​
Refreshing of web entitlements

If you aren’t using a Purchase Controller, the SDK will refresh the web entitlements every 24 hours.

​
Redeeming while a paywall is open

If a redeem event occurs when a paywall is open, the SDK will track that as a restore event and the paywall will close.