Skip to main content
App review, readiness checks, and rejections Level: Developer 11 min read

Canceling an App Store Review Submission in Flight or Draft

A comprehensive guide to safely canceling or withdrawing an App Store Review submission in flight or draft, understanding state transitions, preserving metadata, and re-submitting.

Published: 2026-11-03 • Last Updated: 2026-11-03 • Author: Kip Lawrence
Key MCP Tools: review_submissions_listreview_submission_getreview_submission_items_inspectreview_submission_cancelrelease_readiness_check

Overview: Understanding Submission Withdrawal

Every developer eventually encounters a critical moment right after clicking Submit for Review: a sudden bug report arrives from QA, a third-party API provider pushes a breaking change, or a severe edge-case crash is discovered on a physical device.

The immediate reaction is often panic: Can I stop Apple from reviewing this build? Will canceling delete my version number or erase all the metadata I spent hours drafting? What happens to my binary?

In Apple's App Store Connect architecture, submitting an app for review is managed through a container entity called a Review Submission (reviewSubmissions). Understanding how to withdraw or cancel this submission is a vital operational safeguard.

However, canceling an App Review submission is not a simple "undo" action:

  • It physically pulls your submission out of Apple's global intake queue.
  • It forfeits your position in line.
  • It transitions the associated AppStoreVersion back to an editable or developer-rejected draft state.
  • Your metadata, screenshots, and uploaded binary remain intact. You do not need to re-type descriptions or re-upload your IPA unless you need to replace the binary with a bug-fixed build.
