verify_local_purchase

A Flutter package for verifying in-app purchases and subscriptions locally on device with Apple App Store and Google Play Store. This package allows you to validate purchases without the need for a backend server.

Features

✅ Local verification - Verify purchases directly from your Flutter app
🍎 Apple App Store - Support for iOS and macOS in-app purchases and subscriptions
🤖 Google Play Store - Support for Android in-app purchases and subscriptions
🔒 Official APIs - App Store Server API and Google Play Developer API
📋 Rich results - State, expiration, auto-renew and sandbox flag, not just a boolean
⚡ Easy to use - Simple initialization and verification methods

🔑 Getting Credentials

Before using this package, you need to get API credentials from each platform:

🍎 Apple App Store (iOS/macOS)

Go to App Store Connect
Navigate to Users and Access > Keys
Click the + button to create a new key
Name it (e.g., "In-App Purchase Verification")
Select App Manager role
Click Generate
Download the .p8 file (you can only do this once!)
Note down your Issuer ID (at the top) and Key ID

You'll need:

✅ Issuer ID (UUID format)
✅ Key ID (10 characters)
✅ Private Key (content of the .p8 file)
✅ Bundle ID (from your Xcode project)

🤖 Google Play Store (Android)

Go to Google Cloud Console
Select your project (or create one)
Navigate to APIs & Services > Library, search for Google Play Android Developer API and click Enable
Navigate to IAM & Admin > Service Accounts
Click Create Service Account
Name it (e.g., "In-App Purchase Verifier")
Grant role: Pub/Sub > Pub/Sub Editor (or create custom role)
Click Done
Click on the created service account
Go to Keys tab > Add Key > Create new key
Choose JSON format and click Create
The JSON file will be downloaded automatically

Now link it to Google Play:

Go to Google Play Console
Navigate to Setup > API access
Click Link next to your service account
Grant permissions: View financial data and Manage orders
Click Invite user and then Invite user again

You'll need:

✅ Service Account JSON file (entire content)
✅ Package Name (from your build.gradle)

Installation

Add this to your pubspec.yaml:

dependencies:
  verify_local_purchase: ^2.0.0

in_app_purchase is re-exported by this package — you don't need to add it separately.

Run:

flutter pub get

Upgrading from 1.x? See Migrating from 1.x.

Quick Reference

Initialization:

void main() {
  VerifyLocalPurchase.initialize(
    appleConfig: AppleConfig(
      bundleId: 'com.example.app',
      issuerId: 'your-issuer-id',
      keyId: 'your-key-id',
      privateKey: '-----BEGIN PRIVATE KEY-----\n...\n-----END PRIVATE KEY-----',
      // Default: production, retrying in sandbox when the transaction is not
      // found there (App Review and TestFlight use sandbox).
      environment: AppleEnvironment.productionWithSandboxFallback,
    ),
    googlePlayConfig: GooglePlayConfig(
      packageName: 'com.example.app',
      serviceAccountJson: '{ ... }',
    ),
    enableLogging: kDebugMode, // masked tokens; off by default
  );

  runApp(const MyApp());
}

Verify straight from `PurchaseDetails`

The easiest path — the package extracts the right token for each platform:

// One-time purchase (consumable or non-consumable)
final result = await VerifyLocalPurchase.verifyPurchaseDetails(purchase);

// Subscription
final result = await VerifyLocalPurchase.verifySubscriptionDetails(purchase);

if (result.isValid) {
  // ✅ Grant access
} else {
  // ❌ result.state tells why: expired, revoked, pending, notFound...
}

Verify with a token

If you store tokens yourself, use getOneTimePurchaseToken / getSubscriptionToken and pass the string:

final token = getSubscriptionToken(purchase);
final result = await VerifyLocalPurchase.verifySubscription(token);

Platform	One-time purchase	Subscription
iOS/macOS	`purchase.purchaseID` (transaction ID)	`originalTransactionId` from `localVerificationData`
Android	`serverVerificationData` (purchase token)	`serverVerificationData` (subscription token)

Both helpers throw VerifyPurchaseException (invalidToken) if the token is missing.

`VerificationResult`

