Apple App Review Guidelines 2026: How Independent Developers Self-Check?

Your app is ready to submit, but a new guideline revision has left you unsure whether a feature flag or promotional asset needs to change.

Fastest fix: don’t rewrite the app by default. Check whether each asset is accurate and appropriate, then make sure every real feature is clear and reviewable. Explain any non-obvious behavior in your submission notes.

This guide is for independent developers preparing a new app or update, especially teams using remote configuration, feature flags, or staged releases.
It also helps developers who manage App Store assets and need to distinguish promotional creative from screenshots and app previews.

Last updated October 21, 2026. The revision date and rule references below were checked against Apple’s October 16, 2026 announcement, the current App Review Guidelines, and Apple’s App Store Connect asset guidance.

Start with what changed in the 2026 guidelines

Apple announced a revision to the App Review Guidelines on October 16, 2026. The changes relevant here add section 2.3.14 on creative assets and clarify section 2.5.19 on hidden, dormant, or undocumented features. Apple also notes that related requirements previously appeared under section 2.3.1. These are references to Apple’s published rules, not a prediction that any particular app will be rejected. Read the rule itself before treating an individual implementation as a violation; an implementation detail such as remote configuration does not, by itself, establish that a feature is hidden.

The practical conclusion is narrower than “every app must change.” If your app has no relevant promotional creative, dormant functionality, or unclear review path, the revision alone does not establish that you need to rewrite code. If it does, inspect the affected asset or behavior and correct the mismatch before submitting.

The rule numbers and revision date in this table refer to Apple’s announcement and current guidelines. Check the applicable rule before deciding whether a change is needed. The revision does not mean that every app must immediately change its code or store listing.

Audit creative assets against the actual app

For App Store creative asset review, start by asking whether each piece of promotional creative is connected to the app’s real content, functionality, or brand. Then check whether its presentation is appropriate for the intended audience. An attractive asset can still create a review concern if it implies a capability the app does not have, uses a claim the team cannot substantiate, or promotes something unrelated to the submitted product. Apple’s current requirements are in section 2.3.14 of the App Review Guidelines.

Use this audit before uploading or replacing creative:

• Match the product: Link each claim, visual, and featured capability to something that exists in the submitted app or its stated service.
• Check audience suitability: Review imagery, language, and themes in the context of the audiences for which the app is offered.
• Verify claims: Keep evidence for concrete product claims. Remove statements that cannot be demonstrated or that describe a planned feature as if it were available.
• Review references to other apps: Make sure any reference is relevant and does not give users a misleading impression about affiliation, compatibility, or functionality.
• Recheck price language: If creative includes a price or discount, verify that the presentation remains accurate and does not imply terms that users will not receive.

These checks are not a separate guarantee of approval. They help identify claims that conflict with the submitted app or could mislead a user. When a claim depends on a specific subscription, region, or eligibility condition, make that condition clear in the appropriate listing or in-app context rather than relying on small or ambiguous creative text.

Distinguish creative assets from screenshots and previews

Promotional creative, screenshots, and app previews have different jobs. Do not treat them as interchangeable just because each appears on an App Store product page. Apple describes creative asset management in its App Store Connect asset documentation. For screenshots, follow Apple’s screenshot guidance; for previews, check the App preview specifications.

For every item, compare the asset with the exact version and metadata you intend to submit. A screenshot from an older interface can be misleading even if the feature still exists. A preview that emphasizes a capability available only under an unstated condition can leave the reviewer with a different impression from the actual app.

Check whether remote configuration makes a feature unclear

App Store hidden feature review concerns what the app contains and how users and reviewers can understand it. A feature that is switched off by default or enabled later through remote configuration is not automatically a hidden feature on that fact alone. The important question is whether the submitted app’s behavior is presented clearly and whether the reviewer can understand and evaluate the functionality under review. Apple’s wording on dormant or undocumented functionality is in section 2.5.19.

Separate ordinary staged availability from concealment by documenting what the user and reviewer encounter:

• List capabilities in the submitted build. Include features that are dormant, controlled by a flag, or activated by a server response.
• Record the activation condition. State whether a feature appears after sign-in, account eligibility, a purchase, a configuration response, or another user action.
• Check the review path. Confirm that the submitted version can reach the relevant state, or give reviewers a clear alternative where appropriate.
• Compare the behavior with the listing. Do not describe a capability as generally available if the app hides it behind an unexplained condition.
• Explain changes in rollout status. If a feature is intentionally being released in stages, make its current availability and any review-only access steps understandable.

This is a risk review, not a claim that every remotely controlled feature violates the guidelines. A feature flag can support a normal release process; it becomes a concern when the app’s real capabilities or conditions are not clear to users or reviewers. If the reviewer cannot discover a core flow, the submission notes should explain how to reach it rather than assume the reviewer will infer the configuration.

