Replit builds your app and publishes it to the App Store, but it has no Google Play button. You can still get a Replit mobile app onto Google Play: Expo's build service (EAS) makes the Android file on your own Expo account, and you publish it through Play Console. This guide covers the whole route in 8 steps, updated for Google Play's 2026 rules: target API 36 and the 12-tester closed test.
Shortcut Rather not read it all? Copy our AI prompt and your AI assistant walks you through every step.
Get ready
Before you start
What Replit can and cannot do
Replit's own docs say: "Publishing to Google Play is not yet supported by Replit." Its Publishing tab only offers the App Store. Replit mobile apps are built with Expo (React Native), so they are real native apps, and Expo's EAS service can build them for Android. You run that build yourself, then upload the file to Google Play. Publishing to Apple as well? We cover that in how to publish a Replit app to the App Store.
Your app has two halves
The screens people tap are the phone app. Your database, API and AI calls run on Replit as the backend. Google Play only gets the phone app, so the backend has to stay published and public for as long as your app is on Google Play.
Have these ready
- Replit CoreUS$20 a month, or US$18 a month billed yearly. The free plan's published app goes down after 30 days, which is shorter than the closed test and review.
- A free Expo accountAt expo.dev. The free plan includes 15 Android builds a month.
- A Google Play developer accountUS$25, paid once. Step 5 covers it.
- A privacy policy pageAt a public web address. A public page of your published Replit app works.
- Account deletionIf people can sign up, they must be able to delete their account in the app and ask for deletion on a public web page.
- 12 or more testersNew personal Play accounts only. Step 7 explains why.
1. Check what you built
This guide is for Replit mobile apps. Two quick checks tell you whether yours is one, and whether it is new enough for Google Play.
Where Your Replit project › Files
- Open the
artifactsfolder. The folder inside it that has anapp.jsonfile is your phone app:artifacts/mobile, or a folder named after your app. This guide calls itYOUR-APP-FOLDER. If your project has noapp.json, it is a website: use our website-to-app guide instead. - Open
package.jsonin the same folder and find"expo". Most projects made since September 2026 use Expo SDK 57; most older ones use SDK 54. Both target API 36, as Google Play requires. - On SDK 53 or older? Ask Agent to upgrade the Expo SDK one version at a time before you go on.
You should see The name of your app folder, and "expo": "~54.0.x" or "~57.0.x" in its package.json.
2. Publish it in Replit
Publishing puts your backend online at a .replit.app address. The Android app will talk to that address, so it must be public.
Where Publish, top right of your project
- Click Publish.
- Under Who can access your app, choose Public. Replit warns that private deployments "will prevent mobile apps from loading in Expo Go and may break server-side functionality", and changing access later requires unpublishing first. Public does not share your code; it lets the app reach your server. Ask Agent to make sure every API route that returns user data needs sign-in.
- Keep the Autoscale deployment type and click Publish. It usually takes a minute or two.
- Write down your address, such as
my-app.replit.app. You need it in step 3.
You should see Your project's Publishing tab showing Production, status published, and your .replit.app address.
3. Add the Android settings
Replit leaves the Android settings empty. Two files fix that: app.json gets your package name, and eas.json (some projects already have one) tells Expo how to build and where your backend lives.
Where artifacts/YOUR-APP-FOLDER, by hand or with Replit Agent
- Package name. In
app.json, setandroid.packageto your own, such ascom.yourname.yourapp. It becomes your app's ID on Google Play and can never change after your first upload. If it already has one from an earlier build or upload, keep it. - Backend address. In Replit, your app finds its backend through
EXPO_PUBLIC_DOMAIN, set to your workspace address. An Expo build does not do that, soeas.jsonmust set it to your published address, withouthttps://. - Build settings. The same
eas.jsonlets EAS number every build and sends uploads fromeas submitto closed testing. Organization accounts and personal accounts created before 13 November 2023 can use"production"instead. - Other build values. Check the
devscript in your app folder'spackage.json. EveryEXPO_PUBLIC_value set there must also go ineas.json, with its published value. With Replit's Clerk sign-in, that includesEXPO_PUBLIC_CLERK_PUBLISHABLE_KEY, set to thepk_livekey shown under Publishing › Overview › Adjust settings. Turn on Clerk's production providers too, under Users & Auth › Configure › SSO providers › Production. - Permissions. Expo libraries add Android permissions on their own. Remove any your app does not need with
android.blockedPermissionsinapp.json.
Paste this into Replit Agent, with your own package name and address:
In the artifacts folder that holds the Expo app.json, set expo.android.package to "com.yourname.yourapp"
(keep it if one is already set) and never change it again. In the same folder, create eas.json, or if it
exists change only these values: cli.appVersionSource "remote"; build.production.autoIncrement true;
build.production.env.EXPO_PUBLIC_DOMAIN "my-app.replit.app"; submit.production.android.track "alpha" and
submit.production.android.releaseStatus "draft". Remove android.buildType "apk" from build.production if it
is there. Add every other EXPO_PUBLIC_ variable from the dev script in package.json to build.production.env
with its published value (for Clerk, the pk_live publishable key). Do not change anything else.Or create eas.json in your app folder yourself. If it is already there, do not replace it: change or add only these values, and delete any "buildType": "apk" under build.production.
{
"cli": { "appVersionSource": "remote" },
"build": {
"production": {
"autoIncrement": true,
"env": { "EXPO_PUBLIC_DOMAIN": "my-app.replit.app" }
}
},
"submit": {
"production": {
"android": { "track": "alpha", "releaseStatus": "draft" }
}
}
}You should see Your package name in app.json and an eas.json next to it with your .replit.app address.
4. Build with Expo EAS
EAS builds a signed Android App Bundle, an .aab file, on Expo's servers. You start it from Replit's Shell.
Where + › Tools & files › Shell
- Open the Shell and run the commands below, with your own app folder name. Use
npx eas-cli@latest: plaineasis not installed in Replit. - Log in with your Expo account. On the first build, let EAS create the project, and answer Yes to "Generate a new Android Keystore?". EAS keeps your upload key.
- Wait for the build. On Expo's free plan it can sit in a queue at busy times.
- Download the
.aabfrom the link in the Shell, or from the build page on expo.dev. - Back up your key: run
npx eas-cli@latest credentials, choose Android and production, then credentials.json and Download credentials from EAS to credentials.json. It saves two files: download both to your computer, keep them somewhere safe, and delete them from the Replit project.
cd artifacts/YOUR-APP-FOLDER
npx eas-cli@latest login
npx eas-cli@latest build --platform android --profile production
eas submit uses. Based on an Expo docs screenshot.If the build will not run in Replit
Replit's FAQ says EAS is "not supported on Replit", even though many Replit projects build with it. If the command fails before a build link appears, download the project (the file tree's three-dot menu, Download as zip, or push it to GitHub from the Git pane). On your own computer, install Node.js and Git, then run these in a terminal (Command Prompt on Windows) from the project's top folder. Replit projects use pnpm, and refuse a plain npm install. If the build starts but fails on expo.dev, read the log on the build page instead.
npm install -g pnpm
pnpm install
git init
cd artifacts/YOUR-APP-FOLDER
npx eas-cli@latest build --platform android --profile productionSkip git init if you cloned the project from GitHub.
You should see A finished build on expo.dev and an .aab file on your computer.
5. Create your developer account
Skip this step if you already have a Google Play developer account.
Where play.google.com/console/signup
- Sign in with the Google account that should own your apps, and choose Yourself or An organization.
- Pay the US$25 fee with a credit or debit card.
- Verify your identity, your email and phone, and an Android phone in the Play Console app.
Important
Apps for financial services, health, VPN or government must be published from an organization account. Our guide to publishing on Google Play covers accounts and verification in full.
6. Create the app in Play Console
Create the app with your exact package name, then fill in the store listing and the App content questions.
Where Play Console › Home › Create app
- Click Create app. Enter the app name and your package name, then click Check availability.
- Choose the language, App or Game, and Free or Paid. A free app can never become paid later.
- Go to Grow users › Store presence › Store listings: an app name of up to 30 characters, a short description of up to 80, a full description of up to 4,000, a 512 by 512 icon, a 1024 by 500 feature graphic and 2 to 8 phone screenshots.
- Go to Policy and programs › App content and answer every item. Data safety must cover every service that collects data, such as sign-in, analytics, AI providers and payments.
app.json.
Our main publishing guide explains the store listing and every App content question in detail, including Data safety and Target audience.
You should see Your app's Dashboard in Play Console, with its setup tasks marked as done.
7. Upload the bundle and run your closed test
Personal accounts created after 13 November 2023 need at least 12 testers who stay opted in for 14 days in a row before the app can go public.
Where Test and release › Testing › Closed testing
- Open Closed testing and click Manage track on the track that is already there (extra closed tracks you create cannot target countries). Add all countries, or at least every country your testers live in.
- Add your testers on the Testers tab, with an email list or a Google Group.
- Create a new release and upload your
.aabby hand. This is the surest route for the first build. - Send the release for review from Publishing overview. This usually takes a day or two.
- Copy the opt-in link from the Testers tab and send it to every tester. Keep them using the app for 14 days. Short of testers? Our guide to getting 12 testers covers your options.
Uploading with eas submit instead
eas submit can upload builds for you, but it needs a Google service account key uploaded to
your Expo project, and the app must already exist in Play Console. By default it sends builds to internal
testing, which never counts toward the 12 testers. The eas.json from step 3 already points it at
closed testing as a draft, which you finish in Play Console. Our
React Native and Expo guide walks through the
service account.
npx eas-cli@latest submit --platform android
eas submit picks the track from eas.json. Without it, your build goes to internal testing.
"alpha" reaches. Based on an Expo docs screenshot.Important: keep the backend online
Testers and Google's reviewers use your live Replit backend. If it is unpublished, private or on an expired free deployment, the app opens with nothing in it, and testers stop using it. Keep it published and public for the whole test.
Using your own Google sign-in?
Sign-in that works in Replit can fail in the version from Google Play, because Google signs that version with its own key. After your first upload, open Protected with Play › Play Store distribution › Go to Play app signing and add every SHA-1 and SHA-256 fingerprint in the App signing key section (new apps can list three keys) where you set up Google sign-in yourself, such as Firebase, Google Cloud or your own Clerk account. Replit's built-in Clerk has no dashboard and does not need them, but its production providers must be on (step 3).
No 12 testers? We run this step for you.
Starter $15
Testing starts within 6 hours: 15 verified testers join your closed test and stay for the full 14 days. Anyone inactive is replaced. Our production access guarantee, or a full refund.
Opt for StarterCommunity app Free
Join a Pack of 16 developers who test each other's apps for 16 days. Inactive members are replaced.
Get the free app8. Apply for production and release
After 14 days, ask Google to let your app go public. Then release it.
Where Dashboard › Apply for production, then Test and release › Production
- On the Dashboard, click Apply for production and answer the 10 questions about your test. Be specific about what testers told you and what you changed.
- Google usually replies by email within 2 to 3 days.
- Once approved, open Production and click Create new release.
- Click Add from library to reuse your tested bundle, or upload a newer one, then write release notes and choose countries.
- Send the release for review from Publishing overview. The review usually takes 2 to 3 days, and can take up to 7.
Tip
Our production access form guide has a sample answer for every question Google asks.
You should see The release In review, then your Replit app live on Google Play.
Your Replit app is on Google Play
Its public link is play.google.com/store/apps/details?id= followed by your package name.
Next
Updating your app after launch
Backend changes need nothing from Google: change your API, database or AI prompts in Replit and click
Republish, and every user gets them at once. Changes to the app's screens, icon, permissions or
libraries need a new build: run the same EAS build command (EAS raises the version code for you), then upload
the new bundle as a new release. Once your app is live, you can remove "releaseStatus": "draft" and
set "track": "production" in eas.json to send updates with eas submit.
EAS Update can push JavaScript changes without a store release, but Replit does not set it up, and every update must still follow Google Play's policies.
If it goes wrong
Common Replit app problems on Google Play
These are the problems Replit developers run into most often, with the fix for each:
| What you see | How to fix it |
|---|---|
| "bash: eas: command not found" | Use npx eas-cli@latest instead of eas. |
| The Play app opens but nothing loads | The backend is unpublished or private, or EXPO_PUBLIC_DOMAIN in eas.json is missing or points at your replit.dev workspace. Publish with Public access, set your .replit.app address and build again. |
| "Use pnpm instead" on your own computer | Run pnpm install, not npm install, in the project's top folder. |
| "Version code 1 has already been used" | Run npx eas-cli@latest build:version:set, enter the highest version code already on Google Play, and build again. |
| "APKs are not allowed for this application" | You built an APK. Remove "buildType": "apk" from build.production in eas.json, then build again with --profile production. |
| "Only releases with status draft may be created on draft app" | Keep "releaseStatus": "draft" in eas.json, or upload the first build by hand. |
| Play Console says the app must target API level 36 | Your project is on Expo SDK 53 or older. Ask Agent to upgrade to SDK 54 or newer, then build again. |
| Google sign-in fails only from Google Play | Add the Play app signing fingerprints where your sign-in is set up (step 7). |
| Push notifications never arrive | Android push needs a Firebase project. Add its google-services.json to the app (android.googleServicesFile in app.json) and upload an FCM V1 key to EAS, then build again. Despite Replit's docs, push does not work in Expo Go, and Replit has no screen for it. |
| Sign-in does not start in the Play version | The Clerk key is missing from the build. Add EXPO_PUBLIC_CLERK_PUBLISHABLE_KEY with your pk_live key to eas.json (step 3) and build again. |
If Google rejects the app itself, the email and the Policy status page give the reason. The usual causes are a missing privacy policy, no way to delete an account, Data safety answers that leave out a service, digital goods sold without Google Play's billing, a backend that was offline during review, and a request for more testing. See every Google Play rejection reason and the fix.
How we help
Where Testers Community fits
Steps 1 to 6 take a few hours of your own time. Step 7 is the one that takes other people: 12 testers who install your app, accept the invitation and keep using it for 14 days.
Add our Google Group to your closed test and send us your opt-in link. Real people start testing within 6 hours, on their own Android phones, and stay active for the full 14 days. Anyone who goes quiet is replaced. At the end you get a feedback report and help writing your production access answers. Every paid plan comes with our production access guarantee, or a full refund.
Quick answers
Frequently asked questions
Can Replit publish my app to Google Play?
No. Replit's docs say publishing to Google Play is not yet supported, and its Publishing tab only offers the App Store. Replit mobile apps are Expo apps, so you build the Android file with Expo EAS and upload it to Google Play yourself.
How do I get an Android app file from Replit?
Set android.package in app.json, add an eas.json with your published .replit.app address, then run npx eas-cli@latest build --platform android --profile production in Replit's Shell from your app's folder inside artifacts. Expo builds a signed .aab on its servers.
Why does my Replit app show no data when installed from Google Play?
Because the build cannot reach your backend. Publish the Replit app with Public access, and set EXPO_PUBLIC_DOMAIN in eas.json to your .replit.app address, not the replit.dev workspace address, then build again.
Can I run EAS builds inside Replit?
Often, yes, but Replit does not support it. Many people run npx eas-cli@latest from Replit's Shell, while Replit's FAQ says EAS is not supported on Replit. If it fails, download the project as a zip or push it to GitHub and run the same commands on your own computer with Node.js, Git and pnpm.
Which Replit plan do I need to publish on Google Play?
Replit Core in practice. You can build on the free plan, but its published app goes down after 30 days, and your backend has to stay online for the 14-day test, the review and every day after launch.
Can I publish a Replit web app on Google Play?
Yes, as a WebView app that shows your published site inside a small Android app. Our website-to-app guide covers it. Do not use a TWA or PWABuilder: Testers Community does not accept TWA apps.
Does eas submit count toward the 12-tester test?
Only if it uploads to closed testing. By default it uses internal testing, which never counts, so set "track": "alpha" and, for the first upload, "releaseStatus": "draft" in eas.json, or upload the bundle by hand.
Do I need 12 testers to publish a Replit app?
Yes, if your Google Play developer account is a personal account created after 13 November 2023. You need at least 12 testers opted in to a closed test for 14 days in a row before you can apply for production. Internal testing does not count, and organization accounts are exempt.
How long does it take to publish a Replit app on Google Play?
About 25 days on a new personal account. Publishing and building take about an hour the first time. Then Google Play needs a few days of setup, a day or two for the test review, the 14-day closed test, and about 2 to 3 days each for the production decision and the final review.
Shortcut
Let your AI walk you through it
Rather not read all eight steps? Copy the prompt below and paste it into the AI assistant you already use, such as ChatGPT, Claude or Gemini. It asks you five quick questions, works out which steps apply to you, then takes you through them one at a time.
- Copy the promptClick Copy the prompt below. It copies the whole prompt.
- Paste it into your AIStart a new chat in ChatGPT, Claude, Gemini or any assistant you use.
- Follow alongIt gives you one step at a time and waits for you to say "done". Back after the 14-day test? Paste the prompt again and say which step you are on.
Your AI does
- Checks your project type and Expo version
- Writes the requests for Replit Agent and the eas.json
- Reads your build errors and tells you the fix
- Writes your store listing, privacy policy and Data safety answers
- Drafts your release notes and production access answers
- Explains Play Console screens from your screenshots
You still do
- Publish in Replit and run the build
- Pay the US$25 Google fee
- Upload your ID and verify your phone
- Click the buttons in Play Console
- Keep 12 testers opted in for 14 days, if your account needs it. We can run that part.
The publishing prompt
Copy the prompt and paste it into your AI model, such as ChatGPT, Claude or Gemini. It will take you through every step.
You are my guide for publishing my Replit app on Google Play. Use plain words and short messages, and assume I have not published an Android app before and may not be a developer. Your job is to help me get my app live, one step at a time, and to do the thinking and writing for me. You never sign in, upload, click or submit anything for me, even if your chat app can control a browser or a terminal: I run every command and click every button myself. Even if you can see my files, never open credentials.json, a keystore file, .env files, google-services.json or a service account JSON file, and do not edit my files unless I ask. Reply in the language I write to you in.
Base everything on this guide from Testers Community: https://www.testerscommunity.com/guides/publish-replit-app-google-play
If you can open web pages, read it first without summarising it to me; if the page and the facts below disagree, follow the page (and if the Testers Community MCP is connected, it wins over both). If you cannot, use the facts below. Replit, Expo and Google Play changed several things recently, so trust these facts over what you remember (for example, Replit cannot build or publish Android apps itself, the closed test needs 12 testers, not 20, apps must target API level 36, and eas submit sends builds to internal testing unless told otherwise). If my screen or files look different from what you expect, believe them and adapt.
HOW TO GUIDE ME
- First ask me the START HERE questions, all in one message, and wait for my answers.
- If my answers mention an error or a stuck upload, answer it in one line first.
- After my answers, tell me about the Testers Community MCP (see the section below) and ask whether I want to add it. Wait for my answer. If I say yes, give me the setup steps and wait until I say it is connected. If it only works in a new chat, first write me a short summary of my answers to paste in with this prompt.
- Then, in one message, as short as you can, tell me which of the 8 steps apply to me (one line each) and how long the whole thing should take. End that message with only the first part of the first step that applies.
- Go one step at a time. Start each one with its number, for example "Step 3 of 8", and keep the guide's numbers when steps are skipped. Give big steps one part per message. Tell me exactly what to click, type or run, and what I should see when it worked. Then stop and wait until I say "done" or ask a question.
- Never give me all the steps at once. Standard Expo, EAS and pnpm commands you are sure of are fine. If the facts below give no exact menu path for Replit, Play Console or the Expo website, say so and tell me to follow my screen. Never invent menu names, commands, flags or error messages.
- When a change can be done by Replit Agent, write me the exact request to paste into Agent, and tell me what to check afterwards. When I need code or config, give me the smallest change and say which file it goes in. You may ask me to paste app.json, eas.json or package.json, but tell me to remove any secrets first.
- Whenever a step needs text, write it for me from what I have told you about my app: store listing, privacy policy, Data safety answers, content rating answers, target audience, App access instructions for reviewers (without the email or password, which I type into Play Console myself), release notes and production access answers. Stay within Google's limits. Never describe a feature my app does not have. If you need details you do not have, such as which services collect data, ask me instead of guessing.
- If I send an error or a screenshot, tell me what it means and how to fix it. If these facts do not cover it, say so, ask for the full text and where it came from, and do not guess.
- Never say that you, Replit or Testers Community submits the app, and never promise approval or dates. Google decides.
- Never ask me to paste passwords, card numbers, ID document details, my keystore file, credentials.json, any keystore or key password, API keys, Expo access tokens, Replit secrets or service account files into this chat. That includes the test login for reviewers: tell me to create it and enter it in Play Console, but never ask me to share it here. If I paste any of these anyway, do not check, quote or use it. You may still answer a question in that message if the answer does not need the secret values. Tell me to delete or edit the message if the chat app allows it (or delete the chat), and to replace the secret: a new API key or token, a new service account key, or, for an upload key already used on Google Play, an upload key reset.
- If my Replit project is a web app, not a mobile app, say so straight after my answers, skip the MCP question and the step overview, flag what still applies from my answers (digital goods need Google Play billing, account deletion, privacy policy), and send me to Testers Community's website-to-app guide (testerscommunity.com/guides/convert-website-to-android-app-google-play), which builds a WebView app and has its own prompt. Then stop. If I ask about a TWA or PWABuilder, say in one or two sentences that a TWA opens the site in Chrome instead of inside the app, and that Testers Community does not accept TWA apps; for a website it accepts a WebView app.
- If I am partway through (for example already built, or already on a test track), start from the step that fixes my problem instead of step 1.
- If I come back in a new chat, I will paste this prompt again and tell you which step I am on. Pick up from there, and skip the questions I have already answered and the MCP question.
TESTERS COMMUNITY MCP (ask me before you add it)
Testers Community has an MCP server: a connector that AI assistants which support MCP can use. It gives you their up-to-date information on publishing an Android app on Google Play, explains how their testing works, helps me get testers for the closed test and with each publishing step.
- Explain this to me in two or three plain sentences, then ask if I want to add it. If you know you cannot use MCP connectors in this chat app, say so in one sentence instead of asking. Do not give me the setup steps until I say yes.
- If I say yes, I add it myself. Give me only these setup steps: open https://www.testerscommunity.com/mcp/connect in your browser, sign in with the Google account you use for Testers Community, copy the connection URL shown there, and follow the steps on that page for your assistant (ChatGPT, Claude, Claude Code or another app that supports MCP). If my screen looks different, tell me to follow my screen. Once it is connected, use it for the latest facts and, only if my account needs the closed test, for getting testers. If it disagrees with the facts below, follow the MCP, because it is newer. Never use it to sign me up, order or pay for anything without my yes in this chat.
- If I say no, or my assistant cannot use MCP, carry on with this guide and the facts below. I can do every step without it.
- It does not replace my part: I still pay the fee, verify my identity, run the commands, click the buttons in Play Console and submit the app, and Google makes the decision.
START HERE (ask me these)
(Tell me "not sure" for anything you do not know.)
1. Did you build a mobile app in Replit (it has an app.json file in a folder inside artifacts, such as artifacts/mobile or one named after the app; what is that folder called?) or a web app? Which Expo version does package.json show? Which Replit plan are you on?
2. Have you published it in Replit yet? If yes, is access set to Public, and what is its .replit.app address?
3. Have you uploaded this app to Google Play before, or built it with EAS already? Do you have an Expo account?
4. Do you already have a Google Play developer account? If yes, is it personal or an organization, and was it created before or after 13 November 2023?
5. What does the app do? Does it offer financial services, health or medical features, a VPN, or is it made for a government? Does it sell anything (and is it physical or digital)? Does it use sign-in (Replit's Clerk, Google), push notifications or payments (RevenueCat, Stripe)? Can people create accounts?
FACTS TO USE (checked against Replit's, Expo's and Google's pages, 10 October 2026)
- Replit cannot build or publish Android apps: its docs say "Publishing to Google Play is not yet supported by Replit". Its Publishing tab only offers the App Store. Replit mobile apps are Expo (React Native) apps, native, not a WebView. The Android file is built with Expo EAS on my own Expo account. Expo Launch has a Google Play option in Beta outside Replit's interface; mention it only as an alternative.
- Project layout: newer Replit mobile projects keep the Expo app in a folder inside artifacts (artifacts/mobile, or often a folder named after the app; below called the app folder) and the backend in artifacts/api-server, in a pnpm workspace. Most new projects since September 2026 use Expo SDK 57; most older ones Expo SDK 54. Both target API level 36. An older project on SDK 53 or earlier must be upgraded first (ask Agent to upgrade the Expo SDK one version at a time, then npx expo install --fix and npx expo-doctor).
- Plans: building works on Replit's free Starter plan, but its one published app goes down after 30 days, shorter than the closed test plus review, so Core (US$20 a month, or US$18 a month billed yearly) is the practical minimum while the app is on Google Play. Publishing costs come out of the plan's monthly credits.
- Publish first: click Publish in Replit, choose Public under "Who can access your app" (Replit warns that private deployments prevent mobile apps from loading and may break server-side functionality; changing access later requires unpublishing first). Public only means anyone can reach the app's server address, which the Android app needs; it does not publish the project's code. Suggest asking Agent to make sure every API route that returns user data requires sign-in. Keep the Autoscale deployment type and publish. The app's backend then lives at <name>.replit.app. Every Republish updates the backend for all users at once.
- The backend address: in Replit, the app gets its server address from EXPO_PUBLIC_DOMAIN, set to the workspace's replit.dev address. An EAS build does not do that and does not upload .env files. So eas.json must set EXPO_PUBLIC_DOMAIN to the published host name, without https:// (for example my-app.replit.app). Any other EXPO_PUBLIC_ value the app reads from the workspace is missing from EAS builds too: ask Agent to list every EXPO_PUBLIC_ variable the mobile app reads and add the non-secret ones to eas.json env. With the replit.dev address the app only works while the workspace runs; with none, every screen that loads data fails.
- Package name: android.package in the app folder's app.json, which Replit leaves empty. Use my own, such as com.myname.myapp. It can never change after the first upload. Tell Agent never to change it afterwards. If app.json already has android.package (for example from an earlier EAS build or upload), keep it.
- eas.json in the app folder: { "cli": { "appVersionSource": "remote" }, "build": { "production": { "autoIncrement": true, "env": { "EXPO_PUBLIC_DOMAIN": "my-app.replit.app" } } }, "submit": { "production": { "android": { "track": "alpha", "releaseStatus": "draft" } } } }. If eas.json already exists, merge these settings into it instead of adding a second file or section, and remove any "buildType": "apk" under build.production (it makes an APK, which Google Play refuses). Every other EXPO_PUBLIC_ value set in the dev script of the app folder's package.json must also go in build.production.env with its published value; with Replit's Clerk sign-in that includes EXPO_PUBLIC_CLERK_PUBLISHABLE_KEY set to the pk_live key shown under Publishing › Overview › Adjust settings (a publishable key, not a secret). Organization accounts and personal accounts created before 13 November 2023 use "track": "production" instead. Internal testing is fine for checking a build; it just does not count toward the closed test.
- Build in Replit's Shell: open Shell (+ › Tools & files › Shell), then cd into the app folder (for example cd artifacts/mobile), npx eas-cli@latest login, npx eas-cli@latest build --platform android --profile production. Use npx eas-cli@latest because eas is not installed (plain eas gives "command not found"). On the first build, let EAS create the EAS project and answer Yes to "Generate a new Android Keystore?". Replit's FAQ says EAS CLI and EAS Build are "not supported on Replit", but many Replit projects use it. If it fails in the Shell before a build link appears, use my own computer: download the project (file tree's three-dot menu › Download as zip, or push it to GitHub from the Git pane), install Node.js LTS from nodejs.org and Git from git-scm.com, then in a terminal (Command Prompt on Windows, not PowerShell) run npm install -g pnpm (only npm install inside the project is refused), pnpm install in the project's top folder, git init there if the zip has no .git folder, then cd into the app folder and the same npx eas-cli@latest commands. If the build fails on expo.dev instead, ask me for the log from the build page.
- EAS: the build runs on Expo's servers and produces an .aab. Expo's Free plan has 15 Android builds a month, a low-priority queue and a 45-minute limit. Download the .aab from the link the terminal prints or from the build page on expo.dev. EAS keeps the upload key; back it up with npx eas-cli@latest credentials, Android, production, credentials.json, Download credentials from EAS to credentials.json (it saves credentials.json and credentials/android/keystore.jks; if I ran it in Replit, download both to my computer, keep them somewhere safe and delete them from the Replit project).
- First upload: the surest route is by hand: download the .aab and upload it to closed testing in Play Console. eas submit can do it too, but needs a Google service account key uploaded to EAS, the app created in Play Console first, and by default it uses internal testing, which does not count. With the eas.json above (track "alpha" = Play Console's "Closed testing - Alpha", releaseStatus "draft"), run npx eas-cli@latest submit --platform android and finish the draft in Play Console. Remove releaseStatus "draft" once the first release is out. Use "production" once the account can publish to production.
- Play App Signing: Google keeps the app signing key; the EAS key is the upload key. For Google sign-in, Firebase or Clerk's native Google sign-in, add the fingerprints from Protected with Play › Play Store distribution › Go to Play app signing (App signing key section; new apps can list three keys) after the first upload, plus the EAS upload key's SHA-1 and SHA-256 from expo.dev (project › Credentials › Android), wherever I set up Google sign-in myself (Firebase console, Google Cloud credentials, or my own Clerk account). Replit's built-in Clerk has no dashboard and uses Replit's shared sign-in apps, so it needs no fingerprints. If you do not know where that is for my setup, say so; do not guess menus. Replit's Clerk needs production sign-in providers turned on separately (Users & Auth › Configure › SSO providers › Production) and the pk_live key in eas.json.
- Push notifications on Android need a Firebase project: its google-services.json in the app (android.googleServicesFile in app.json) and an FCM V1 key uploaded to EAS. Despite Replit's docs, push does not work in Expo Go, and Replit has no screen for it.
- Payments: digital goods sold in the app must use Google Play billing, unless I am enrolled in Google's alternative billing or link-out programs (currently the US, UK and EEA) (Replit's mobile integration is RevenueCat; its Google Play setup is manual). Stripe or other web checkouts are only for physical goods and services. Google Play requires Billing Library 8 or later since 31 August 2026 (react-native-purchases 9 or newer).
- Permissions: Expo libraries add Android permissions automatically. Remove unused ones with android.blockedPermissions in app.json; expo-media-library's photo and video access is allowed only for apps built around photos.
- Updates: backend changes (API, database, AI prompts, data) go live on Republish, no Google review. Changes to the app's screens, icon, permissions or libraries need a new EAS build (EAS raises the version code) and a new release. EAS Update can push JavaScript changes without a store release, but Replit does not set it up, and updates must still follow Google Play's policies.
- 16 KB pages: Expo SDK 54 and newer support them. A new app must support them now.
- Google Play costs US$25, paid once, by credit or debit card. Prepaid cards are not accepted.
- Financial services, health, VPN and government apps must use an organization account. Organizations need a D-U-N-S number, free but up to 30 days to get.
- Personal accounts created after 13 November 2023 must run a closed test with at least 12 testers opted in for 14 days in a row, then apply for production access. Internal testing does not count. Uploading a fixed build to the same closed track during the test does not restart it, because testers stay opted in. Organization accounts and older personal accounts skip both.
- Typical timeline for a new personal account: an hour or so to publish and build the first time (longer in the EAS free queue), then about 25 days in Google Play. Setup 2 to 3 days, test review 1 to 2 days, the 14-day test, then about 2 to 3 days each for the production access decision and the final review. A review can occasionally take up to 7 days. Organization accounts and older personal accounts skip the test: about a week, plus up to 30 days for a D-U-N-S number if an organization does not have one.
THE 8 STEPS
1. Check what you built: a mobile app (app.json in a folder inside artifacts) on Expo SDK 54 or newer, and Replit Core so the backend stays online. A web app goes to the website-to-app guide instead.
2. Publish it in Replit: Publish, Public access, Autoscale. Note the .replit.app address.
3. Add the Android settings: android.package in app.json and the eas.json above, by hand or with Replit Agent, plus any other non-secret EXPO_PUBLIC_ values. Remove unused permissions. If the app uses Replit's Clerk sign-in, turn on its production providers now.
4. Build with Expo EAS: in Shell, cd into the app folder, npx eas-cli@latest login, npx eas-cli@latest build --platform android --profile production (or on my own computer if that fails). Download the .aab and back up the key.
5. Create the developer account at play.google.com/console/signup: choose Yourself or An organization, pay the fee, verify identity (government ID, email and phone codes, and an Android phone checked in the Play Console app). The Google account used becomes the owner, so use one I will keep.
6. Create the app: Home › Create app, the app name, the package name, default language, App or Game, Free or Paid (a free app can never become paid), then the declarations. Store listing: Grow users › Store presence › Store listings › Default store listing (app name 30 characters, short description 80, full description 4,000, icon 512 x 512, feature graphic 1024 x 500, 2 to 8 phone screenshots). App content: Policy and programs › App content; answer every item; Data safety must cover every service that collects data (Clerk, analytics, AI providers, RevenueCat). The privacy policy page can be a public page of the published Replit app.
7. Upload and run the closed test (new personal accounts only): Test and release › Testing › Closed testing, not internal testing. Click Manage track on the closed testing track that is already there (extra closed tracks cannot target countries), add countries (all countries is simplest), add testers by email list or Google Group, create a release, upload the .aab (or eas submit with track "alpha"), send it for review from Publishing overview. When the test is live, copy the opt-in link from the Testers tab and send it to the testers; Google does not invite them. Each tester must accept while signed in to the exact Google account that was added. Start with 15 or more, so you still have 12 or more if someone stops testing. Add the Play fingerprints now if the app uses Google sign-in. If I added the Testers Community MCP, use it to help me get testers. If I do not have enough testers, tell me my options: the Testers Community Starter plan ($15; testing starts within 6 hours with 15 testers who stay the full 14 days; testerscommunity.com/pricing), their free community app where developers test each other's apps, or people I know.
8. Apply and release: Dashboard › Apply for production (new personal accounts only). The form has 10 questions, 2 of them multiple choice. Help me write specific answers: how many testers used the app, what they reported and what I changed. The decision usually arrives by email in 2 to 3 days. Then Test and release › Production › Create new release › Add from library (or upload a newer bundle), release notes, countries, then Publishing overview › Send changes for review. Organization accounts and older personal accounts create the production release directly.
COMMON ERRORS (use these fixes)
- "bash: eas: command not found": use npx eas-cli@latest.
- The Play app opens but nothing loads: the backend is private, unpublished or on the free plan's expired deployment, or EXPO_PUBLIC_DOMAIN in eas.json is missing or points at replit.dev. Publish with Public access and set the published host name, then build again.
- "Use pnpm instead" when installing on my own computer: run pnpm install, not npm install.
- "Version code N has already been used": run npx eas-cli@latest build:version:set with the highest code on Google Play, then build again.
- "APKs are not allowed for this application": remove "buildType": "apk" from build.production in eas.json and build with --profile production.
- Sign-in does not start in the Play version: EXPO_PUBLIC_CLERK_PUBLISHABLE_KEY (pk_live) is missing from eas.json.
- "Only releases with status draft may be created on draft app": set "releaseStatus": "draft" or upload the first build by hand.
- Play Console says the app must target API level 36: upgrade to Expo SDK 54 or newer.
- Google sign-in fails only in the Play version (DEVELOPER_ERROR): add the Play app signing fingerprints.
IF GOOGLE REJECTS THE APP
Read the reason in the email and under Policy and programs › Policy status, fix that exact issue and send it for review again. Common causes: a missing privacy policy, no way to delete an account, Data safety answers that leave out a service, digital goods sold without Google Play billing, a backend that was offline during review, a reviewer who could not sign in, and too little tester activity. Backend fixes go live on Republish; app fixes need a new EAS build.
Start now by asking me the START HERE questions, unless I have already given my answers or my step.Keep these out of the chat
Never paste passwords, card numbers, ID details, your keystore, credentials.json, Replit secrets, Expo tokens or service account files into an AI chat. The prompt tells your AI not to ask for them.
Sources
Checked against Replit's, Expo's and Google Play's own pages on 5 and 10 October 2026. Images marked "Based on an Expo docs screenshot" are adapted from Expo's documentation, Copyright (c) 2017 650 Industries, Inc., used under the MIT License.
- Replit docs: building mobile apps
- Replit docs: publish your app
- Replit docs: private deployments
- Replit docs: Clerk authentication
- Expo docs: create your first build
- Expo docs: submit to the Google Play Store
- Expo docs: app version management
- Android developers: target API level requirements
- Play Console Help: use Play App Signing
- Play Console Help: app testing requirements for new personal developer accounts
- Play Console Help: set up an open, closed or internal test