How to turn a Replit app into an APK, iOS app, or Android app

You can turn a Replit app into an APK or a store-ready mobile app without moving its backend, and you have two ways to do it. Replit Agent builds native mobile apps with React Native and Expo, and eligible JavaScript projects can add one alongside an existing web app.

A new mobile front end isn't always what you need, though. If your Replit website already works well on a mobile device, you can use Median.co to convert your website to an app, and package your Replit site as an iOS and Android app without rebuilding any of your UI. Your full Replit frontend, backend, and database work without modifications except as required to integrate native features like transactional push notifications.

The real decision is what you want to maintain: separate mobile screens, or the one web interface you already have.

Try it for free

Build a mobile app from your Replit URL

Build now

What Replit's mobile builder does

Replit's mobile app documentation calls the mobile part of a project a Mobile app artifact. It's built with React Native and Expo, which means it has its own mobile screens rather than loading your website in a web view.

You can preview the app in Replit's iOS simulator, an Android emulator, or Expo Go, and when it's time to ship, Replit walks you through TestFlight and the Apple App Store without ever making you install Xcode on a Mac.

Two limits matter before you start. Replit doesn't yet guide you through Google Play publishing, so you'll create and submit the Android release yourself. And Expo Go can't run every custom native module, so if your app depends on one, test with a development build instead.

Some older JavaScript projects can be moved to Replit's multi-artifact project structure. Replit says the migration can preserve the deployed URL, database, and secrets, though Agent may reorganize the project along the way and not every older project is eligible.

When Replit's mobile builder is a good fit

Build the mobile app in Replit if you want:

• A React Native interface designed separately from the website

• Mobile-specific navigation and screen layouts

• Native modules that do not work well with a web interface

• Web and mobile code in the same Replit project

• Replit's guided TestFlight and App Store process

That control has a standing cost. A change to a web screen doesn't automatically update the matching React Native screen, so from the first build onward your team owns two versions of the interface.

When Median.co is a better fit for an existing Replit web app

Median.co is the better fit when:

• The deployed Replit app already works well on phones.

• You want the installed app to show the same interface as the website.

• Website changes should reach the app without a rebuild.

• You need push notifications, biometrics, haptics, deep links, or other native plugins.

• You want help publishing to both Apple and Google.

A Median app wraps the deployed website in an iOS and Android shell. Changes to the website show up the next time the app loads them, while changes to the app icon, permissions, or native plugins still need a new build of the shell itself.

Maintenance decides this more often than features do. If the Replit interface changes every week, keeping a second set of React Native screens in sync will cost more time than building the app did.

What happens to the Replit backend and database?

You keep the existing Replit backend either way. A Replit mobile app can call the same API and use the project's shared database and secrets. A Median app loads the deployed website, so every API call and database connection works exactly as it does in the browser.

Authentication deserves careful testing whichever way you go. A web view may store cookies differently from Safari or Chrome, and a React Native app may need its own token storage. Test account creation, sign-in, password resets, and session expiry on real devices before you submit.

How to turn a deployed Replit website into an app with Median.co

You build the app from the deployed URL alone, so the whole web to app conversion happens without exporting anything from Replit.

1. Use a production deployment

Point the mobile app at a stable HTTPS deployment, not an editor preview or a temporary development URL.

Then open the deployed site on a small iPhone and an Android phone, and fix anything that would embarrass you in an installed app: horizontal scrolling, hover-only controls, keyboard overlap, tap targets that need a stylus.

2. Add the URL to the Median App Studio

Open the Median App Studio, enter the Replit URL, and set the app name. The Replit setup documentation explains how to add the Median JavaScript Bridge for the moments when the website needs to call a native function.

3. Set up the app shell

Add the icon, splash screen, loading screen, colors, navigation, link handling, and permissions, then layer in the native features your app actually needs: push notifications, biometrics, haptics, camera access, deep links, or an analytics SDK.

Only request a permission the user can connect to a feature. A photo editor has an obvious reason to ask for photo access. A budgeting app usually doesn't.

4. Test the installed app

The browser simulator is good for layout checks and nothing else. It can't prove that sign-in, notifications, purchases, or device permissions work, so test those on an iPhone and an Android phone:

• Account creation, sign-in, password reset, and logout

• Google, Apple, or other OAuth redirects

• Database reads and writes

• File uploads and downloads

• Camera, microphone, location, and photo access

• External links and links back into the app

• Push registration and notification taps

• Subscription purchases and restores

• Slow connections and offline messages

• Android's back button and iOS safe areas

If the app hangs on the loading screen, look at authentication redirects and third-party cookies before you start changing the backend.

5. Create the store builds

Wait until the deployment and app settings are stable, then create the signed iOS and Android builds. Your team can submit them, or Median.co's Publishing Service can handle the submissions and the review questions that come back.

How to add a mobile app to an existing Replit project

Replit's project migration documentation explains how eligible JavaScript web projects can add a Mobile app artifact with Agent.

Before you let Agent reorganize an existing production project:

1. Confirm that you can recover the current deployment, database, and secrets.

2. Tell Agent to preserve the existing web app while adding the mobile app.

3. Decide which business logic can be shared and which screens need a React Native version.

4. Test API calls and authentication from the mobile app.

