Google Play closed testing for Godot games

Google Play needs a non-debug signature. Create a release keystore with keytool:

keytool -v -genkey -keystore mygame.keystore -alias mygame -keyalg RSA -validity 10000

In the Android preset, under Keystore, fill in Release (the file path), Release User (the alias) and Release Password. Godot currently needs the keystore password and the key password to be the same, and it's safest to use only letters and numbers.

This keystore is your upload key. On the first upload, Play App Signing is set up and Google keeps the app signing key. In CI, keep the secrets out of export_presets.cfg and pass them as environment variables instead:

GODOT_ANDROID_KEYSTORE_RELEASE_PATH=/secrets/mygame.keystore
GODOT_ANDROID_KEYSTORE_RELEASE_USER=mygame
GODOT_ANDROID_KEYSTORE_RELEASE_PASSWORD=*****

In the preset, Version → Code is the integer Google compares; increase it for every upload, because Play Console rejects reused codes. Version → Name is what players see.

Since 31 August 2026, new apps and updates must target Android 16 (API level 36). Under Gradle Build, Target SDK sets targetSdkVersion; left empty, the template's default applies. If your Godot version's default is lower than 36, set it explicitly or upgrade Godot, then test the export on a recent device.

• Mismatched templates. Export templates and the Android build template must match the editor version. After upgrading Godot, reinstall both.
• Export With Debug left on. The bundle is then signed with the debug keystore, and Play Console rejects it.
• Missing arm64-v8a. Under Architectures, keep arm64-v8a enabled; Google Play requires 64-bit native code.
• Folders starting with an underscore. In Gradle builds, assets inside a folder whose name begins with _ aren't included. Testers then hit missing textures or scenes.
• Special characters in passwords. They can make the export fail with unclear errors. Use letters and numbers.
• C# projects. Android export for C# has been available since Godot 4.2 but is still experimental. Test the release bundle on real devices early.

A Godot export runs your scripts on top of a precompiled engine library, so most tester reports turn out to be script errors, missing resources or device-specific rendering problems rather than engine crashes. The fastest way to see them is on a phone of your own, with the editor attached.

1. 1

   Deploy in one click

   Enable developer mode and USB debugging on a phone, connect it and make sure your Android preset is marked Runnable. An Android button then appears in the top-right corner of the editor and exports and installs in one click.

2. 2

   Turn on remote debugging

   With Debug → Deploy with Remote Debug enabled, the game on the phone connects back to your computer, so the editor's debugger, breakpoints and error output work as they do on desktop.

3. 3

   Go wireless if USB is unreliable

   Enable wireless debugging on the phone, pair it with adb pair and the code it shows, and confirm with adb devices. If adb devices doesn't list the phone, Godot won't see it either.

4. 4

   Check Play Console after every upload

   Engine crashes appear under Monitor and improve → Android vitals → Crashes & ANRs. The pre-launch report also installs each uploaded build on test devices automatically and flags crashes and compatibility problems.

# Wireless debugging: pair once with the code shown on the phone
adb pair <ip address>:<port>
adb devices

# Watch the device log while you reproduce a tester's report
adb logcat

A build exported without Export With Debug doesn't connect to the editor. To see why the release build fails on a specific phone, install it there and watch adb logcat while you reproduce the tester's steps.

Once your Godot bundle is built and signed, the rest happens in Play Console and works the same for every framework. This is the checklist; the full Play Console walkthrough covers every menu and screen.

• Finish app setup on the Dashboard: privacy policy, app access, ads, content rating, target audience, data safety and store listing.
• Create a closed testing release under Test and release → Testing → Closed testing: choose your testers' countries, upload the .aab and send it for review.
• Add testers with a Google Group on the Testers tab and share the opt-in link. It works once the track shows Published.
• Keep at least 12 testers opted in for 14 days in a row. Internal testing doesn't count, and someone who leaves and rejoins starts their 14 days again.
• Ship at least one update during the test and write down what testers found and what you changed.
• Apply for production from the Dashboard and answer the three sections about your test, your app and your readiness. The decision is Google's; nobody can guarantee approval.

Plan for drop-outs: recruit more than 12 testers so one person leaving doesn't push back your timeline. See the full Play Console steps.

Increase Version → Code in the preset, export the .aab again and upload it to the same closed track.

For your own test runs, Debug → Small Deploy with Network Filesystem deploys a minimal executable over USB and streams project files from the editor over the network, which saves a lot of time with large games. It's strictly a development feature: testers always need a full exported .aab on the closed track.

• Edge to edge. The preset's Screen → Edge to Edge option lets the game draw behind translucent system bars. If you enable it, keep important UI inside the area returned by DisplayServer.get_display_safe_area() so nothing hides under a bar or camera cutout.
• Keep native libraries uncompressed. Gradle Build → Compress Native Libraries makes the bundle smaller but slows startup, because libraries must be extracted before use. For Google Play, the Godot docs recommend leaving it off.
• Script the export. A headless export with the keystore in environment variables, as in the signing section, produces the same bundle every time and makes the version code bump part of the routine.
• Don't upgrade Godot mid-test. A new editor version means new export templates, a new Android build template and a new engine library for testers. Upgrade before the test or after production access.