intent

use this skill to answer "is my app ready to submit now?" and to drive a complete app store release using the current asc command surface. covers readiness checks, metadata staging, build attachment, review submission, and monitoring. handles first-time submission blockers (availability, subscriptions, iaps, game center, app privacy) with explicit public-api and web-session paths. run this before every submission to catch blocking issues early and separate what the cli can fix from what requires manual intervention or web sessions.

inputs

required app context:

APP_ID: app store connect app identifier (numeric or bundle ID format asc accepts)
VERSION: semantic version string (e.g. "1.2.3")
BUILD_ID: build identifier once uploaded to app store connect
VERSION_ID: resolved app store version ID (alternative to VERSION when already known)

required auth:

asc auth configured via asc auth login or environment variables: ASC_USERNAME, ASC_PASSWORD, ASC_PRIVATE_KEY_ID, ASC_PRIVATE_KEY, ASC_ISSUER_ID (for api key auth)
api key must have app-manager or admin role

optional inputs:

METADATA_DIR: path to canonical metadata directory (e.g. ./metadata/version/1.2.3) containing version-scoped metadata files when using metadata-driven staging
IPA_PATH: local path to .ipa file for one-command publish flows (e.g. ./App.ipa)
SUBMISSION_ID: explicit review submission ID when modifying an existing submission
SUBSCRIPTION_ID, GROUP_ID: product IDs for subscription/group version workflows
IAP_ID: in-app purchase product ID
GC_LEADERBOARD_VERSION_ID, GC_GROUP_VERSION_ID: game center component IDs

external connections:

app store connect api (always required; no fallback)
asc web-session commands (optional; used only for gaps not covered by public api: first-review subscription attachment, app privacy publish, first-time iap selection on version page)

edge cases to handle:

auth expiry mid-workflow (retry with fresh login)
api rate limits (asc throttles; back off and retry)
empty result sets (zero versions ready for submission; branch logic must stop and ask user)
ambiguous locale resolution (multiple en-US localizations found; require explicit choice)
build processing delay (use --wait flag with asc publish appstore)
network timeout during staging (re-run with --dry-run to verify plan before retry)

procedure

step 1: resolve app and version context

input: APP_ID (or app name), VERSION string, optional existing VERSION_ID or BUILD_ID

output: confirmed APP_ID, VERSION, VERSION_ID (if needed), BUILD_ID (if available)

resolve the app id and version string from user input. if user provides VERSION string only, asc will resolve VERSION_ID automatically. if user has BUILD_ID already uploaded, note it; if not, you will upload or find it in step 2. confirm all three identifiers before proceeding (do not assume).

step 2: run readiness check

input: APP_ID, VERSION, optional --strict flag

output: validation report (pass, warning, or blocking issue) in table or json format

run the core readiness check:

asc validate --app "APP_ID" --version "VERSION" --platform IOS --output table

if warnings should block automation, add --strict:

asc validate --app "APP_ID" --version "VERSION" --platform IOS --strict --output table

decision: if validation passes with no blockers, move to step 3. if blockers exist, jump to the "blocking issues resolution" section below and resolve by type before retrying validate.

for apps selling digital goods, also run:

asc validate iap --app "APP_ID" --output table
asc validate subscriptions --app "APP_ID" --output table

step 3: stage without submitting (prepare phase)

input: APP_ID, VERSION, BUILD_ID (or will be resolved), optional METADATA_DIR or copy-from version

output: staging plan (with --dry-run) or staged version state (after --confirm)

prepare the version, apply metadata, and attach build without submitting to review:

asc release stage \
  --app "APP_ID" \
  --version "VERSION" \
  --build "BUILD_ID" \
  --metadata-dir "./metadata/version/VERSION" \
  --dry-run \
  --output table

inspect the plan. if it looks wrong, stop and fix metadata or build before proceeding.

once plan is correct, apply mutations:

asc release stage \
  --app "APP_ID" \
  --version "VERSION" \
  --build "BUILD_ID" \
  --metadata-dir "./metadata/version/VERSION" \
  --confirm

alternative: if copying metadata from a prior version, use:

asc release stage \
  --app "APP_ID" \
  --version "VERSION" \
  --build "BUILD_ID" \
  --copy-metadata-from "PRIOR_VERSION" \
  --confirm

output: stage command returns the prepared version state. verify the version is now in PREPARE_FOR_SUBMISSION or READY_FOR_SUBMISSION state.

step 4: handle first-time submission blockers (if applicable)

input: APP_ID, VERSION_ID, app context (first submission, has subscriptions, has iaps, has game center)

output: resolved blocker state; blockers removed or deferred with documented reason

only execute this step if the app is a first submission or if the previous step revealed missing prerequisites.

4a: bootstrap app availability (first submission only)

check if availability exists:

asc pricing availability view --app "APP_ID"

