Skip to content
AppDues
Log in
Contact salesSign up

App Store Receipt Signing Certificate Change: Who Is Affected and How to Respond

Apple's App Store receipt signing certificate moved to a new WWDR intermediate certificate in early 2023, and the earlier certificate stopped functioning after its expiry date. Most apps were never exposed. The narrow group that was exposed had pinned that intermediate certificate inside an on-device validation routine. This guide gives you a short triage checklist, explains what actually fails, and lays out the three realistic responses so you can pick one deliberately rather than by reflex.

What changed, and why the date mattered

Apple announced the change in December 2022. From January 18, the App Store receipt signing certificate would use a new WWDR intermediate certificate; from February 7, the previous certificate would expire and no longer function. The expiry date was written into the certificate itself, so the deadline was visible long before it arrived — it just looked distant when the validation code was first written.

The practical lesson is not about this one date. It is that a certificate baked into your binary has a fixed lifetime, and any future rotation by Apple restarts the same clock.

What actually fails when the certificate expires

The break lands on the signature check. Inside the PKCS #7 container that carries the receipt data sits the iTunes App Store Certificate, and the app's validation routine is expected to confirm it against the WWDR Certificate. When that WWDR Certificate has passed its expiry, the confirmation cannot succeed and validation reports a failure. The receipt payload itself is untouched — the bytes the user received are the same bytes you are parsing.

That distinction matters because the failure you see in production is usually one step removed. A trust-chain rejection is a cryptographic verdict; 'this user is not entitled' is a product decision your code makes afterwards. If your error handling collapses the first into the second, paying customers get locked out of content they bought, support queues fill up, and reviews turn negative. During triage, separate the two: confirm whether verification itself is failing before you touch entitlement logic.

Triage checklist: are you exposed?

Work through these in order. The affected set is narrow, and most teams can stop at the first step.

  1. Do you verify transactions with the AppTransaction and Transaction APIs? If yes, you are not in the affected path.
  2. Do you use the verifyReceipt web service endpoint? If yes, you are not in the affected path.
  3. Do you perform on-device receipt validation with a hardcoded intermediate certificate? If yes, you are exposed and need to act.

Only the third combination matters. In other words, the exposure is the pattern of pinning the intermediate certificate locally instead of relying on the recommended trust chain. If you are unsure which of the three describes your codebase, search the project for a bundled certificate resource and for any local PKCS #7 parsing before assuming you are safe.

Three response paths, and how to choose

Apple's suggested route is to follow the recommended validation process in its Validating Receipts with the App Store documentation. For apps currently validating on-device, that means sending the binary encrypted receipt through the verifyReceipt endpoint from a secure server. The app itself must not be the party that talks to Apple's server: you control neither end of that connection, so a trusted link between the App Store and the user's device cannot be established. If no such server exists yet, building one is typically days of work.

With limited time, three options are on the table:

  • Replace the pinned certificate with the new one. This is the fastest fix and the one to avoid. It restores validation but leaves the same fragility in place for the next rotation.
  • Move to a non-pinned trust chain. Guidance exists for StoreKit 2; teams still on StoreKit 1 face a more involved change and generally need a dedicated on-device validation walkthrough.
  • Offload validation to a managed backend. Installing an SDK that provides the secure server removes the certificate-pinning problem from your binary entirely, along with the maintenance burden.

A reasonable decision rule: if you have server capacity and time, follow Apple's recommended process; if you are on StoreKit 2 and want to stay on-device, remove the pin; if neither holds, offloading is the shortest safe path. Replacing the certificate is only defensible as a stopgap with a scheduled follow-up.

What a managed validation backend covers

If you take the offload path, the SDK installation supplies the secure server that Apple's guidance calls for. Beyond receipt validation, a subscription backend of this kind typically lets you host and configure products remotely from a dashboard, review your subscription metrics in one place, inspect customer transaction histories and LTV charts, grant promotional subscriptions, and trigger other services from real-time events via webhooks — across platforms. Treat that list as a scope description to check against your own needs, not as a promise about any specific plan.

The takeaway beyond this deadline

The blast radius of this particular expiry was small, but it belongs to a long series of platform changes that consume engineering time without adding product value. The durable fix is structural: keep certificate trust out of your shipped binary, or keep it in one place you can rotate without an app release. Whichever path you choose, write down the certificate's expiry date next to the code that depends on it.

Frequently asked questions

How do I know if my app is affected?

You are affected only if all three hold: you do not use the AppTransaction and Transaction APIs, you do not use the verifyReceipt endpoint, and you validate receipts on-device with a hardcoded intermediate certificate. Any other combination falls outside the affected path.

What exactly fails when the old certificate expires?

The app can no longer use the expired WWDR Certificate to validate the iTunes App Store Certificate inside the PKCS #7 container holding the receipt. The receipt data itself is unchanged; the signature check is what breaks.

Why not just swap in the new certificate?

It works immediately, but it recreates the same problem at the next certificate change. It is acceptable only as a temporary measure with a planned migration away from pinning.

Can the app call the App Store server directly to validate?

No. You control neither end of that connection, so a trusted link between the App Store and the user's device cannot be established. Validation through verifyReceipt belongs on a secure server you operate.

Does the StoreKit version change the fix?

Yes. Guidance for removing the pinned certificate is straightforward with StoreKit 2. On StoreKit 1 the change is more involved and generally needs a dedicated on-device validation walkthrough.