TEXT
┌────────────────────────────────────────────────────────────────────────┐
│                   REVIEW SUBMISSION CANCELLATION LIFECYCLE             │
│                                                                        │
│   DRAFT (READY_FOR_REVIEW)        WAITING FOR REVIEW                   │
│   [Staged submission container]   [Queued on Apple's review cluster]   │
│                 │                               │                      │
│                 │                               │                      │
│                 └───────────────┬───────────────┘                      │
│                                 ▼                                      │
│                  review_submission_cancel (FlightDeck)                 │
│               [PATCH /v1/reviewSubmissions/{id} (canceled=true)]       │
│                                 │                                      │
│                                 ▼                                      │
│                  CANCELING ──► COMPLETE                                │
│                                 │                                      │
│                                 ▼                                      │
│                  VERSION RESTORED TO EDITABLE DRAFT                    │
│   • Binary stays in build library (intact)                             │
│   • Metadata & screenshots preserved                                   │
│   • Ready for new build selection or re-submission                     │
└────────────────────────────────────────────────────────────────────────┘

[!CAUTION] Cancellation Invariant: In Apple's API and FlightDeck MCP, cancellation is supported when the submission is in READY_FOR_REVIEW (draft) or WAITING_FOR_REVIEW (queued). Once an Apple reviewer actively opens the build (IN_REVIEW), API cancellation fails closed. Pulling a build actively under review requires removing the version from review via the web portal or developer-rejecting the version.


The Primary Withdrawal Prompt

Use this prompt with your AI coding assistant (Cursor, Claude Code, Windsurf, or Roo Code) to safely inspect your submission state, verify cancellation eligibility, and request human confirmation before triggering the cancellation mutation:

TEXT
Inspect the active App Review submission for [Your App Name]. Identify the submission container and its exact review state. If the submission is in WAITING_FOR_REVIEW or READY_FOR_REVIEW, explain the consequences of canceling it, show me what items are attached, and ask for my explicit approval before staging the cancellation in FlightDeck.

The App Store Connect Submission State Machine

Apple tracks the review submission lifecycle through discrete states. Understanding where your release stands determines the correct operational path:

Review Submission State Apple Raw State Can Be Canceled via API? Consequence of Cancellation
Ready for Review READY_FOR_REVIEW YES Discards the draft submission container; attached items return to unsubmitted draft pool.
Waiting for Review WAITING_FOR_REVIEW YES Pulls the build from Apple's queue; version transitions to editable draft. Forfeits queue position.
In Review IN_REVIEW NO (API fails closed) An Apple reviewer is actively testing the app. Must remove from review via App Store Connect web portal.
Unresolved Issues UNRESOLVED_ISSUES NO Review is already paused due to rejections. Respond in Resolution Center rather than canceling.
Canceling CANCELING In Progress Apple servers are processing the state rollback.
Complete COMPLETE NO Lifecycle finished. Cannot cancel an already closed submission.

Step-by-Step Safe Withdrawal Workflow

To prevent accidental disruptions to release schedules, adhere to this 5-step safety workflow:

TEXT
┌────────────────────────────────────────────────────────────────────────┐
│                   SAFE SUBMISSION WITHDRAWAL WORKFLOW                  │
│                                                                        │
│   1. INSPECT SUBMISSION       Verify submission ID, state, and items   │
│            │                                                           │
│            ▼                                                           │
│   2. EVALUATE CONSEQUENCES    Confirm build, metadata, and queue impact│
│            │                                                           │
│            ▼                                                           │
│   3. STAGE CANCELLATION       Stage review_submission_cancel in MCP    │
│            │                                                           │
│            ▼                                                           │
│   4. DESKTOP APPROVAL         Physically confirm in FlightDeck Desktop │
│            │                                                           │
│            ▼                                                           │
│   5. POST-MUTATION READBACK   Verify state is CANCELING / COMPLETE     │
└────────────────────────────────────────────────────────────────────────┘

Step 1: Inspect the Active Submission

Before modifying any live state, query Apple's API to confirm the exact submission container and attached items:

  • Call review_submissions_list to find the active container for your appId.
  • Call review_submission_items_inspect to identify what is attached (e.g., App Store Version, App Clip, In-App Purchase, or Phased Release configuration).

Step 2: Evaluate the Consequences

Before confirming cancellation, review these fundamental rules:

  • Queue Position: You forfeit your place in Apple's review queue. When you resubmit, your app goes to the back of the intake line.
  • Binary Status: Your uploaded IPA binary (.ipa) is NOT deleted or invalidated. It remains permanently stored in your App Store Connect build library and can be reattached later.
  • Metadata Preservation: All localized marketing copy (descriptions, keywords, support URLs, promotional text) and screenshots remain completely preserved in your version draft.
  • Version Number Reusability: The version number (e.g., 1.2.0) is retained. You do not need to bump your marketing version string.

Step 3: Stage the Cancellation Mutation

FlightDeck MCP implements review_submission_cancel targeting Apple's canonical operation:

  • Endpoint: PATCH /v1/reviewSubmissions/{id}
  • Operation ID: reviewSubmissions_updateInstance
  • Payload: {"data": {"type": "reviewSubmissions", "id": "[SUBMISSION_ID]", "attributes": {"canceled": true}}}

Under FlightDeck's security governance, review_submission_cancel is classified as an operational mutation (isMutation: true). When AI Approval is ON (the shipping default), calling the tool creates a staged proposal in FlightDeck's native macOS Approval Center.

Step 4: Confirm in FlightDeck Desktop

Open FlightDeck Desktop on your Mac. Navigate to the Approval Center, inspect the SHA-256 bound payload showing the target submission ID and canceled: true, and click Approve.

Step 5: Post-Mutation Readback Verification

Always execute a readback query immediately following execution:

  • Call review_submission_get(submissionId: "[SUBMISSION_ID]").
  • Confirm the state attribute reports CANCELING or COMPLETE.
  • Call app_store_versions_list to verify your version draft has returned to an editable state.

What to Do After Withdrawing a Submission

Once your submission has been canceled and your version draft is editable, choose your path forward:

Scenario A: Replacing the Binary (Fixing a Critical Bug)

If you canceled because of a code defect:

  1. Fix the bug in your local workspace.
  2. Increment your build number in Xcode (CFBundleVersion), e.g., from 14 to 15. Maintain your existing marketing version (CFBundleShortVersionString e.g. 1.2.0).
  3. Compile and upload the new binary to App Store Connect.
  4. Once build processing is COMPLETE, select the new build on your version draft.
  5. Create a new ReviewSubmission container, attach the version, and submit.

Scenario B: Updating Metadata or Review Notes

If you canceled because of an error in your description, missing review demo credentials, or an incorrect support URL:

  1. Update the localized copy using app_store_version_localization_update or update review credentials via flightdeck_operation_stage (or in the App Store Connect web portal).
  2. Run release_readiness_check to verify that all required fields are populated.
  3. Create a fresh review submission container (review_submission_create_draft).
  4. Re-attach your version (review_submission_add_app_version).
  5. Submit the new container to Apple (review_submission_submit).

What FlightDeck Can and Cannot Do

Understand the exact boundaries of FlightDeck MCP tooling for submission lifecycle management:

Operation / Capability Tool / Method Supported in FlightDeck?
Inspect Active Submissions review_submissions_list, review_submission_get YES (Direct API)
Inspect Attached Submission Items review_submission_items_inspect YES (Direct API)
Cancel Waiting/Draft Submission review_submission_cancel YES (Staged Mutation)
Cancel an IN_REVIEW Submission None (Apple API Rejection) NO (Web Portal Only)
Create New Draft Submission review_submission_create_draft YES (Staged Mutation)
Attach Version to New Draft review_submission_add_app_version YES (Staged Mutation)
Submit New Review Container review_submission_submit YES (Staged Mutation)
Preserve Queue Position After Cancel None (Apple Server Policy) NO (Impossible)

Practical AI Workflows & Prompts

Scenario 1: Diagnostic Submission Inspection Before Withdrawal

Inspect the active review container and verify what would be canceled:

TEXT
Inspect the active review submission for [Your App Name]. Retrieve our latest submission container and inspect attached items. Tell me its current state, whether it can be canceled via API, and what items are attached.

Scenario 2: Two-Phase Safe Cancellation

Safely stage and execute a submission cancellation:

TEXT
Prepare to cancel the active review submission for [Your App Name]. Before executing, verify that the state is WAITING_FOR_REVIEW, explain the consequences for my binary and metadata, and stage the cancellation proposal for my review in the FlightDeck Approval Center.

Scenario 3: Creating a Replacement Submission Pipeline

After uploading an updated build, rebuild and submit a fresh review container:

TEXT
Our new build [Your Build Number] has completed processing for [Your App Name]. Guide me through:
1. Selecting build [Your Build Number] on version draft [Your App Version].
2. Checking release readiness to verify zero blockers.
3. Creating a new draft review submission container.
4. Attaching the version and staging the submission for my approval in FlightDeck.

Verification & Recovery Checklist

  • [ ] Confirm Active State: Ensure the submission state is WAITING_FOR_REVIEW or READY_FOR_REVIEW before calling review_submission_cancel.
  • [ ] Verify In-Review Blockers: If the app is already IN_REVIEW, navigate to appstoreconnect.apple.com > App Store > Versions > Remove from Review manually.
  • [ ] Verify Metadata Persistence: Call app_store_version_localizations_list after cancellation to confirm all descriptions, keywords, and screenshots are intact.
  • [ ] Confirm Binary Availability: Verify via builds_list that your existing build remains in your account.
  • [ ] Resubmission Readiness: Always run release_readiness_check on the editable version draft before creating a new submission container.

Official Apple Documentation


Next Steps

If you withdrew your submission to resolve a software crash, increment your CFBundleVersion and compile a replacement binary using Compiling and Exporting a Signed IPA via xcodebuild CLI. Once uploaded, verify submission health with Pre-Flight App Store Submission Readiness Check.

Connect Your AI Agent to App Store Connect

FlightDeck runs locally on your Mac, keeping private keys secure in your macOS Keychain and executing mutations only after your explicit approval.

Download FlightDeck on Mac App Store