跪拜 Guibai
← Back to the summary

Publishing an iOS App from Windows: The 8-Step Order That Avoids Rejections and Empty Build Lists

iOS App Store Submission Process

When submitting an iOS app for the first time, the most common point of confusion is whether to create the certificate first or create the app first. Halfway through uploading the ipa, you might get a message that the provisioning profile type is wrong. And once you finally manage to upload it, you return to the submission page only to find the build list empty. This guide breaks the iOS App Store submission process into 8 steps in chronological order, explaining for each step what to do, where it commonly gets stuck, and how to confirm the step is done. The entire flow runs on Windows using Appuploader, without a Mac or Xcode. The only hard prerequisite is a paid Apple Developer Program membership — free accounts can do on-device debugging but cannot submit for review.

Login → Distribution Certificate → Bundle ID with Capabilities → App Store Provisioning Profile → Create App Record → Package and Upload ipa → Fill Version and Store Information → Select Build and Submit for Review.

The steps are detailed below.

Step 1: Login, Confirm Team and Membership Status

After logging into Appuploader, the first stop is the account overview. One Apple ID may be associated with multiple developer teams. In the "Teams" section, click "Activate" to select the team you need to work with — certificates, Bundle IDs, provisioning profiles, and apps will all reload based on the activated team. If you select the wrong team, everything after that will be wrong.

Pitfall: If you see a message about "not joined Apple Developer Program", it means this Apple ID does not have a paid membership, and developer portal features like certificates and provisioning profiles are unavailable. Either purchase the membership at developer.apple.com, or first generate an API key via the web login and use App Store Connect features separately.

Confirmation: In the account info, you can see the team name, team ID, and member role. If "Certificate & Provisioning Profile Access" is set to Allowed, this step is done.

Step 2: Create a Distribution Certificate (Apple Distribution)

For App Store submission, you use a distribution certificate, not a development certificate — keep these two separate. In the certificate section, fill in a certificate name and a p12 password, create an Apple Distribution certificate, and download the .p12 file for later signing. This p12 can be reused on a different computer or shared with colleagues, unlike on a Mac where you have to deal with Keychain export.

Pitfall: A build signed with a development certificate (Apple Development) will be rejected outright when you submit it for review. Also, remember the p12 password; you'll need it when re-importing for signing.

Confirmation: In the certificate list, you see an Apple Distribution entry that is valid and has an expiration date. To verify details, you can drag the downloaded p12 into Appuploader's file info view to check the Team ID, SHA1 fingerprint, and whether the private key matches the certificate. The SHA1 fingerprint required for APP filing (ICP) can also be copied directly from here.

Distribution Certificate

Step 3: Register a Bundle ID and Configure Capabilities as Needed

The Bundle ID must match the one in your project. In the Bundle ID section, create one, then check the capabilities your app actually uses: Push Notifications, Sign in with Apple, iCloud, App Groups, etc.

Pitfall: A common trap many people hit — changing capabilities after the fact invalidates previously generated provisioning profiles; you must regenerate them, otherwise the signing won't match. So configure capabilities before generating the profile and think it through.

Confirmation: You can see the Bundle ID in the list, and its capability status matches your needs.

Step 4: Generate an App Store Type Provisioning Profile

A provisioning profile binds the certificate, Bundle ID, and devices together. For submission, you must select App Store type (not Development, not Ad Hoc). In the provisioning profile section, select the Bundle ID and the distribution certificate from Step 2, then generate and download the .mobileprovision file.

Pitfall: Selecting the wrong type is a frequent cause of submission rejection. Among the four types, Development is for daily on-device debugging, Ad Hoc is for internal testing on specific devices, App Store is for submission, and the enterprise certificate is for internal distribution. Don't use the debugging type for submission.

Confirmation: Drag the generated mobileprovision into file info to verify that the Bundle ID, embedded certificate, and validity period all match. After changing a certificate or adding new test devices, use "One-Click Rebuild" to automatically include the current valid certificate and all enabled devices, so you don't have to reconfigure manually.

Step 5: Create the App Record in App Store Connect

Once the signing material is ready, create the app. In the App section, create a new app and fill in app-level, version-independent information: primary language, primary and secondary categories, age rating (check the frequency of each content descriptor; it generates after saving).

Pitfall: Categories, age ratings, and in-app purchases must be managed with an API key account; other login methods are not supported. If you log in with Apple ID + app-specific password and find these items uneditable, go to the account overview and generate an App Store Connect API key (the private .p8 is shown only once, so save it immediately) and return.

Confirmation: The app appears in the app list, searchable by name / Bundle ID / SKU, and the detail page has a "Open in App Store Connect" option.

Step 6: Package and Upload the ipa

Upload the ipa to App Store Connect. Click upload in the interface; to integrate with CI, use the command line in your packaging script:

# Last step of the packaging script, --wait waits for Apple to finish processing before continuing
appuploader-cli build upload ./build/App.ipa --wait

Pitfall: Uploading is not the same as being ready to submit. After the ipa is uploaded, Apple needs processing time in the background; only after that will it appear in the selectable build list. Many people see an empty build list on the submission page because either it hasn't finished processing or the upload never completed. If the build number already exists, the tool will warn you directly and won't upload a duplicate.

Confirmation: When the build appears in the TestFlight page of App Store Connect with a normal status, processing is complete.

Step 7: Fill Version Information, Store Copy, and Screenshots

This step has the most content, split into three parts:

Pitfall: Name and subtitle changes only take effect with the next version's review; promotional text can be changed anytime without review; What's New is required only during version updates. Mixing these up leads to thinking "it changed but didn't take effect."

Confirmation: Required field indicators are all satisfied, and screenshots display correctly under the corresponding device sizes.

Step 8: Select the Build and Submit for Review

Back on the version page, click "Choose the build to submit," pick the build from Step 6 that has finished processing, then click "Submit for Review."

Pitfall: If you can't select a build, 99% of the time Step 6 hasn't finished processing. Go back and wait a bit, then refresh. After submission, the status changes to Waiting for Review; if you submit the wrong build, you can "Cancel" this submission to withdraw it.

Confirmation: Status shows "Waiting for Review" — the submission flow is complete, and the rest is up to Apple's review.

Tired of Clicking Through Step by Step? One Command Ties It Together

The 8 steps above are GUI operations, suitable for clarifying the whole picture on first submission. Once you're familiar, or to integrate CI, you can use Appuploader's built-in appuploader-cli: write an appuploader.yaml in your project, and a single release will run through certificates, provisioning profiles, app creation, upload, store information, screenshots, and submission in sequence. If it fails midway, you can resume from the breakpoint. It works on GitHub Actions, Jenkins, and GitLab CI Linux runners.

Compared with the pure web-plus-Mac path: you can use only the App Store Connect web page to fill in information and submit, but certificates and provisioning profiles must be obtained separately from the developer portal, and the ipa still needs to be uploaded via Xcode or Transporter on a Mac. Appuploader consolidates certificates, provisioning profiles, app information, copy and screenshots, upload, and submission in one place, letting you complete the entire chain on Windows and Linux — for teams without a Mac, it saves the back-and-forth between multiple tools and web pages.

Comments

Top 1 from juejin.cn, machine-translated. The original thread is authoritative.

宇本尊

The process is broken down very clearly, especially the step of waiting for the build to finish processing after upload, which is easy to miss. One addition: for apps that require login, it's best to preload demo accounts with test data that can be experienced directly, and ensure they don't expire or trigger risk control during review; writing the entry path in the review notes can reduce back-and-forth caused by the inability to reproduce features.