A repeatable procedure for publishing an Android app through Google Play Console. It covers a first production release and the checks to repeat for later updates.
Last verified: 14 November 2026. Google changes Play Console screens, policy declarations and submission requirements. The linked Google documentation is the authority if a screen or requirement has changed.
The route to production depends on your developer account. In particular, some newer personal accounts must complete a closed test and obtain production access before a public release. Check this before planning your launch date.
At a glance
- Prepare the app, developer account and signing arrangements.
- Create the Play Console app record.
- Build and validate a signed Android App Bundle.
- Complete the store listing and App content declarations.
- Complete the testing track required by your account.
- Apply for production access if required.
- Submit the production release and verify the public listing.
Allow extra time for account verification, policy review and mandatory testing. A technically finished app is not necessarily ready to publish.
1. Check the account and app requirements
Before you start, confirm:
- You are at least 18 and have an active Google Account. A standard Play Console developer account has a US$25 one-time registration fee; payment methods and local availability can vary. Accept the Google Play Developer Distribution Agreement during registration. Prepaid cards are not accepted. If the identity information is invalid, Google says the registration fee will not be refunded.
- The developer account's identity and contact details are verified. Google may require legal identity documents; organisation accounts need a D‑U‑N‑S Number (unless an applicable government-entity exception applies) and organisation documents. A D‑U‑N‑S number is free to obtain, but registration can take up to 30 days.
- Check what will be public on your developer profile. Your developer name can differ from your legal name. For a personal account, Google displays your verified legal name, country and developer email; if you monetise, your full address is also displayed. If you declare trader status, your phone number can also be displayed. For an organisation account, Google displays the legal name, D‑U‑N‑S number, legal address, developer email and developer phone number. Keep internal Google contact details separate from the public developer profile.
- If this is a personal account, verify access to a physical Android device using the Play Console mobile app before publishing. This device-verification step applies to personal account owners; it is separate from the 12-testers/14-days production-access rule for personal accounts created after 13 November 2023.
- You know whether the account is personal or organisation, and when it was created. Personal accounts created after 13 November 2023 have additional testing and production-access requirements.
- Trader status: all active Play Console developer accounts must declare trader or non-trader status under EEA and UK law by 1 February 2027, regardless of where apps are distributed. New accounts must declare during setup. If you do not distribute apps in the EEA or UK, Google says you can declare as a non-trader; otherwise assess your actual commercial activity (including paid apps, in-app purchases, advertising revenue, transaction patterns and whether you operate as a business). If you declare as a trader, self-certify legal compliance and confirm trader status for each app, providing a Terms of Service link for each. For personal accounts, trader contact phone and address are publicly displayed. From 1 March 2027, trader contact details, D‑U‑N‑S number and Terms of Service link will be displayed to users globally; EEA and UK users will also see the developer/trader name and self-certification. Missing the deadline can lead to update blocks or app removal. This is a legal classification; consult qualified advice if uncertain.
- The application ID (package name) is final.
- You have a public support contact and privacy policy URL.
- You have a release-ready build and a secure signing-key plan.
- If you sell paid apps or in-app products, complete the Google payments profile/merchant setup and any required tax and payout details before launch. For organisation accounts, the legal name and address in the payments profile must match the D‑U‑N‑S record.
- You understand the app's data collection, advertising, permissions and third-party SDK behaviour.
Current target API requirement
For standard Android mobile apps, as of 13 November 2026:
- New apps and app updates must target Android 16 (API level 36) or higher. This requirement took effect on 31 August 2026.
- Existing apps that target Android 15 (API level 35) or higher meet the separate target-level threshold for remaining available to new users on newer Android devices.
- Existing apps targeting API 34 or lower can have their availability restricted on newer Android devices. The published extension deadline was 1 November 2026; do not assume an extension is still available.
Wear OS, Android TV, Android Automotive OS and Android XR have different target API requirements. This guide is for a standard Android phone/tablet app. Check the live Google Play target API requirements for your form factor and before every release.
Do not confuse target API level with minimum SDK. The target controls the Android behaviour and policy compatibility your app declares; the minimum SDK controls the oldest Android version on which it can run.
2. Create the app record
Open Google Play Console and:
- Select Create app.
- Enter the app name and default language.
- Choose App or Game.
- Choose whether the app is free or paid.
- Enter a support email address.
Make the free-or-paid decision carefully. Google Play lets you change a paid app to free, but once an app has been offered for free you cannot change that same app back to paid. A paid version would require a new app with a new package name. Check pricing, countries and your monetisation model before publishing. 6. Complete the developer declarations and accept the Play App Signing terms presented. 7. Select Create app.
Choose the application ID carefully. It identifies the app and cannot simply be changed by renaming the project later. Confirm that the ID in your Android build matches the Play Console record.
The dashboard then lists the remaining setup tasks. Work through those tasks; creating the record does not make the app ready for release.
Official instructions: Create and set up your app.
3. Prepare a signed Android App Bundle
Google Play uses Android App Bundles (AAB) to generate device-optimised APKs. New apps on Google Play are required to publish with an Android App Bundle.
Before generating the release:
- Confirm the application ID matches the Play Console record.
- Set the user-facing version name.
- Increment the version code for every uploaded update. It must be higher than the previous uploaded version code.
- Set the target API level required by current Play policy.
- Check the minimum SDK and supported device configuration.
- Remove debug menus, test endpoints, sample accounts and development-only configuration.
- Review every permission and remove those the app does not need.
- Test the release configuration, not only a debug build.
In Android Studio, use Build → Generate Signed Bundle / APK, choose Android App Bundle, select the correct module and release signing configuration, then generate the bundle.
Protect app signing
Play App Signing is required for new Google Play apps. You sign the AAB with your upload key; Google uses the separate app-signing key to sign the APKs delivered to users. Google manages the app-signing key, while you must protect your upload key. The upload key and app-signing key are different credentials; do not confuse their certificates.
If your app uses Google APIs, OAuth, Maps, Firebase or another service that validates signing certificates, register the Google Play app-signing certificate fingerprints with those providers as well as configuring your upload key. A release signed by Google will not have the same certificate fingerprint as your local upload key.
Play App Signing manages the app signing key used for distribution. Your upload key is still sensitive and must be protected.
- Store the upload keystore and passwords in a secure password manager or secrets vault.
- Use a signing certificate that meets Google's current validity requirements; current guidance requires validity beyond 22 October 2033.
- Keep an encrypted backup in a separate secure location.
- Record who can recover the signing material.
- Never commit keystores, passwords or signing secrets to Git.
- Do not casually replace or reset signing keys; understand the Play Console recovery process first.
Install and test the release build on real devices. Confirm the app starts, permissions behave correctly and the important journeys work without development tooling attached.
Official background: Upload your app to Play Console.
4. Complete the store listing
In Play Console, open the main store listing under Grow users → Store presence. Console navigation labels can change.
Prepare accurate, final content:
-
App name.
-
Short description.
-
Full description. Prepare these required store assets:
-
App icon: 512 × 512 px, 32-bit PNG with alpha, maximum 1 MB. This is the high-resolution Play listing icon; it does not replace the app's launcher icon.
-
Feature graphic: 1024 × 500 px, JPEG or 24-bit PNG without alpha.
-
Screenshots: at least two across different device types are required to publish the listing. Use JPEG or 24-bit PNG without alpha; each image must be 320–3840 px, and its longest dimension cannot exceed twice its shortest dimension.
-
Recommendation-quality screenshots: for an app, provide at least four screenshots at 1080 px or higher (at least 1920 × 1080 landscape or 1080 × 1920 portrait) to meet Google's screenshot criteria for recommendation formats. This is a promotional eligibility recommendation, not the minimum publication requirement.
-
Large screens: if the app supports tablets or Chromebooks, provide at least four large-screen screenshots between 1,080 and 7,680 px, using 16:9 landscape or 9:16 portrait. Upload up to eight screenshots for each supported device type.
-
Phone, tablet and other device screenshots: add assets for the device types the app supports. Device-specific requirements apply to TV, Wear OS, Automotive and XR.
-
Category and tags.
-
Support email and any useful website or phone contact.
The current text limits shown by Google are 30 characters for the app name, 80 for the short description and 4,000 for the full description. Recheck the fields in Play Console before submission. The short description must explain the app's core purpose; avoid keyword stuffing, calls to action, emojis and claims about rankings, awards or promotional pricing.
Use screenshots from the actual release build. Make sure they are legible, current and representative of the real experience. Do not show unavailable features, invented awards or unsupported claims. Add accurate alt text for every graphic asset and screenshot (140 characters or fewer). Google prohibits misleading store metadata, keyword stuffing and claims such as rankings, awards or user testimonials that are not permitted. Avoid calls to action, promotional pricing and time-sensitive claims in listing assets. Check Google's current preview asset requirements before exporting assets.
Write for a person deciding whether to install. Explain what the app does, who it helps and what is genuinely different. Do not fill the description with repeated search terms.
5. Complete App content and policy declarations
Open App content in Play Console and complete every declaration applicable to the app. The exact set depends on its features and audience.
Common declarations include:
- Privacy policy.
- Ads.
- App access and reviewer instructions.
- Target audience and content.
- Content rating questionnaire.
- Data safety.
- Sensitive permissions.
- Other policy declarations displayed for the app.
Data safety is mandatory for published apps, including apps distributed through closed, open or production testing tracks. Apps active only on internal testing, system services and private apps are exempt. Even if your app collects no user data, you must complete the form and provide a privacy policy. Review the declaration across all active app versions, not just the build you are submitting.
Privacy policy and Data safety
Google requires every app to provide a privacy policy link in the designated Play Console field and a privacy policy link or text within the app, even if the app does not access personal or sensitive user data. The policy must be active, publicly accessible, non-geofenced and not a PDF. It must identify the developer or app, provide a privacy contact or enquiry mechanism, describe data access, collection, use and sharing, and explain security, retention and deletion practices. Keep it consistent with the Data safety form and any in-app disclosures.
Complete Data safety by reviewing the app and every integrated SDK or service. Consider analytics, crash reporting, advertising, attribution, authentication, payments, subscriptions, cloud storage, synchronisation and support tools. Google's definitions are technical:
- Collection generally means transmitting user data off the device. Data transmitted by an SDK counts even if it goes directly to a third party; controlled WebViews can count too.
- Local-only processing is generally not collection. Qualifying end-to-end encrypted data can also be excluded when nobody except sender and recipient can read it.
- Ephemeral processing still belongs in the form response, even where qualifying ephemeral data is not shown in the public Data safety section.
- Sharing can include transferring user data to another app on the same device. Google has specific exceptions for service providers, legal purposes, certain user-initiated or consented transfers and fully anonymised data.
Do not assume a permission automatically means data is collected, or that an SDK is exempt because its provider receives the data directly. Apply Google's current definitions to the actual data flow.
For each relevant data type, determine whether it is collected or shared, whether collection is required or optional, the purposes, and whether the data is encrypted in transit. Include third-party SDK behaviour and relevant webviews controlled by your app. Do not answer only from the code you wrote yourself. Google's Data safety form describes the combined practices across app versions currently distributed on Google Play, so keep it accurate across active releases.
If the app's data practices or SDKs change, review and update the declaration before the next release.
Account and data deletion
If users can create an account in the app, provide a readily discoverable in-app route to request account deletion and a working external web resource where users can request deletion without reinstalling the app. Enter that URL in the designated Play Console field and answer the Data safety deletion questions. Delete the account and associated data, subject only to clearly disclosed lawful retention exceptions. Account freezing is not a substitute for deletion.
Ads and app access
Declare ads if advertising appears in the app, including ads delivered through an SDK or network.
If reviewers need to sign in, subscribe, enter a code or pass a setup step to access core functionality, provide working instructions and credentials. Explain any hardware, location or other special requirement. Keep the reviewer route and required backend services available during review.
Audience and content rating
Answer the target-audience and content-rating questions from the app's actual content and functionality. Complete the Families declaration and comply with Families requirements if children are included in the target audience; this affects ads, SDKs, data handling and content. If ads are shown to children or users of unknown age, use only Families self-certified ad SDKs and do not serve personalised advertising or remarketing to them. For a mixed audience, implement a neutral age screen where required. Complete any other declarations shown for your app, such as health, financial features, news, government, permissions, advertising ID or other regulated functionality. Do not select a child audience merely because an app is suitable for families.
Payments, in-app products and subscriptions
For digital goods, app features, virtual items and subscriptions sold inside a Play-distributed app, Google Play's billing system is generally required unless a specific policy exception or enrolled regional programme applies. A paid app or in-app product also requires the relevant payments profile and merchant setup in Play Console. Choose the correct legal/payments profile carefully: Google states that a Play Console account can be linked to a payments profile only once, and it cannot later be unlinked or changed without creating a new developer account and transferring apps. Physical goods and physical services are treated differently. Do not add an external payment link or direct users to an alternative payment method unless the current policy and an applicable programme explicitly permit it; EEA, UK and other regional rules can differ.
For subscriptions, clearly disclose the offer terms, price, billing period, automatic renewal, whether a subscription is required and the benefits provided. Free trials and introductory offers must state their duration, the price after the offer and how to cancel before conversion. A subscription must provide sustained or recurring value, not merely a one-off benefit. Provide an easy online cancellation method in the app, such as a link to Google Play's Subscription Center or direct access to your cancellation process. Ensure the product, base plan, offers, pricing and purchase flow are configured and tested before review.
Google's guide: Prepare your app for review.
6. Check whether your account must run a closed test
This is a launch-planning requirement, not an optional quality recommendation.
Personal developer accounts created after 13 November 2023 must run a closed test with at least 12 testers opted in continuously for at least 14 days before applying for production access.
If this applies to your account:
- Complete the required app setup tasks.
- Open Test and release → Testing → Closed testing.
- Create a closed testing track.
- Add testers using the supported email list or Google Groups method.
- Create and roll out a closed-test release.
- Give testers the opt-in link and clear testing instructions.
- Confirm at least 12 testers have opted in.
- Keep at least 12 testers opted in continuously for at least 14 days. At the point you apply, the 12 testers must have been opted in throughout the preceding 14 days.
- Collect feedback, review issues and fix problems during the test.
- When the requirement is met, use the dashboard's Apply for production action.
- Answer Google's questions about the test, the app and production readiness. Google may ask for more testing if tester numbers or engagement are insufficient.
An internal test is useful for early checks, but it does not replace this closed-testing requirement. Sending 12 invitations or having 12 people download the app once is not enough: the testers must remain opted in for the required continuous period.
Other account types may have different requirements. Google says production-access application reviews usually take seven days or less, but can take longer. Do not schedule a launch on the assumption that approval is automatic or guaranteed. Check the account's dashboard and Google's current testing requirements for new personal developer accounts.
7. Test the exact release bundle
Use internal or closed testing to verify the exact version you intend to release.
Minimum checks:
- Fresh installation and first launch.
- Upgrade from the previous version, if one exists.
- Main user journeys and error states.
- Login, logout and account deletion, where applicable.
- Permissions granted, denied and later changed in device settings.
- Network loss and recovery.
- Purchases, subscriptions and restore flows.
- Ads and consent flows.
- Data collection and privacy behaviour.
- Supported Android versions, screen sizes and orientations.
- Accessibility and text scaling.
- Crash-free operation and useful error handling.
- Reviewer account access.
Record the version name, version code and bundle tested. If you upload a replacement bundle, test that replacement; results from an earlier build do not prove the new one is ready.
8. Create and submit the production release
After app setup and any required production-access approval:
- Open Test and release → Production.
- Select Create new release.
- Follow the Play App Signing prompts if this is the first release.
- Upload the signed AAB.
- Wait for processing and resolve blocking errors.
- Add concise release notes for the relevant languages.
- Review countries and regions.
- Review the release summary and policy warnings.
- Save and complete the submission or publishing steps presented in Play Console.
For a first production release, complete the review and publishing steps in Play Console and select Release when the release summary is ready; that action publishes the app when the review requirements are satisfied. For updates to an existing app, standard publishing releases approved changes as soon as possible, while managed publishing lets you choose when approved changes go live. Managed publishing is not a way to bypass review. Check Publishing overview, the app status and the update status; saving a draft does not make an app public.
Official release guidance: Prepare and roll out a release.
9. Roll out and verify
Before confirming the release, check:
- Correct app and application ID.
- Version code is higher than the previous release.
- Target API meets the current requirement.
- Correct signed bundle is selected.
- Listing, artwork and contact details are accurate.
- Privacy, Data safety and policy declarations are complete.
- Reviewer access works.
- Pricing, countries and release notes are correct.
- No blocking errors remain.
For an update, consider a staged rollout if it is available and appropriate. Monitor crashes, Android vitals, reviews and support reports. If a serious issue appears, use the release controls available in Play Console; do not assume an update reaches every user immediately.
For a first release, verify the public Google Play listing and install the app from Google Play once it is available. Allow time for listing and pricing changes to propagate; Google notes that some updates can take a few hours to appear. Check the app's country availability and device compatibility if users cannot find it. A successful upload or console status is not proof that users can install it.
Release checks to repeat
Use these checks before each release.
- Correct Play Console app and application ID
- Version name updated
- Version code incremented
- Target API checked against current policy
- Signed release AAB generated
- Upload key and signing material backed up securely
- Release build installed and tested on supported devices
- Store listing copy checked
- Icon, required feature graphic and screenshots checked
- Four high-resolution screenshots prepared for recommendation eligibility where applicable
- Alt text supplied for graphic assets
- Privacy policy is publicly accessible, non-geofenced, not a PDF, and linked in Play Console and inside the app
- Privacy policy and Data safety declarations match the app and all SDK behaviour
- Data safety deletion questions completed
- In-app and external account-deletion routes verified where accounts can be created
- Ads declaration matches the release build
- App access instructions and reviewer credentials verified
- Target audience, content rating and Families requirements checked
- Sensitive-permission and all other applicable App content declarations complete
- Closed-test requirement satisfied if this account is subject to it
- Production access approved if required
- Countries, pricing and release notes checked
- Production release submitted and publishing status checked
- Public listing and installation verified
- Crashes, Android vitals and reviews monitored
Common mistakes
- Choosing an application ID casually.
- Reusing a version code.
- Losing the upload key or failing to back it up.
- Uploading with an outdated target API level.
- Confusing internal testing with the mandatory closed test for newer personal accounts.
- Inviting 12 testers but not checking continuous opt-in.
- Completing Data safety without reviewing third-party SDK behaviour.
- Leaving reviewer credentials or backend services unavailable.
- Saving a release but not completing the publishing workflow.
- Assuming a successful upload means the app is publicly available.
Official sources
- Get started with Play Console: age, account types, fee and verification
- Verify developer identity information
- Device verification requirements
- Create and set up your app
- Prepare your app for review
- Data safety section
- Trader status declaration
- Google Play's Payments policy
- Subscription policy and cancellation requirements
- Required information to create a Play Console developer account
- Google Play Payments policy
- Google Play Families policies
- Subscription policy
- User data and privacy policy requirements
- Account deletion requirements
- Preview asset requirements
- Store listing best practices
- Publish your app and managed publishing
- Target API level requirements
- Testing requirements for new personal accounts
- Upload your app bundle
- Sign your app and configure Play App Signing
- Prepare and roll out a release
- Test your app on different form factors
- Set up app prices
- Set up a merchant account
Maintenance rule: verify Google's official requirements before every release. Target API levels, account testing rules and policy declarations change. Update this guide's review date whenever the workflow is re-verified.