What do iOS privacy manifest requirements actually enforce?
At upload, Apple checks two things: that your code's use of certain system APIs has a declared, approved reason, and that specific third-party SDKs ship their own manifest and signature. The rest of the manifest drives disclosure and runtime behavior rather than acting as an upload gate.
That distinction matters for triage. A missing reason for UserDefaults earns an ITMS-91053 Missing API declaration email from App Store Connect, and Apple has moved from warnings to rejecting builds with these gaps. A wrong tracking flag won't bounce the upload, but it can quietly break attribution at runtime or contradict your privacy label at review.
For a subscription app, the stakes are concrete. Your paywall SDK, subscription SDK, and analytics or attribution SDK are exactly the dependencies most likely to touch required reason APIs. One stale version pinned in your lockfile can hold a pricing test hostage through a week of resubmissions.
The six steps, ordered by impact
Fix the upload-blocking problems first, then the silent ones, then lock in a process so you don't regress.
- Update every third-party SDK to a version that ships its own privacy manifest.
- Declare the required reason APIs your own code calls.
- Set
NSPrivacyTrackinghonestly and list tracking domains on separate hostnames. - Declare collected data types and reconcile them with your App Store privacy label.
- Generate Xcode's privacy report from an archive before every submission.
- Re-verify against Apple's current lists every release cycle.
Steps 1 and 2 clear the errors that stop uploads. Steps 3 and 4 prevent slower failures: broken attribution and review-time mismatches. Steps 5 and 6 keep a passing build passing.
Step 1: Why update third-party SDKs before your own manifest?
Because SDK gaps are the most common manifest failure, and nothing you put in your own file can fix them. Each bundle's manifest is read separately, so the SDK has to carry its own.
Apple maintains a list of commonly used third-party SDKs covering analytics, networking, crash reporting, and similar libraries. If your app includes any of them, each must include its own PrivacyInfo.xcprivacy, and binary dependencies must also be signed. Your app-level manifest doesn't cover an SDK's behavior, because Xcode treats every bundle's manifest independently. So if an old analytics framework reads file timestamps without declaring it, adding that reason to your own file won't clear an ITMS-91061 Missing privacy manifest flag. The fix is almost always an SDK upgrade, since most maintainers shipped manifests once Apple announced the requirement. Static linking is the trap. When an SDK is linked statically, its manifest can get dropped unless the SDK packages it as a resource bundle, so confirm the file actually lands in your built product rather than trusting the release notes.
What to change: open Package.resolved or Podfile.lock, list every dependency, check each against Apple's list, and bump to a manifest-bearing version.
How to verify: in a built .app, choose Show Package Contents and confirm each framework contains a PrivacyInfo.xcprivacy. Step 5's report confirms it again.
The classic scenario: you pinned an attribution SDK years ago because a newer release changed its init API. That pin is now your biggest compliance risk, so budget the migration instead of deferring it again.
Step 2: How do you declare required reason APIs in your own code?
Add an entry under NSPrivacyAccessedAPITypes for each API category your code touches, with an approved reason code. The categories are UserDefaults, file timestamps, system boot time, disk space, and active keyboards, and nearly every app hits UserDefaults.
Required reason APIs are system calls Apple considers useful for fingerprinting, meaning identifying a device without consent. Rather than ban them, Apple requires you to state why you call them, choosing from a fixed list of approved reasons that each carry a code. For UserDefaults, the common reason is CA92.1: reading and writing data only your app can access. Each entry pairs a category, such as NSPrivacyAccessedAPICategoryUserDefaults, with an array of reason codes. The mechanism is accountability, not behavioral detection: Apple's tooling scans your binary for the relevant symbols, then checks that a declaration exists. If you share defaults with a widget through an App Group, that's a different reason from app-only access, so don't paste CA92.1 blindly. Pick the reason that matches what the code does, and pull codes from Apple's current documentation, because the list evolves.
What to change: search your codebase for UserDefaults, creationDate, modificationDate, systemUptime, mach_absolute_time, volumeAvailableCapacity, and activeInputModes. Add one category entry per hit type.
How to verify: upload a build to TestFlight. No ITMS-91053 email for your own target means the declarations landed.
Step 3: When should NSPrivacyTracking be true?
Only when your app or an SDK links user data with third-party data for targeted advertising or measurement, or shares it with data brokers. That's Apple's App Tracking Transparency definition, and the manifest uses the same one.
If you set it to true, list every tracking hostname in NSPrivacyTrackingDomains. The mechanism has teeth: on recent iOS versions, the system blocks network requests to declared tracking domains until the user grants ATT permission. A hostname that serves both tracking and non-tracking traffic needs splitting, or declaring it blocks your legitimate calls too.
Picture running Meta Ads with their SDK handling attribution. When a user declines ATT, requests to declared tracking domains fail by design. That's correct behavior, but it changes what your ad reporting can see, so plan your measurement around it rather than discovering it in a dashboard dip.
How to verify: run the app through a proxy such as Proxyman with ATT denied and confirm which requests fail and which still succeed.
Step 4: How should collected data types match your privacy label?
NSPrivacyCollectedDataTypes lists each data type you collect, whether it's linked to identity, whether it's used for tracking, and its purposes. It should agree with the privacy nutrition label in App Store Connect, because the two are meant to describe the same app.
Subscription apps nearly always collect purchase history through their subscription SDK. Add a user or device identifier if you sync entitlements across devices, plus crash data and product interaction if you run analytics. Review those SDKs' own manifests too, since their declarations roll into the aggregate picture.
How to verify: put the Step 5 report and your current App Store privacy label side by side, then fix any data type that appears in one but not the other.
Step 5: How do you generate Xcode's privacy report?
Archive the app, open the Organizer, right-click the archive, and choose Generate Privacy Report. Xcode produces a PDF aggregating your manifest with every bundled SDK's manifest.
Read it for three things: every SDK from your lockfile appears, no tracking domain surprises you, and data types match your label. An SDK missing from the report means its manifest didn't ship, which sends you back to Step 1. Make this a fixed line in your release checklist, right before upload.
Step 6: Why re-verify every Apple cycle?
Because Apple revises the commonly used SDK list, the approved reasons, and the review guidelines over time. A manifest that passed last fall can fail next spring with zero code changes.
Set a recurring check after WWDC and after each major Xcode release, then re-run Steps 1 and 5. If you'd rather get an alert than keep a calendar reminder, AppApex tracks App Store Review Guideline changes, flags at-risk setups, and audits privacy manifest and SDK compliance alongside rejection coaching. Manifest issues rarely arrive alone, so it's worth knowing the most common App Store rejection reasons and how to handle a paywall rejection under guideline 3.1.2.
Where does the usual advice go wrong?
Most privacy manifest advice errs toward over-declaring or assuming someone else owns the problem. Both create risk you can avoid.
| Common advice | Why it's wrong | Do this instead |
|---|---|---|
| Declare every reason code to be safe | Reasons are statements of what your code does; over-declaring misrepresents it | Declare only reasons that match actual calls |
| Set tracking to true just in case | It triggers runtime blocking of declared domains when ATT is denied | Set it from Apple's definition, not caution |
| SDK vendors handle their own compliance | You ship the binary; old pins and static linking drop manifests | Verify each SDK's manifest in the built product |
| The manifest fills in your privacy label | The label is entered separately in App Store Connect | Use the report as input, then update the label by hand |
The tracking row deserves emphasis. Developers flip NSPrivacyTracking to true defensively, then wonder why requests fail for users who declined ATT. Caution in a declaration isn't free; it changes how the app behaves.
What should you do with 30 minutes today?
Archive your current build, generate the privacy report, and compare its SDK list against your lockfile. Any dependency missing from the report is your first fix.
Then run the app through the free Privacy Manifest Checker as an outside check before your next submission. Once compliance is off your plate, see where the rest of your funnel stands with a free Growth Audit: enter your App Store ID and get a health score plus analysis, no account needed.
Last updated October 23, 2026