5. Use a development build if Expo Go cannot run a required native module.

6. Set aside time for a manual Google Play submission.

You don't need any of this just to put a responsive Replit website in the app stores. The migration earns its keep when you genuinely want a separate React Native interface and are prepared to maintain it.

Replit to APK, AAB, and IPA

An APK installs an Android app directly on a phone, which makes it the right format for testing or for sharing a private build with a few people. Google Play expects something different for a new public release: an Android App Bundle, or AAB, which Google uses to generate APKs for each kind of device.

An IPA is the signed iOS equivalent, and it's what gets delivered to App Store Connect. Having a Replit IPA doesn't mean the app is published, though. You still need an Apple Developer account, an App Store Connect record, store information, testing, and review.

That's the practical difference between Replit to APK and Replit to app store. The APK proves the app runs on a phone, and the store release needs an AAB or IPA plus each store's review.

How to publish a Replit app to the Apple App Store

Replit's guided iOS launch covers Mobile app artifacts. For a Median app, you upload the iOS build through cloud tooling, or Median.co's Publishing Service handles the whole submission for you. Either way, once cloud signing is set up you never have to run Xcode locally.

In App Store Connect:

• Create the app record and use the same bundle ID as the build.

• Upload the build and test it through TestFlight.

• Add screenshots, a description, a support URL, and a privacy policy.

• Complete the App Privacy questions.

• Give the reviewer a working demo account.

• Check account deletion and in-app purchases when the app needs them.

If the app is already live, keep the existing bundle ID and signing ownership. A different bundle ID creates a brand-new app instead of updating the one you have.

How to publish a Replit app to Google Play

Replit currently leaves Google Play publishing to you. You create the Android build in Median.co, and its Publishing Service can take on the Play Console work as well.

Create the app in Play Console with the same package name as the build, then work through the store listing, the Data safety form, content declarations, app access instructions, the privacy policy, and Google's testing requirements. Upload the AAB to an internal testing track before promoting anything to production. Keep the APK for direct device testing and give Play Console the AAB.

Will Replit website updates appear in the mobile app?

If the app uses Median.co, yes. The installed app loads the deployed website, so the latest web interface is what people see the next time they open it. Only native-shell changes need a new build.

A Replit Mobile app artifact works the other way around. Web and mobile can share backend logic, but the React Native interface is separate, so changing a web screen does nothing to the matching mobile screen. Interface changes ship through a new store build.

Selling subscriptions in a Replit mobile app

Stripe stays fine for physical goods and real-world services. Digital subscriptions, credits, content, and app features are where Apple In-App Purchase and Google Play Billing usually become mandatory.

In a Median app, RevenueCat connects both store billing systems to the Replit website through the Median JavaScript Bridge. A Replit React Native app needs a billing library that works inside its native project and reports subscription status back to the shared backend. Either way, test a new purchase, a cancellation, a renewal, a restore, and an existing-customer sign-in before you submit.

Frequently asked questions

How do I convert a Replit app to a mobile app?

Use Replit's Mobile app artifact if you want to build a React Native interface, or use Median.co for a website to app conversion that keeps the screens you already have. Either way, plan for device testing and the app store submissions.

Can Replit make iOS apps?

Yes. Replit builds native mobile apps with React Native and Expo, and its guided launch process walks you through TestFlight and the Apple App Store. Some older JavaScript projects can add a Mobile app artifact through migration.

Can Replit make Android apps?

Yes. Replit Mobile app artifacts run on Android as well as iOS. Google Play publishing is currently manual, and you'll need a development build whenever Expo Go can't run a native module the app depends on.

Can I turn a Replit app into an APK?

Yes. You can build an Android test app from a Replit Mobile app artifact, or from a Median app that loads the deployed Replit website. For Google Play, upload an AAB rather than treating the APK as the finished submission.

Can Replit publish directly to the App Store?

Replit guides Mobile app artifacts through TestFlight and App Store publishing. An existing Replit website can't go straight to the store on its own. It first needs a Mobile app artifact, or a service such as Median.co to package it.

Can Replit publish directly to Google Play?

Replit can build the Android app, but its documentation currently leaves the Play Console submission to you. That still means signing, an AAB, a store listing, disclosures, testing, and review.

Do I need to export my Replit code for Median.co?

No. Median.co only needs the stable deployed HTTPS URL. Your Replit source, backend, database, and deployment process all stay in Replit.

Does my Replit database stay intact?

Yes, as long as the mobile app keeps using the same backend. Replit says an eligible project migration preserves the URL, database, and secrets, and a Median app simply uses the deployed website and its existing connections.

Should I use Replit or Median.co for the mobile app?

Use Replit when you want a separate React Native interface and can commit to maintaining it. Use Median.co when the responsive website already is the product and you want that same interface on the web, iOS, and Android.

Choose based on what you want to maintain

Replit's mobile builder makes sense when the app needs its own React Native interface and you're ready to keep it in sync with the website. Median.co makes sense when the deployed Replit website already is the product and you want that same experience in both app stores.

List the screens that genuinely need native controls or mobile-specific behavior. If the answer is nearly all of them, build the Mobile app artifact in Replit. If most of the site can stay as it is, drop the deployment URL into the form above and look at the result before you commit to anything bigger.