TPInAppReceipt

The library is structured into three distinct layers that separate data modeling, parsing, and verification:

1. Core: Contains the data models. AppReceipt is the primary typealias representing the receipt structure. It uses generic PKCS#7 types (like ContentInfo, SignedData, and SignerInfo) to model the ASN.1 structure, while InAppReceiptPayload and InAppPurchase hold the actual decoded receipt data.
2. Decoder: Responsible for parsing raw data. It uses an Engine to transform Data into an AppReceipt.
3. Validator: Responsible for verifying the receipt. It composes multiple ReceiptVerifier implementations (such as chain, signature, hash, and meta verifiers) and runs them in parallel using a TaskGroup.

All core types are Sendable and Hashable.

To upgrade to version 4.0.0 or later, update your Swift Package Manager dependency and ensure your project meets the new platform requirements. Note that v4 introduces significant breaking changes, moving from synchronous/callback-based APIs to Swift Concurrency (async/await) and renaming core types.

.package(url: "https://github.com/tikhop/TPInAppReceipt.git", from: "4.0.0")

The core type has changed from InAppReceipt to AppReceipt. Loading the local receipt and parsing from data are now asynchronous operations.

// Loading local receipt
// Before: let receipt = try InAppReceipt.localReceipt()
let receipt = try await AppReceipt.local

// Parsing from data
// Before: let receipt = try InAppReceipt.receipt(from: data)
let receipt = try AppReceipt.receipt(from: data)

To use TPInAppReceipt in your project, add it as a dependency in your Package.swift file.

Requirements

• Swift 6.0+ / Xcode 16+
• macOS 10.15+ / iOS 13+ / tvOS 13+ / watchOS 6.2+ / visionOS 1+

dependencies: [
    .package(url: "https://github.com/tikhop/TPInAppReceipt.git", from: "4.0.2")
]

.target(
    name: "YourTarget",
    dependencies: ["TPInAppReceipt"]
)

If you are working in a context where asynchronous APIs are unavailable, you can use the Blocking SPI (System Programming Interface) to perform synchronous receipt retrieval and validation.

Note that this requires using the @_spi(Blocking) attribute to access the synchronous methods.

Key differences from Async mode:

• Verifiers: Uses Security.framework verifiers (SecChainVerifier, SecSignatureVerifier) instead of the async swift-certificates/swift-crypto implementations.
• Execution: Verifiers run sequentially rather than in parallel.
• Consistency: Hash and metadata verification logic remains identical to the async version.

@_spi(Blocking) import TPInAppReceipt

let receipt = try AppReceipt.local_blocking
let result = receipt.validate_blocking()

To verify the authenticity and integrity of an App Store receipt using the standard suite of checks, call the validate() method on a receipt instance. This runs four checks in parallel: certificate chain, signature, hash, and metadata. The validator automatically selects the appropriate Apple root certificate based on the receipt's environment.

let result = await receipt.validate()

switch result {
case .valid:
    // Proceed with trusted receipt
    break
case .invalid(let error):
    print(error)
}

The following minimum platform versions and Swift versions are required for v4:

• iOS: 13+
• macOS: 10.15+
• tvOS: 13+
• Swift: 6.0+

You can decode a receipt using AppReceipt in two ways: by accessing the local receipt stored on the device or by decoding raw data (e.g., from a network response or file). AppReceipt is a typealias over ContentInfo<SignedData<InAppReceiptPayload>>, allowing access to the full PKCS#7 structure.

import TPInAppReceipt

// Local receipt
let receipt = try await AppReceipt.local

// From raw data
let receipt = try AppReceipt.receipt(from: data)

The following features and types have been removed in v4:

• Objective-C bindings
• CocoaPods support
• isValid computed property (use await receipt.validate())
• base64 computed property
• SKSubscriptionGroup class and related SKProductsResponse extensions
• isEligibleForIntroductoryOffer(for: SKSubscriptionGroup) overload (use the Set<String> variant instead)

The callback-based InAppReceipt.refresh has been replaced by an asynchronous AppReceipt.refresh(). Methods for managing refresh sessions (cancelRefreshSession() and isReceiptRefreshingNow) have been removed; use Swift Concurrency task cancellation instead.

// After
try await AppReceipt.refresh()

If you need to request an updated receipt from the App Store, use the asynchronous refresh() method.

try await AppReceipt.refresh()

Use the AppReceipt instance to inspect the user's purchase history and active subscriptions. You can check for general purchase existence, list all purchases, or query specifically for auto-renewable subscriptions.

receipt.purchases              // [InAppPurchase]
receipt.hasPurchases
receipt.autoRenewablePurchases
receipt.activeAutoRenewableSubscriptionPurchases

// Query by product identifier
receipt.purchases(ofProductIdentifier: "com.example.sub")
receipt.containsPurchase(ofProductIdentifier: "com.example.premium")

// Subscription specific queries
receipt.hasActiveAutoRenewableSubscription(
    ofProductIdentifier: "com.example.sub",
    forDate: Date()
)

receipt.lastAutoRenewableSubscriptionPurchase(
    ofProductIdentifier: "com.example.sub"
)