if empty, create first availability record:

asc pricing availability create \
  --app "APP_ID" \
  --territory "USA,GBR" \
  --available true \
  --available-in-new-territories true

4b: prepare and attach subscriptions (first review only)

validate subscriptions are ready:

asc validate subscriptions --app "APP_ID" --output table

fix any missing metadata (broad pricing coverage, review screenshots, promotional images) before attaching.

list current subscription state on first review:

asc web review subscriptions list --app "APP_ID"

if not attached, choose attachment path:

path a: attach a subscription group

asc web review subscriptions attach-group \
  --app "APP_ID" \
  --group-id "GROUP_ID" \
  --confirm

path b: attach a single subscription

asc web review subscriptions attach \
  --app "APP_ID" \
  --subscription-id "SUB_ID" \
  --confirm

note: the deprecated asc subscriptions review submit shortcut must not be used for new workflows.

for a subsequent review (existing submission), follow the explicit api 4.4.1 versioned workflow in decision points section 4b-explicit below.

4c: prepare and submit in-app purchases (first submission or new iap)

validate iap readiness:

asc validate iap --app "APP_ID" --output table

upload missing review screenshots:

asc iap review-screenshots create --iap-id "IAP_ID" --file "./review.png"

for an api 4.4.1 iap version on a new or existing submission, list versions ready for submission:

asc iap versions list --iap-id "IAP_ID" --state PREPARE_FOR_SUBMISSION --paginate --output json

branch on count:

zero: create one version, capture .data.id as IAP_VERSION_ID, continue to locale/image setup below
one: reuse .data[0].id as IAP_VERSION_ID, continue to locale/image setup
more than one: stop, require user to choose explicit version ID

if zero, create:

asc iap versions create --iap-id "IAP_ID" --output json

resolve localization before writing:

asc iap versions localizations list --version-id "IAP_VERSION_ID" --paginate --output json

if en-US absent, create:

asc iap versions localizations create \
  --version-id "IAP_VERSION_ID" \
  --locale "en-US" \
  --name "Premium" \
  --description "Unlock premium features"

if en-US exists and differs, update it:

asc iap versions localizations update \
  --localization-id "IAP_LOC_ID" \
  --name "Premium" \
  --description "Unlock premium features"

if en-US exists and matches, do nothing.

resolve images:

asc iap versions images list --version-id "IAP_VERSION_ID" --paginate --output json

if intended image present, do nothing. if absent, create:

asc iap versions images create --version-id "IAP_VERSION_ID" --file "./review.png"

if different image must be replaced, delete old, then create new (separate confirmed branch):

asc iap versions images delete --image-id "IAP_IMAGE_ID" --confirm
asc iap versions images create --version-id "IAP_VERSION_ID" --file "./review.png"

inspect resolved version before adding to submission:

asc iap versions view --version-id "IAP_VERSION_ID" --output table
asc iap versions localizations list --version-id "IAP_VERSION_ID" --paginate --output table
asc iap versions images list --version-id "IAP_VERSION_ID" --paginate --output table

for first iap on app or first iap type, apple may require manual selection on app-version "in-app purchases and subscriptions" page. prepare iap fully (localization, pricing, review screenshot) first. if public api rejects the review item path for non-renewing iaps, use web-session fallback:

asc web review iaps attach --app "APP_ID" --iap-id "IAP_ID" --confirm

call out that this requires authenticated web session and is a first-version-selection gap only.

4d: prepare game center (if app uses game center)

create app version game center record:

asc game-center app-versions create --app-store-version-id "VERSION_ID"

if game center leaderboards, achievements, or other component versions must ship, use explicit review submission api (see step 5 decision points) so all items can be added together before submission.

4e: publish app privacy (if not yet published)

check and publish app privacy state:

asc web privacy pull --app "APP_ID" --out "./privacy.json"
asc web privacy plan --app "APP_ID" --file "./privacy.json"
asc web privacy apply --app "APP_ID" --file "./privacy.json"
asc web privacy publish --app "APP_ID" --confirm

if user avoids web-session commands, require manual confirmation in app store connect web ui: https://appstoreconnect.apple.com/apps/APP_ID/appPrivacy

step 5: submit to review

input: APP_ID, VERSION, BUILD_ID (or VERSION_ID), optional SUBMISSION_ID for existing submission

output: submission confirmation and submission ID

choose submission path based on app complexity:

path a: simple submission (most apps)

use asc review submit for explicit submission of already-prepared version:

asc review submit --app "APP_ID" --version "VERSION" --build "BUILD_ID" --dry-run --output table

inspect the plan. once correct:

asc review submit --app "APP_ID" --version "VERSION" --build "BUILD_ID" --confirm

alternative: if you have VERSION_ID already:

asc review submit --app "APP_ID" --version-id "VERSION_ID" --build "BUILD_ID" --confirm

