Android App Bundles: Getting Started

See how to use App Bundles to reduce the size of the app your user downloads to their device, saving them precious data and storage! By Arturo Mejia.

Leave a rating/review
Download materials
Save for later
You are currently viewing page 2 of 3 of this article. Click here to view the first page.

Creating a Signed App Bundle From Android Studio

Go to Android Studio ▸ BuildGenerate Signed Bundle / APK.

Generating signed app bundle

Select Android App Bundle and click Next.
signed app bundle

Introduce your app signing configuration and click Next.

Select signing configuration

On the next screen, choose a Destination Folder and Build Type, and then click Finish. Simple. :]

Select signing configuration

Creating an App Bundle From the Command Line

With the availability of App Bundles, you now have some new Gradle tasks to produce an .aab:

Run the bundle task for CountOnMe, from the project root folder, in this case countonme-starter:

./gradlew app:bundle

You will see that the app.aab file is generated at the following path.


You can use the following commands to create the app bundle for a specific build variant.

./gradlew modulename:bundleVariant

Here buildVariant could be the buildDebug or buildRelease task.

The location of the output file will be:


The same signing process used for traditional APKs is compatible with App Bundles.

Publishing an App Bundle in the Play Store

To publish your App Bundle to the Play Store, the first thing you need do is enroll in App Signing by Google Play. After enrolling, you can manage your releases as you did with APKs.

App signing Google Play

After uploading your App Bundle, you have the opportunity to review your release.

Review release summary

The Google Play console will generate all the APKs for your user configurations. A nice tool for visualizing all those APKs is Bundle Explorer.

Go to Release ManagementArtifact library, then select one of the bundles that you have uploaded and click EXPLORE

Explore app bundle

Now you can see all the savings that an App Bundle provides, and all the APK files that it generated.

You can go even deeper by clicking VIEW DEVICES, and see the specific devices that an APK is going to be delivered to.

View devices

The Bundle Explorer can be a great tool while debugging, when you want to know the exact file that a user received on their device.

App Bundles are also available in the Publishing API for automation.

Testing App Bundles

The Google Play Store provides a convenient way to test your App Bundle called Internal Test Track. This is a special track wherein you can invite a closed list of users to test your app.

The Internal Test Track is similar to the Alpha and Beta tracks. The difference is that you don’t have to wait very long with the Internal Test Track, because it’s available almost instantly after you upload your App Bundle file. That helps to ensure that what your users are going to receive is the same as what your QA team is testing.

In the Play Store console, go to Release ManagementApp ReleasesInternal test track
Internal test track

There you can create a list of up to 100 testers.

List of testers

You can then share the Opt-in URL link with your testers. This link allows the users on the test list to download your app.

Using Bundletool

Bundletool is a command-line tool that helps you to manipulate Android App Bundles. This is the same tool that the Play Store uses to generate .apk files from a .aab file. Additionally, the source code of Bundletool is available as an open source project on GitHub, in case you want to take a deeper look at its ins and outs.

Bundletool allows you to test locally and simulate the same process that Google Play does to serve your App Bundle to users, in case you don’t want to test through the Play Store.

It’s your turn to play a bit with Bundletool. :]

Go to the Bundletool release page and download the bundletool-all-[LAST-VERSION].jar file into a new directory called testing-app-bundle. Then rename the jar to bundletool.jar, and copy the debug .aab file that you previously generated to this same directory.

After that, you should have a directory similar to this one:

testing app bundle directory

Note: Bundletool is distributed as a .jar file, so to be able to use it, you need to install Java Runtime Environment. Make sure you have JRE installed before going forward. As an Android developer, you likely have a JDK already installed, which includes a JRE.

To execute Bundletool from the command line, you need to use java -jar bundletool.jar followed by any command that you want Bundletool to execute.

Try this with build-apks. This command takes an App Bundle (.aab) file and outputs a set of APKs. To indicate the bundle, you use the argument --bundle, and output is identified with the argument --output.

Open Terminal, navigate to the testing-app-bundle directory and run the following:

java -jar bundletool.jar build-apks  --bundle=app.aab --output=app.apks

After executing the command above, you have a file app.apks:

App apk files

Pro-tip: If you use the flag --connected-device, you can generate APKs just for the devices connected to your development machine.

Note: The command above creates a set of unsigned APKs. If you want to install the APKs onto a device, you must also include your app’s signing information, for example:
java -jar bundletool.jar build-apks  --bundle=app.aab --output=app.apks
java -jar bundletool.jar build-apks  --bundle=app.aab --output=app.apks

To install your app on a device, you use the command install-apks, which takes an APK set as an input with the argument --apks, then extracts it and installs the corresponding APK on a connected device.

java -jar bundletool.jar install-apks --apks=app.apks

Internally, Bundletool will read the configuration of the connected device and will select the APK that matches the configuration in order to install it on the device. This is the same matching process that the Google Play Console does when a user requests an app.

Using Bundletool, you can replicate the same process that Google Play uses. This is a great tool for testing locally.

You’ve seen just a small set of things you can do with Bundletool. You can find more in the complete reference.

A Closer Look at Bundletool Output

You’ll now take a closer look at the APK set file app.apks in the testing-app-bundle folder. Change the extension of app.apks to and uncompress it using your favorite unzipping tool.

Now you have an app directory. Inside this directory there’s a sub-folder called splits. In there, you can find all the APK variations.

split apks

Cool! :]

Now, try a small experiment, taking one of these split APKs and comparing it with a traditional APK.

You’ll take the base-es.apk file and open it with the APK Analyzer tool in Android Studio, by going to BuildAnalyze APK.

Analyze apk

Note: APK Analyzer is a tool embedded in Android Studio that allows you to inspect the content of an APK file.

Navigate to the splits folder in the test-app-bundle directory you made, choose base-es.apk and click OK.

base apk analysis

base apk analysis

base-es.apk is a small file of just 5.3 KB, and it only contains the string resources for the Spanish language.

Now for the other side of the coin, a traditional (universal) APK file. A universal APK contains all the resources for every possible device configuration your app supports, and it’s the traditional way to distribute an app.

Go to BuildBuild Bundle(s) / APK(s)Build APK(s):

build apk

Then choose the APK file in app/build/outputs/apk/debug:

debug APK bundle

debug APK bundle

As you can see above, the universal APK has everything in it! It’s a much bigger 2.6 MB vs 5.3 KB file, like comparing an 🐜 versus an 🐘.

APK Analyzer allows you to diff two APKs, by going to the upper right corner and clicking the Compare with previous APK button, then navigating to and choosing the base-es.apk file:

Analyze diff

Here’s the diff between the universal APK and base-es.apk:

APK diff

Now you see the real power of App Bundles in action!