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
AppStoreVersionback 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.
┌────────────────────────────────────────────────────────────────────────┐
│ 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) orWAITING_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:
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:
┌────────────────────────────────────────────────────────────────────────┐
│ 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_listto find the active container for yourappId. - Call
review_submission_items_inspectto 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
stateattribute reportsCANCELINGorCOMPLETE. - Call
app_store_versions_listto 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:
- Fix the bug in your local workspace.
- Increment your build number in Xcode (
CFBundleVersion), e.g., from14to15. Maintain your existing marketing version (CFBundleShortVersionStringe.g.1.2.0). - Compile and upload the new binary to App Store Connect.
- Once build processing is
COMPLETE, select the new build on your version draft. - Create a new
ReviewSubmissioncontainer, 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:
- Update the localized copy using
app_store_version_localization_updateor update review credentials viaflightdeck_operation_stage(or in the App Store Connect web portal). - Run
release_readiness_checkto verify that all required fields are populated. - Create a fresh review submission container (
review_submission_create_draft). - Re-attach your version (
review_submission_add_app_version). - 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:
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:
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:
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_REVIEWorREADY_FOR_REVIEWbefore callingreview_submission_cancel. - [ ] Verify In-Review Blockers: If the app is already
IN_REVIEW, navigate toappstoreconnect.apple.com > App Store > Versions > Remove from Reviewmanually. - [ ] Verify Metadata Persistence: Call
app_store_version_localizations_listafter cancellation to confirm all descriptions, keywords, and screenshots are intact. - [ ] Confirm Binary Availability: Verify via
builds_listthat your existing build remains in your account. - [ ] Resubmission Readiness: Always run
release_readiness_checkon the editable version draft before creating a new submission container.
Related Guides & Official References
Related FlightDeck Developer Guides
- Creating and Submitting an App Review Draft via MCP — The complete submission lifecycle.
- App Store Review Times in 2026: What to Expect and How to Expedite — Review queue stages and benchmarks.
- Execution vs Staging Rules: What AI Operations Require Human Approval — What AI operations require approval.
- Pre-Flight App Store Submission Readiness Check — Preventing submission errors.
Official Apple Documentation
- App Store Connect API: Review Submissions — Authoritative Apple REST API specification.
- App Store Connect API: Update a Review Submission — Cancellation endpoint documentation.
- App Store Connect Help: View App Status and Remove from Review — Official web portal workflows.
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.