Field	Description
`isValid`	Whether to grant access now
`state`	`purchased`, `active`, `canceled`, `gracePeriod`, `billingRetry`, `onHold`, `paused`, `pending`, `expired`, `revoked`, `notFound`, `unknown`
`platform`	`StorePlatform.apple` / `StorePlatform.google`
`productId`	Product returned by the store
`expiresAt`	End of the current subscription period (use it to cache the result)
`willAutoRenew`	Whether the subscription renews automatically
`isSandbox`	Answer came from sandbox / a test purchase
`raw`	Decoded store payload

When is a subscription valid?

Store	Valid (`isValid: true`)	Not valid
Apple	Active (1), Billing Grace Period (4) — canceled auto-renew still counts until expiration	Expired (2), Billing Retry (3), Revoked (5)
Google	`ACTIVE`, `CANCELED`, `IN_GRACE_PERIOD` and `expiryTime` in the future	`PENDING`, `ON_HOLD`, `PAUSED`, `EXPIRED`

Errors

Every method throws VerifyPurchaseException with a code:

try {
  final result = await VerifyLocalPurchase.verifyPurchaseDetails(purchase);
} on VerifyPurchaseException catch (e) {
  switch (e.code) {
    case VerifyPurchaseErrorCode.networkError:
      // offline — retry later, don't revoke access
    case VerifyPurchaseErrorCode.unauthorized:
    case VerifyPurchaseErrorCode.invalidCredentials:
      // configuration problem
    default:
      // e.statusCode / e.storeErrorCode have details
  }
}

An unknown token/transaction is not an error: it returns VerificationResult with state: notFound.

Refunds

// Apple: refunds for one customer
final appleRefunds = await VerifyLocalPurchase.getRefundsWithAppStore(originalTransactionId);

// Google: all voided purchases of the app (last 30 days by default, paginated)
final googleRefunds = await VerifyLocalPurchase.getRefundsWithGooglePlay(
  startTime: DateTime.now().subtract(const Duration(days: 7)),
);

Complete Example

import 'dart:async';

import 'package:flutter/material.dart';
import 'package:verify_local_purchase/verify_local_purchase.dart';

void main() {
  VerifyLocalPurchase.initialize(
    appleConfig: AppleConfig(
      bundleId: 'com.example.app',
      issuerId: 'your-issuer-id-here',
      keyId: 'your-key-id-here',
      privateKey: '''-----BEGIN PRIVATE KEY-----
YOUR_PRIVATE_KEY_CONTENT_HERE
-----END PRIVATE KEY-----''',
    ),
    googlePlayConfig: GooglePlayConfig(
      packageName: 'com.example.app',
      serviceAccountJson: '''{ "type": "service_account", ... }''',
    ),
  );

  runApp(const MaterialApp(home: StorePage()));
}

class StorePage extends StatefulWidget {
  const StorePage({super.key});

  @override
  State<StorePage> createState() => _StorePageState();
}

class _StorePageState extends State<StorePage> {
  final _inAppPurchase = InAppPurchase.instance;
  StreamSubscription<List<PurchaseDetails>>? _subscription;

  @override
  void initState() {
    super.initState();
    _subscription = _inAppPurchase.purchaseStream.listen(_onPurchaseUpdate);
  }

  @override
  void dispose() {
    _subscription?.cancel();
    super.dispose();
  }

  Future<void> _onPurchaseUpdate(List<PurchaseDetails> purchases) async {
    for (final purchase in purchases) {
      if (purchase.status == PurchaseStatus.purchased ||
          purchase.status == PurchaseStatus.restored) {
        await _verifyAndComplete(purchase);
      } else if (purchase.pendingCompletePurchase) {
        await _inAppPurchase.completePurchase(purchase);
      }
    }
  }

  Future<void> _verifyAndComplete(PurchaseDetails purchase) async {
    try {
      final result = await VerifyLocalPurchase.verifyPurchaseDetails(purchase);

      if (result.isValid) {
        // ✅ TODO: grant access to result.productId
      } else {
        debugPrint('❌ Purchase not valid: ${result.state}');
      }

      if (purchase.pendingCompletePurchase) {
        await _inAppPurchase.completePurchase(purchase);
      }
    } on VerifyPurchaseException catch (e) {
      // Network/config errors: keep the purchase pending to retry later
      debugPrint('⚠️ Could not verify: $e');
    }
  }

  @override
  Widget build(BuildContext context) => const Scaffold();
}

Configuration Reference