Keep the store listing and submitted behavior aligned

Review the listing as a set: metadata, creative assets, screenshots, previews, and the current app build should tell a consistent story. Check the version information associated with the submission, and compare it with the materials you intend users and reviewers to see.

For each prominent promise, answer three questions:

1. Where does the submitted app deliver this? Identify the screen, flow, or service that supports the claim.
2. Who can access it? Note any account, region, subscription, device, or rollout condition that changes availability.
3. Can the reviewer verify it? If the path is not obvious, prepare clear access instructions or supporting explanation.

Pay special attention to feature names that differ between the store listing and the interface. A reviewer should not have to guess whether two different labels refer to the same capability. Explain meaningful restrictions in plain language, and do not use a screenshot or preview to imply a broader experience than the submitted build provides.

Prepare App Review notes for non-obvious flows

For App Store Connect submission, include information that lets the reviewer reach and understand the relevant functionality. Apple’s instructions for providing complete review information are the authoritative reference for the submission details reviewers may need.

A useful note is specific and reproducible. It should identify the feature, explain its activation condition, and state the steps needed to reach it. If a feature requires an account or a particular setup, include the review access information requested by Apple and make sure it works with the submitted build. Do not include credentials or secrets in source code, public documentation, or unrelated metadata.

Use a compact structure such as this:

Feature: [name shown in the app]
Availability: [condition required to see it]
Review path: [steps from launch to the feature]
Expected result: [what the reviewer should see]
Notes: [relevant limitation or rollout status]

Example with placeholders:

Feature: [feature label]
Availability: Enabled for the review account
Review path: Sign in, open [screen], select [control]
Expected result: [describe the visible behavior]
Notes: This feature is not shown before sign-in.

Treat the example as a format, not a claim about Apple’s preferred wording. Replace every placeholder with accurate instructions for the build under review. If a feature depends on a remote response, verify that the review path is available when the reviewer tests it; do not assume that a temporary configuration will remain active without checking.

Separate asset risk from feature and access risk

A rejection or review question can arise from different parts of a submission. Keep the diagnosis specific: an inaccurate promotional claim is not the same problem as a feature the reviewer cannot find. This makes any correction more targeted and prevents a team from changing code when the issue is a stale asset—or changing creative when the actual problem is an undocumented access path.

Record each finding against the exact asset or feature. Keep the result, owner, and required fix together so that the final reviewer can confirm what changed. Avoid treating a single review outcome as a universal interpretation of the guidelines; Apple’s published text is the basis for this checklist, while individual decisions depend on the submitted app and its context.

Run a final build-to-submission check

Before submission, verify that the materials and review instructions correspond to the build actually being sent. A local inspection of Xcode build settings can help identify the bundle identifier and other settings used for the build; it does not validate App Store compliance or prove that a particular asset matches the binary.

For a project using Xcode, a developer can inspect selected build settings with a command such as:

xcodebuild -showBuildSettings | grep -E 'PRODUCT_BUNDLE_IDENTIFIER|PRODUCT_NAME'

Illustrative output:

PRODUCT_BUNDLE_IDENTIFIER = [your.bundle.identifier]
PRODUCT_NAME = [your app name]

Compare those values with the app record and the version information for the submission. Then verify that the screenshots, preview, creative, and review instructions refer to the same user-facing product and feature set. The command is only a local inspection aid; it does not replace checking the uploaded build or App Store Connect record.

A practical release record can contain:

• The asset or feature checked.
• The version or build being reviewed.
• The result and any mismatch found.
• The change made, if needed.
• The reviewer access path and whether it was tested.

This record is useful when a team makes a last-minute change to a feature flag, store image, or review account. If any of those change after the check, repeat the relevant part rather than assuming the earlier result still applies.

Choose the right environment for final verification

A developer can perform this review on an existing Mac if it has the required project and submission access. That approach may be less suitable when the only build machine is unavailable to teammates, the local environment is shared with unrelated work, or the team needs a separate macOS environment for producing and checking a submission build. A remote Mac can provide another place to build and inspect the candidate; it cannot make assets compliant, reveal an undocumented feature automatically, or guarantee an approval.

For a temporary or team-based macOS environment, compare the available remote Mac options with the requirements of the project before choosing one. If a hosted Mac is appropriate, review the available Mac mini environment and confirm that its access method and setup fit the build workflow. A local Mac remains the simpler choice when the team already has a suitable machine or needs direct access to physical devices and peripherals.

The deciding factor is not where the build runs; it is whether the submitted build, its store materials, and its reviewer instructions agree. Complete the creative-asset, feature-visibility, and review-note checks first. If the existing setup makes that verification difficult, a dedicated remote Mac can make the build environment easier to separate and access—but the approval decision remains Apple’s.