How to Install an AAB on a Phone: bundletool, Not a Rename
An .aab will not install on a phone and renaming it to .apk does not work. Here is the bundletool sequence that puts a real app bundle on a test device.
Need testers who stay active for all 14 days?
TesterBee matches you with 12 real Android testers in under 24 hours. Refund if Google rejects you over tester engagement.
On this page
- 01Why renaming an .aab to .apk cannot work
- 02The two commands that put a bundle on a device
- 03One file for several testers: the universal APK
- 04When internal app sharing is the better path
- 05What a local install does not reproduce
- 06What actually breaks during a handover
- 07Checking what actually landed on the device
- 08Does a bundletool install count toward closed testing?
- 09Frequently Asked Questions
- 10Sources
You cannot install an .aab file on a phone, and renaming it to .apk will not make it work. An Android App Bundle is a publishing format: Google Play takes the bundle, generates the split APKs a particular device needs, signs them, and serves them. To reproduce that on a test phone, use bundletool, Google's own command-line tool, in two steps. bundletool build-apks turns the bundle into an APK set, and bundletool install-apks pushes the right split combination to the connected device. If the person testing is already an opted-in Play tester, internal app sharing avoids the cable entirely.
Why renaming an .aab to .apk cannot work
An app bundle "is a publishing format that includes all your app's compiled code and resources, and defers APK generation and signing to Google Play", as the App Bundle documentation puts it. Nothing inside that file is installable on its own, because the device-side installer is not the component that reads it.
The archive layout gives the second reason. An .aab is a zip of module directories: a base module plus any feature modules, each holding its own manifest, dex and resources, with a BundleConfig.pb file at the root. Android's package installer expects one APK, with a manifest at the archive root and a signature block over the whole thing. Renaming changes the label the operating system reads and nothing about the bytes underneath, so installation stops at a parse error before any of your code runs.
The .apks file is not installable either. It is a container of APKs that still have to be selected for a specific device, which is the job bundletool does for you.
The two commands that put a bundle on a device
Both need a phone or emulator with USB debugging enabled, and adb on the machine doing the install. Run them from the folder that holds the .aab; the paths below are the ones in Google's own examples.
- Build the APK set from the bundle with build-apks, giving --bundle and --output.
- Add your keystore, or let bundletool fall back to a debug key.
- Connect the target phone and confirm adb devices lists it.
- Install the matching splits with install-apks --apks=your_file.apks.
- If the set was built with --local-testing, install it with install-apks rather than adb install.
Step 1: build the APK set
bundletool build-apks --bundle=/MyApp/my_app.aab --output=/MyApp/my_app.apks
That produces an .apks archive holding the APKs for every configuration your app supports. To deploy those APKs rather than only inspect them, add signing information: --ks, --ks-pass, --ks-key-alias and --key-pass. With no signing flags, bundletool signs with a debug key, which is fine for a phone you own and wrong for anything you intend to distribute.
Android Studio and the Android Gradle plugin produce the bundle in the first place. If you build with Flutter, flutter build appbundle performs the same step; our Flutter publishing walkthrough covers where the file lands.
Step 2: install the splits the device needs
bundletool install-apks --apks=/MyApp/my_app.apks
On Android 5.0 and above, bundletool pushes the base APK, the feature module APKs and the configuration APKs that device requires. With more than one device attached, add --device-id followed by the serial number. One constraint on that page is easy to miss: a set built with --local-testing has to be installed with install-apks, not adb, or local testing does not work correctly.
Building for one phone instead of every phone
--connected-device builds a set targeted at the attached device. For a phone you do not have in front of you, run bundletool get-device-spec --output=/tmp/device-spec.json once on that device, then build with --device-spec=/tmp/device-spec.json. This is the dependable way to prepare a build for a tester on a different ABI, screen density or Android version.
Pulling one device's APKs out of an existing set
bundletool extract-apks --apks=/MyApp/my_app.apks --output-dir=/MyApp/pixel2 --device-spec=/MyApp/pixel2.json writes the relevant APKs out as separate files. Use it when the tester has adb access and you want them to run adb install-multiple, or when you need to see exactly what the phone would receive.
One file for several testers: the universal APK
Add --mode=universal to build-apks and bundletool produces a single APK containing all code and resources, compatible with every configuration the app supports. It is considerably larger than the split build, and Google notes that only feature modules declaring dist:include="true" in their manifest are included, so a dynamic feature can go missing from it without any warning. Treat it as a sharing convenience, not as a test of what real users download.
When internal app sharing is the better path
If the tester is already on your closed test, upload the .aab on the internal app sharing page and send the generated link. Play delivers the build, so the install path is closer to production than adb is, and nobody needs a cable or a laptop.
The limits are specific, and worth knowing before you promise a link. Uploaded artifacts are excluded from the app bundle explorer and cannot be used in a track release. They can be signed with any key, because Play re-signs them with an Internal App Sharing key. Version codes can be reused. A single link works for a maximum of 100 downloading users. Links expire 60 days after the upload date.
Because the artifact is re-signed, an internal-sharing install does not exercise your production signing setup. If a signing problem is what you are hunting, bundletool is the more honest test.
If the tester is not sitting next to your machine, sign the set with the upload key rather than leaving bundletool on its debug key, send the .apks file with the install command, and tell them to remove any Play build of the app first. In our own campaign handovers, that uninstall step is the one people skip, and it is the one that produces INSTALL_FAILED_UPDATE_INCOMPATIBLE.
What a local install does not reproduce
bundletool generates splits from the bundle with the logic Play uses, but three parts of real delivery are not inside the bundle at all.
- Play's signing stamps. When Google signs your APKs with the app signing key, it adds two attributes to the manifest, com.android.stamp.source and com.android.stamp.type, so a distributed APK can be traced back to the signer. A locally built APK carries neither, so it cannot answer a question that starts with "which build is installed on that user's phone".
- Delivery rules held in Play Console. Staged rollout percentages, country targeting and device exclusions are configured on the track, not written into the bundle. No local build can reproduce who would have received which version.
- Play Core split installs. If your app fetches feature modules on demand, a sideloaded build usually has no Play to fetch them from. Google's documented answer is the fake split install manager, used with --local-testing; without it, an on-demand feature looks broken on the test phone while working for real users.
None of that makes bundletool the wrong tool. It makes it a test of the app, not a rehearsal of the release.
What actually breaks during a handover
Most failed handovers produce one of a handful of messages. Here is what each one means.
- INSTALL_FAILED_UPDATE_INCOMPATIBLE. The signature on the new APK differs from the copy already on the phone. With Play App Signing, the installed build was signed with the app signing key Google holds, while your local build is signed with the upload key or a debug key. Uninstall the store build on a spare device, or test on a phone that never had it.
- INSTALL_FAILED_VERSION_DOWNGRADE. The versionCode you built is lower than the installed one. Raise it. Do not delete and reinstall on a tester's daily phone, because that wipes their data and their bug report.
- INSTALL_FAILED_NO_MATCHING_ABIS. The APK was built for an ABI the phone does not use. Rebuild with --connected-device or with that tester's device spec instead of hand-picking a file out of the set.
- The app opens and crashes immediately. Usually base.apk was installed by hand and the configuration splits that hold the code or resources it needs were left behind. Install the set rather than one file from it.
- adb devices shows nothing. Cable, driver, or the RSA authorisation prompt still waiting on the phone screen. Nothing in bundletool works until a device is listed.
- Play Console rejects the upload rather than the phone rejecting the install. That is a different failure: usually the target API level, or native libraries that fail the 16 KB page size check.
Checking what actually landed on the device
After install-apks, confirm the split set instead of assuming it worked. adb shell pm path com.example.app prints one path per installed APK, so a healthy split install returns several lines, a base APK plus its configuration splits, while a single line means the splits never went in.
For the version the phone is actually running, adb shell dumpsys package com.example.app reports the versionCode and versionName as the device sees them. A tester reporting a bug you cannot reproduce is often running a different build from the one you sent, and comparing that versionCode with the artifact you handed over settles the question in seconds rather than in a thread of screenshots.
Does a bundletool install count toward closed testing?
No. Google's production-access requirement counts testers who are opted in to your closed test and have stayed opted in continuously for the preceding 14 days; the measure is opt-in, not installs. A build pushed over adb leaves no opt-in record, no tester in the track and no day on the counter, however many people install it. If the reason for the handover is the 12-tester requirement rather than a quick look at a build, it has to arrive through the track, and our walkthrough of the 12 testers requirement covers the invite flow and what testers have to do in Play Console.
The counter is unforgiving about gaps, too. A tester who installs your build from a cable on Monday and only opts in to the track on Friday has no days until Friday, and someone who opts out and back in restarts at zero. Opt in first, then install; the days and the install then refer to the same build.
Frequently Asked Questions
Can I just change the .aab extension to .apk?
No. The extension is a label, and the archive is still a bundle, with manifests inside module folders and no root manifest for the installer to read. Android reports a parse error rather than a signature error, because it never reaches the point where a signature would be checked.
What is the difference between .aab and .apks?
The .aab is the publishing artifact you upload to Play. The .apks is an APK set that bundletool generates locally, containing APKs for every configuration your app supports. Neither one installs by itself; install-apks selects from the set and pushes the result to a device.
Do I need my app signing key to build installable APKs?
No. bundletool signs with a debug key when you give it no signing flags, and you can supply your upload keystore instead. What you cannot do is install a locally signed build over a Play-signed one, because Play App Signing means the device copy carries Google's app signing key and the signatures will not match.
Can a tester install an AAB from a download link?
Not the bundle itself. Either you hand them an APK or an APK set plus a machine to push it, or you upload the bundle to internal app sharing and share the Play link. Through that link the download is an APK install, capped at 100 users and expired after 60 days.
Does bundletool upload my app to Google?
No. It runs locally and re-creates the APK generation Play would otherwise do server-side. Nothing leaves the machine, which is why it is the normal way to test a build before it ever reaches the Play Console.
Why does install-apks report no connected device?
adb cannot see a device: an authorisation prompt is waiting on the phone, the cable is charge-only, or platform-tools are not on the path. Run adb devices and fix that first. With several devices attached, pass --device-id so bundletool knows which one to target.
Is installing with bundletool acceptable for a production release?
For testing, yes. It is Google's own tool, documented for building and testing app bundles locally. It does not replace the upload, though: new apps and updates still go to Play as an app bundle, and Play generates and signs the APKs users receive.
Sources
- About Android App Bundles, developer.android.com: the publishing format, and the deferral of APK generation and signing to Google Play.
- bundletool, developer.android.com: build-apks flags, install-apks, --connected-device, --device-spec, --mode=universal, --local-testing and the install-apks requirement that goes with it.
- Share app bundles and APKs internally, Play Console Help: the 100-user download cap, 60-day link expiry, re-signing with an Internal App Sharing key, and exclusion from the app bundle explorer.
- Use Play App Signing, Play Console Help: upload key versus app signing key, and which one signs the APKs delivered to devices.
- App testing requirements for new personal developer accounts, Play Console Help: 12 testers opted in continuously for 14 days before production access.

Senior full stack developer specializing in Laravel, React, and Firebase. Helped 1,300+ Android developers pass Google Play Closed Testing and publish apps. Expert in Play Console, production access, and Android app publishing.
Get 12 testers into your closed test in 24 hours
Matched Android testers who open your app every day of the 14-day window, so your production access review has real engagement to look at.
Start your closed testRelated articles
Google Play Developer Account Transfer: What Actually Moves
Google runs two transfer routes: the account owner switch and the app transfer. Which route you get depends on account type, and test groups do not survive.
assetlinks.json SHA-256: Fix Play App Signing Mismatches
Play App Signing re-signs your app, so the fingerprint your keytool prints is not the one Android checks. Here is the SHA-256 to publish and how to verify it.
How Long Google Play Review Actually Takes in 2026
Google publishes a duration for only a few of its review clocks. Here is what it says for each one, plus the timing claims that have no Google source.