Building the app is only half the work. Getting it through Apple’s App Review and Google Play’s review is a separate project with its own rules, forms and deadlines, and those rules change every year. This post is the checklist I use to publish a Flutter app on both stores, updated for the requirements in force in late 2026.
Every requirement below links to the official page it comes from. Store rules change often, so check the linked page before you rely on a date.
Before you start: accounts and identifiers
You need two paid accounts before you can publish anything:
- An Apple Developer Program membership, to create App IDs, sign the iOS build and use App Store Connect.
- A Google Play Console developer account.
Decide early whether the app is published under the client’s own accounts or yours. I recommend the client’s accounts. The listing, reviews and revenue then belong to the business, and changing developers later does not mean transferring the app.
Then pick identifiers that you will never change:
- iOS Bundle ID (for example
com.company.app), registered as an Explicit App ID in the Apple Developer portal - Android application ID, normally the same string
- App name, short description and support email
The Google Play closed-testing rule
If the Play account is a personal account created after November 13, 2023, you cannot go straight to production. Google requires a closed test with at least 12 testers who stay opted in continuously for 14 days. Only then can you click “Apply for production” on the Play Console dashboard. Google says that review of the production access application usually takes seven days or less.
Plan for this. In practice it adds three weeks or more to the first Android launch: 14 days of testing, a production access review, then the normal app review. Start the closed test as soon as you have a stable build, not the week before launch. The application form asks how engaged your testers were and what you changed based on their feedback, so recruit people who will actually use the app.
Versioning in pubspec.yaml
Flutter keeps both platforms’ version numbers in one line of pubspec.yaml:
version: 1.4.0+12
1.4.0is the version users see. It becomesversionNameon Android andCFBundleShortVersionStringon iOS.12is the build number. It becomesversionCodeon Android andCFBundleVersionon iOS.
Both stores reject an upload that reuses a build number, so increase the number after + on every upload, including test builds. You can also override both at build time with --build-name and --build-number, as described in the Flutter Android release docs and iOS release docs.
Android release checklist
1. Target the right API level
From August 31, 2026, new apps and app updates must target Android 16 (API level 36) or higher to be submitted to Google Play. Wear OS, Automotive, TV and XR apps have lower minimums. Existing apps that target API 34 or lower stop being available to new users on newer Android versions. Google offered an extension to November 1, 2026 for developers who requested it.
In a Flutter project, android/app/build.gradle.kts normally reads targetSdk = flutter.targetSdkVersion. Check what that resolves to with your Flutter version. If it is below 36, upgrade Flutter or set the value yourself, then test, because each Android version brings behavior changes for apps that target it.
2. Create an upload key and sign the build
Google Play signs the APKs that users download with an app signing key that Google holds (Play App Signing). You sign your uploads with a separate upload key that you keep. If you lose the upload key, Google can reset it. If you manage the app signing key yourself and lose it, it cannot be reset. That is a good reason to let Google hold it.
Create the upload keystore (macOS/Linux, from the Flutter docs):
keytool -genkey -v -keystore ~/upload-keystore.jks -keyalg RSA \
-storetype JKS -keysize 2048 -validity 10000 -alias upload
Then create android/key.properties with the store password, key password, alias and keystore path, and reference it from a release signing config in android/app/build.gradle.kts. The Flutter docs show the exact Gradle code.
- Keystore and
key.propertiesare not committed to git - Keystore and passwords are backed up somewhere the client can access
- The release build type uses the release signing config, not debug
3. Build an app bundle, not an APK
New apps must be published as an Android App Bundle (.aab) since August 2021. Play generates optimized APKs for each device from it.
flutter build appbundle
# output: build/app/outputs/bundle/release/app.aab
With obfuscation (recommended, see below):
flutter build appbundle --obfuscate --split-debug-info=build/symbols/android
4. Fill in the Play Console forms
Most first-release delays on Android come from forms, not code. Before you can send the app for review, complete:
- Privacy policy URL. Every app needs one, even an app that collects no data. A privacy policy is required to complete the Data safety form.
- Data safety form. Required for every app on closed, open or production tracks. Apps that collect no data still have to complete it and say so. Include data collected by SDKs such as Firebase, analytics and crash reporting.
- Account deletion. If users can create an account in your app, you must offer a way to delete the account and its data inside the app, and also a web link where users can request deletion without reinstalling. The web link goes into the Data safety form. Deactivating or “freezing” an account does not count.
- App access instructions and test credentials if the app needs a login
- Content rating questionnaire, target audience, ads declaration
- Store listing: icon, feature graphic, screenshots, descriptions
If you don’t have a privacy policy yet, my free app privacy policy generator gives you a starting draft that covers the usual Flutter SDKs. Have it reviewed if your app handles sensitive data.
iOS release checklist
1. Use the current Xcode and SDK
Since April 28, 2026, apps uploaded to App Store Connect must be built with Xcode 26 or later using the iOS 26 SDK. Since September 9, 2026, iOS apps must also target iOS 13 or later. Flutter supports iOS 13 and later, so the deployment target is rarely a problem, but an old Mac that cannot run Xcode 26 is. Check this before release day.
You also need a Mac to build and upload the iOS app, or a cloud CI service that provides one.
2. Register the app and check Xcode settings
Following the Flutter iOS release docs:
- Register the Bundle ID in the Apple Developer portal
- Create the app record in App Store Connect (Apps, then +, then New App) and select that Bundle ID
- In
ios/Runner.xcworkspace, check Display Name, Bundle Identifier, signing Team and Deployment Target on the Runner target - Replace the placeholder app icon and launch image in
Assets.xcassets
3. Build the IPA and upload it
flutter build ipa --obfuscate --split-debug-info=build/symbols/ios
# archive: build/ios/archive/ ipa: build/ios/ipa/
To set the version explicitly:
flutter build ipa --build-name=1.4.0 --build-number=12
Upload with Apple’s Transporter app, by opening the archive in Xcode and using Validate App and then Distribute App, or from the command line with an App Store Connect API key:
xcrun altool --upload-app --type ios -f build/ios/ipa/*.ipa \
--apiKey your_api_key --apiIssuer your_issuer_id
Apple usually emails you within about 30 minutes, when the build has been processed and is available in TestFlight. Test that exact build on real devices through TestFlight before submitting it.
4. Privacy details, permissions and account deletion
- App Privacy details. Required to submit new apps and updates. You must declare data collected by third-party SDKs in your app, not only your own code.
- Privacy policy URL in App Store Connect, and a link to the policy inside the app, in an easily accessible place (guideline 5.1.1(i)).
- Account deletion. Guideline 5.1.1(v): if the app supports account creation, it must also offer account deletion inside the app.
- Purpose strings. Every permission (camera, photos, location, microphone) needs a clear
NS...UsageDescriptioninInfo.plistthat explains why. Apple lists unclear data access requests as a common issue. Flutter plugins do not write these for you. - Privacy manifests and required reason APIs. Since May 1, 2024, Apple requires approved reasons for certain APIs, including use inside third-party SDKs. Keep your plugins up to date so their privacy manifests are current.
- Age rating. Apple introduced updated age rating questions in 2026. Answer them in App Information.
Obfuscation and debug symbols
Flutter’s obfuscation works only in release builds and needs both flags together: --obfuscate and --split-debug-info=<directory>. It works for appbundle, apk, ipa and other targets.
Two things to keep in mind:
-
Keep the symbols files for every release you ship. Without them you cannot read crash stack traces from that build. To decode a trace:
flutter symbolize -i stack_trace.txt -d build/symbols/android/app.android-arm64.symbols -
Obfuscation only renames symbols. It does not hide API keys or secrets in the app, and code that depends on class names (for example
runtimeType.toString()) breaks in obfuscated builds. Test the obfuscated build, not just the debug build.
Common rejection reasons and how to avoid them
Apple says that over 40% of unresolved issues relate to guideline 2.1, App Completeness: crashes, placeholder content and incomplete information. Most rejections I’d plan for fall into a few groups.
Crashes and broken features (Apple 2.1). Test the release build on real devices, on the oldest and newest OS versions you support. A release build of a Flutter app can fail where debug works, for example because of obfuscation or a missing Info.plist key.
No working demo account. Guideline 2.1 asks you to include demo account info and “turn on your back-end service” if the app has a login. Google Play has a similar App access section. Give a working account with sample data, and make sure the staging server isn’t switched off during review.
Placeholder content and broken links. Lorem ipsum, “coming soon” screens, empty tabs and dead support URLs all count. Every link in the app and listing must work.
Privacy policy and data disclosures that don’t match the app. If you add Firebase Analytics or Crashlytics and the Data safety form or App Privacy details say “no data collected”, that’s a mismatch. Update the forms whenever you add an SDK. (Details: what Apple and Google require in an app privacy policy.)
Missing account deletion. Both stores require it if users can create accounts. Apple asks for deletion to be offered within the app, and Google also wants a web link.
Third-party login without an equivalent option (Apple 4.8). If the user’s main account uses Google or Facebook sign-in, Apple requires another login option that limits data to name and email and lets users hide their email. Sign in with Apple meets this.
Screenshots that don’t show the app (Apple 2.3). Screenshots must show the app in use, not only the splash or login screen, and must match the current version.
Too little functionality (Apple 4.2). An app that is only a WebView around a website is likely to be rejected under minimum functionality. Make sure the app does something useful on its own.
Two rejections from my own work:
- A budgeting app rejected as a finance app. App Review treated a personal budget app of mine as if it managed real money. It only tracks budgets and spending that the user enters, and no money moves through it. I fixed it by replying to App Review in App Store Connect and explaining clearly what the app does and doesn’t do. If a reviewer misreads your app, a clear, polite reply often solves it without code changes.
- A government app whose developer account left with an employee. On a government project (I can’t name it), the app was rejected, and the Apple developer account it was published under belonged to an employee who had since left the company. Before fixing the rejection, the app first needed a new home. We’re republishing it from an individual account and will then transfer it to a new company account. The lesson: publish client apps under the client’s own organisation account from day one, never a personal account of someone on the team.
How long review takes
- Apple: App Review says it typically reviews at least 50% of submissions in under 24 hours and 90% in under 48 hours. Incomplete submissions take longer. For a critical bug fix or a dated event, you can request an expedited review.
- Google Play: Google says some apps are subject to extended reviews, which can take up to seven days or longer in exceptional cases. New apps and new accounts should plan for the longer end. Add the 14-day closed test and the production access review on top for new personal accounts.
My recent timings: updates to existing apps are usually approved within 1–2 hours. A new app on Google Play takes about 15–20 days in total, mostly because of the closed-testing requirement before production. On the App Store, I keep a new app in TestFlight for testing first. After that, if review finds no issues, approval comes within a week.
My advice: don’t promise a client a launch date until both apps are approved. Use the store’s manual or scheduled release option, so approval and going live are separate steps.
The short version
- Accounts set up in the client’s name, Bundle ID and application ID chosen
- Personal Play account: 12 testers, 14 continuous days, then apply for production
-
version: x.y.z+buildbumped for every upload - Android targets API 36, signed with an upload key, built as
.aab - iOS built with Xcode 26 and the iOS 26 SDK, uploaded and tested through TestFlight
- Privacy policy URL on both stores and inside the app
- Data safety form and App Privacy details match every SDK in the app
- In-app account deletion, plus a web deletion link for Google Play
- Purpose strings for every iOS permission
- Release built with
--obfuscate --split-debug-info, symbols files saved - Demo account and review notes provided, backend running
- Screenshots show the real, current app
Publishing is not a one-time job. Every year Apple raises the Xcode minimum and Google raises the target API level, and an app that isn’t updated eventually can’t ship updates or disappears for new users. If you’d rather not track this yourself, my app maintenance service covers yearly SDK upgrades, store compliance and releases.
If you have a Flutter app that’s ready, or nearly ready, and you want someone to handle the App Store and Google Play release, get in touch.
Need a Flutter app built? Tell me about your project, or see case studies of apps I’ve worked on.
