Skip to content
AppDues
Log in
Contact salesSign up

Migrating from StoreKit 1 to StoreKit 2

Apple has deprecated the StoreKit 1 APIs — now labeled the "original API for in-app purchase" — and new features going forward target StoreKit 2 only. This guide maps the two migration routes: upgrading an SDK that already wraps StoreKit 2, or doing the work yourself. For the manual route it covers the three things that actually change: how purchase data is represented, where verification happens, and which iOS versions can run the new APIs.

Why the migration is on your roadmap

In-app purchase has existed on Apple platforms since iPhone OS 3.0 in 2009, and for most of that span developers worked against the original StoreKit APIs. StoreKit 2 was introduced at WWDC 2021 as a Swift-only framework built around modern async APIs.

At WWDC 2024 Apple formally deprecated the StoreKit 1 APIs. They still function for the time being, but Apple's direction is clear: new capabilities and updates will land in StoreKit 2 only. Treat the deprecation as a scheduling signal rather than an outage — you have room to plan, not room to ignore it.

Route A: upgrade through your SDK

If your app already depends on an in-app purchase SDK, check that vendor's documentation for whether it has adopted StoreKit 2 and what its upgrade path requires. Where it has, much of the framework-level work — the entity changes, the server API calls, and the version fallbacks described below — may already be handled inside the SDK, but that is a claim to confirm per vendor rather than assume.

Before you commit, read that vendor's launch notes and migration guide for caveats; an SDK upgrade is not automatically a drop-in for every app configuration. The appeal of this route is that the StoreKit 2 plumbing becomes someone else's maintenance burden — not that no review is needed.

Route B: migrate manually

Doing the migration yourself is substantially more involved. Three workstreams drive the effort, and they can be sequenced:

  1. Client data model — stop parsing the old receipt and read the new signed entities instead.
  2. Server verification — replace receipt-based validation with App Store Server API calls.
  3. Compatibility — keep StoreKit 1 paths alive for devices below the StoreKit 2 floor.

Tackle the client entities first so you can see real transaction data, then move verification server-side, then close the version gap. The checklist below turns that order into concrete checks.

Replace the receipt: Transaction, RenewalInfo, and JWS

StoreKit 2 retires the single receipt blob. In its place Apple provides discrete entities — Transaction and RenewalInfo among them — that carry the same underlying data, signed as a JSON Web Signature (JWS).

Every place your code opened the receipt and parsed fields out of it needs to be rewritten against these entities. The practical consequence: field extraction moves from byte-offset parsing of one payload to reading typed properties from signed objects, and signature verification becomes part of your read path rather than an afterthought.

Move verification to the App Store Server API

On the backend, the App Store Server API becomes your source for verifying transactions and auto-renewable subscription status, plus refund information, order lookups, and other customer in-app purchase history.

This is the step most likely to touch systems outside the app binary. If your server currently validates a receipt payload, plan for new endpoints, new response shapes, and a period where old and new verification paths coexist while installed clients catch up.

Backwards compatibility: the iOS 15 floor and the iOS 16 gap

StoreKit 2 requires iOS 15 or later. If your app still supports iOS 15 or earlier, those older devices must continue on the StoreKit 1 APIs — you maintain two code paths, not one.

There is a second, sharper constraint. Some APIs did not arrive until iOS 16, including originalPurchaseDate. That matters specifically for apps that moved from a Paid Up Front model to subscriptions and want to grandfather features for users who already paid. On an iOS 15 device you cannot read that value through StoreKit 2, so the grandfathering logic needs a fallback rather than a single code path.

If your SDK handles StoreKit 2, confirm with that vendor whether this dual-path handling is covered for you.

Migration checklist

Use this before you start and again before you ship:

  • Confirm your minimum deployment target and list every supported iOS version below 15.
  • Inventory every code site that reads the old receipt; each one maps to a Transaction or RenewalInfo read.
  • Identify server endpoints that validate receipts and map each to its App Store Server API replacement.
  • Flag any feature gated on originalPurchaseDate or other iOS 16-only APIs and design a fallback.
  • Decide whether an SDK upgrade covers the work or you own each of the three workstreams.
  • Plan a coexistence window where StoreKit 1 and StoreKit 2 clients both report purchases correctly.

Where to go next

For a full walkthrough of implementing StoreKit 2 in an app, see the linked StoreKit 2 tutorial. If you are moving an existing app onto an in-app purchase platform, the migration documentation covers the available paths, and a migration consultant can help build a custom plan.

Manual StoreKit 2 migration workstreams
WorkstreamStoreKit 1 approachStoreKit 2 approachKey constraint
Purchase dataParse the receipt payloadRead Transaction and RenewalInfo entities signed as JWSAll receipt-parsing code must be rewritten
Server verificationValidate the receipt on your backendCall the App Store Server API for transaction and subscription status, refunds, orders, and purchase historyBackend endpoints and response handling change
Version supportSingle StoreKit 1 pathStoreKit 2 on iOS 15+, StoreKit 1 fallback beloworiginalPurchaseDate and some APIs require iOS 16

Describes the manual migration route only; an SDK that supports StoreKit 2 may handle these workstreams for you — verify with the vendor. Version requirements reflect Apple's documented StoreKit 2 availability at the time of writing — confirm against current Apple documentation.

Frequently asked questions

Can I run StoreKit 1 and StoreKit 2 in the same app?

Yes — and if you support iOS 15 or earlier you must. StoreKit 2 requires iOS 15 or later, so devices on older versions need to keep using the StoreKit 1 APIs while newer devices use StoreKit 2.

What replaces the receipt in StoreKit 2?

Discrete signed entities such as Transaction and RenewalInfo. They carry the same data the receipt did, but signed as a JSON Web Signature (JWS), so code that parsed fields out of the receipt must be rewritten to read these entities.

Why does originalPurchaseDate matter for grandfathering?

Apps that moved from a Paid Up Front model to subscriptions use originalPurchaseDate to identify users who already paid and keep their features unlocked. That API was not added until iOS 16, so on iOS 15 devices the grandfathering logic needs a fallback.

Do I still need server-side verification with StoreKit 2?

Yes. On the backend you use the App Store Server API to verify transactions and auto-renewable subscription status, along with refund information, order lookups, and other purchase history.