path b: one-command upload and submit (when build not yet uploaded)

use asc publish appstore for upload plus submission in one flow:

asc publish appstore --app "APP_ID" --ipa "./App.ipa" --version "VERSION" --submit --dry-run --output table

if build processing will delay, add --wait:

asc publish appstore --app "APP_ID" --ipa "./App.ipa" --version "VERSION" --submit --wait --confirm

path c: complex submission with multiple item types (subscriptions, iaps, game center)

create explicit submission and add all items before submitting:

asc review submissions-create --app "APP_ID" --platform IOS

capture returned SUBMISSION_ID. add app version:

asc review items add --submission "SUBMISSION_ID" --item-type appStoreVersions --item-id "VERSION_ID"

add resolved iap, subscription, and game center versions:

asc review items add --submission "SUBMISSION_ID" --item-type inAppPurchaseVersions --item-id "IAP_VERSION_ID"
asc review items add --submission "SUBMISSION_ID" --item-type subscriptionVersions --item-id "SUBSCRIPTION_VERSION_ID"
asc review items add --submission "SUBMISSION_ID" --item-type subscriptionGroupVersions --item-id "GROUP_VERSION_ID"
asc review items add --submission "SUBMISSION_ID" --item-type gameCenterLeaderboardVersions --item-id "GC_LEADERBOARD_VERSION_ID"

(also supports gameCenterAchievementVersions, gameCenterActivityVersions, gameCenterChallengeVersions, gameCenterLeaderboardSetVersions)

inspect before submitting:

asc review submissions view --id "SUBMISSION_ID" --output table

submit:

asc review submissions-submit --id "SUBMISSION_ID" --confirm

step 6: monitor submission status

input: APP_ID, VERSION_ID, or SUBMISSION_ID

output: current submission state (in review, approved, rejected, etc.)

check app-level status:

asc status --app "APP_ID"

check version-level submission status:

asc submit status --version-id "VERSION_ID"

or check explicit submission status:

asc submit status --id "SUBMISSION_ID"

if submission must be canceled before review completes:

asc submit cancel --id "SUBMISSION_ID" --confirm

repeat status checks periodically until review resolves.

step 7: handle review details (if missing)

input: VERSION_ID

output: review details record created or updated

check current review details:

asc review details-for-version --version-id "VERSION_ID"

if missing or incomplete, create:

asc review details-create \
  --version-id "VERSION_ID" \
  --contact-first-name "Dev" \
  --contact-last-name "Support" \
  --contact-email "dev@example.com" \
  --contact-phone "+1 555 0100" \
  --notes "Explain the reviewer access path here."

or update existing (only set demo-account fields if apple review truly needs credentials):

asc review details-update \
  --id "DETAIL_ID" \
  --notes "Updated reviewer instructions."

decision points

readiness-gate (step 2):

if asc validate returns no blockers, proceed to step 3 (stage).

if blockers exist, identify type (api-fixable, web-session-fixable, or manual fallback) and resolve before retrying validate:

api-fixable blockers: build validity, metadata completeness, screenshots, review details, content rights, encryption declaration, version/build attachment, iap readiness, game center version readiness. fix via metadata updates, asc commands, or build revalidation. retry asc validate after each fix.
web-session-fixable blockers: first-review subscription attachment, app privacy publish state. use asc web ... commands. after running web commands, retry asc validate.
manual fallback: first-time iap selection on app-version "in-app purchases and subscriptions" page when no cli attach flow exists, or any flow user does not want to run through web-session. call out that it must be done manually in app store connect web ui and resume workflow after manual step completes.

staging-confirmation (step 3):

if asc release stage --dry-run plan is correct, run asc release stage --confirm to apply mutations.

if plan is wrong, stop. identify the issue (bad metadata, wrong build, version mismatch). fix in source, then re-run stage with --dry-run again before confirming.

first-submission blocker-check (step 4 entry):

if app is first submission or first-time digital goods addition, execute step 4 sub-steps in order (availability, subscriptions, iaps, game center, app privacy).

if app is a subsequent version with no new digital goods and game center already configured, skip step 4 and go straight to step 5.

subscription-versioning (step 4b, explicit api 4.4.1 flow for existing submission):

when adding a subscription version to an existing submission, first list versions ready for submission:

asc subscriptions versions list --subscription-id "SUB_ID" --state PREPARE_FOR_SUBMISSION --paginate --output json

branch on result count before any write:

zero versions: create one, capture .data.id as SUBSCRIPTION_VERSION_ID, proceed to locale and image setup
one version: reuse .data[0].id as SUBSCRIPTION_VERSION_ID, proceed to locale and image setup
more than one: stop, require user to explicitly choose version ID

if zero, run:

asc subscriptions versions create --subscription-id "SUB_ID" --output json

resolve locale (must handle exactly one