Skip to content
Unbase44

Base44 to the App Store: how mobile builds work and where they stop

Base44 can package your app for the App Store and Google Play. What you ship is a native wrapper around your published web app: quick to produce, and updated instantly when you publish, but with real limits. Here is how it works, what reviewers look for, and what owning the code changes.

Updated 8 min readBy the Unbase44 team

On this page

How Base44’s mobile builds work

Base44’s app store guide describes the model plainly: your mobile app runs your published Base44 app inside a secure web view, a lightweight native wrapper that opens only your app’s address.

From the editor you can:

  • Scan your app against Apple and Google guidelines and get a readiness score (available on the Free plan).
  • Improve flagged problems with the AI chat and scan again.
  • Generate the store files for the App Store and Google Play, which requires the Builder plan or higher.
  • Add push notifications when you generate the files, using an Apple push key and a Firebase project, and send them from your backend with Base44’s push notification integration (about one integration credit per notification).

Because the wrapper loads your live app, most content and design changes appear on phones as soon as you publish, without a store review. You only submit a new build when the app shell changes: its name, icon, identifiers, push notifications or new device permissions.

Even without the stores, Base44 apps work in any mobile browser, and people can add them to their home screen, where they open like an app (Creating and using your app on mobile).

APK, AAB and the Play Store

For Android, Base44 generates an AAB (Android App Bundle), not an APK. For iPhone it generates an IPA. Both downloads need the Builder plan or higher.

The AAB is the format Google Play asks for: new apps have had to publish with App Bundles since August 2021, and Play turns the bundle into the APKs each device downloads (Android developers). You don’t need an APK to reach Play Store users.

An AAB can’t be installed on a phone directly, though. If you want an APK to try the app on your own device or hand to a tester:

  • Use Play’s internal testing track. Upload the AAB and it reaches up to 100 testers within minutes, and internal tests may skip Play’s standard reviews (Google Play Console help). This is the simplest route, and testers get the same build your public release will use.
  • Convert it with bundletool. Google’s bundletool builds APKs from an app bundle, including a single “universal” APK, and installs them on a connected device. It’s a developer’s tool, and an APK you sign yourself this way isn’t the copy Play distributes, so keep it for testing.

Three Android details from Base44’s store guide are worth knowing before you create the listing: the package name is fixed as com.base followed by your app ID and .app; if your app has Google sign-in, you add Play’s app-signing SHA-256 fingerprint in Base44; and if Play Console asks you to prove you own the package name, you paste Google’s snippet into Base44, which rebuilds the files.

What the wrapper can’t do yet

Base44 is open about the current limits:

  • No in-app purchases. Apple and Google insist that digital goods sold inside an app, such as subscriptions, premium features or credits, go through their own payment systems. Base44 doesn’t support StoreKit or Google Play Billing yet, and warns that an app selling digital content through Stripe will be rejected. The suggested workaround is to sell on the web and have the app check who has paid, without any payment flow inside the app. Base44 also notes that third-party plugins such as RevenueCat or Capacitor purchase plugins need native access its apps don’t expose, so they don’t work.
  • No HealthKit, and no full offline mode.
  • A fixed start page. The app opens at the entry point Base44 chooses from your published app; you can’t pick a different start page for mobile.
  • Fixed identifiers. Base44 sets the bundle ID and signing key in the generated files, and they can’t be changed. If you’ve published a native app for the same brand before, the stores may block the update, and Base44’s advice is to create a new store listing.
  • Google sign-in needs an extra step. You add Google Play’s app-signing fingerprint to Base44 so Google login works in the installed app.

For many apps, like internal tools, community apps or companion apps to a web service, none of this matters. For consumer apps that charge for features on the phone, the in-app purchase gap is decisive.

Store basics, whatever you build with

These apply to every app, however it’s made:

  • Apple Developer Program: $99 a year, in your name or your company’s.
  • Google Play Console: a one-time $25 registration fee.
  • New personal Google Play accounts need 12 or more testers opted in to a closed test for 14 days in a row before they can apply for production access (Google’s testing requirements). Plan for those two weeks.
  • Apple’s minimum functionality rule (guideline 4.2): an app that is only a website in a frame can be rejected. Show that the app is useful as an app: push notifications, a proper sign-in, and screens designed for a phone help.
  • Account deletion: if people can create an account in your app, Apple requires that they can also delete it from within the app.
  • Review access: give reviewers a working demo account, and make sure your privacy policy and terms are reachable before sign-in.

Other routes onto a phone

A PWA: no store at all

A progressive web app is a website that a phone can install. Base44 generates the web app manifest for you from your app’s name, description and icon, so people can use Add to Home Screen and get your icon and a full-screen app (Creating and using your app on mobile). There’s no developer account, no review and no store fee, and every publish reaches everyone at once.

What a PWA doesn’t get is a store listing, and with it the discovery and trust that come from being in the App Store or Google Play. Offline use depends on a service worker, which is optional for installation (MDN), and Base44’s documentation doesn’t describe offline support for the web version. For an internal tool, a client portal or an early product, a PWA is often all you need.

Capacitor, PWABuilder and Trusted Web Activities

Base44’s own mobile page names three third-party tools for wrapping your app’s address or its exported code yourself: Capacitor, PWABuilder and Trusted Web Activities. It also notes that these are managed outside Base44, that native features such as push notifications have to be set up separately, and that exporting the code needs the Builder plan or higher.

  • Capacitor turns a web app into native iOS and Android projects you build and sign yourself (Capacitor docs). It’s the most flexible of the three, and the one the next section describes.
  • PWABuilder packages progressive web apps for app stores (PWABuilder on GitHub).
  • A Trusted Web Activity opens your web app full screen inside an Android app. The app and the site must be shown to come from the same developer, which is verified with a Digital Asset Links file on your domain (Chrome developers), so you need to be able to publish that file at your address.

Each of these wraps the same app, still running on Base44’s backend. They change how the app reaches the phone, not where it runs.

A separate React Native app

Base44 also documents building a mobile app with React Native (Expo) against its backend service, using the same SDK (React Native quickstart). That’s a second app a developer writes against a Base44 backend, rather than a wrapper around the one you have.

What owning the code changes

When your app’s code and backend are yours, the wrapper stops being a fixed product and becomes a choice. A common setup is Capacitor, which packages a React app as a native iOS and Android project you control:

  • In-app purchases through StoreKit and Google Play Billing, directly or via a service such as RevenueCat, with your own backend verifying each purchase.
  • Native features: push notifications, deep links, biometrics, camera and file access, background tasks, and HealthKit if you need it.
  • Your own identifiers and signing, so you can keep an existing store listing.
  • Offline behaviour that you design, such as caching the screens and data that matter.
  • Your own release rhythm, from your repository.

The cost is the pipeline: building an iOS app needs Xcode on a Mac or a cloud build service, and store submissions become your job. A developer, or a coding agent working on your repository, can set it up once.

Unbase44 and mobile

A migrated app is the same web app, now served from your own domain and hosting. Anything that loaded your Base44 app in a browser, including a home-screen shortcut, works the same way pointed at the new address.

Because the code and the backend are yours, a developer or a coding agent can also wrap the app with Capacitor, as described above, and publish it under your own store accounts.

Coming soon to your Unbase44 page: one click to build the Android app, and iPhone builds uploaded to TestFlight from a cloud Mac, with no Mac of your own.

In-app purchases for digital goods still need StoreKit or Google Play Billing, which your developer (or coding agent) adds in your own repository.

Questions and answers

Can a Base44 app be published on the App Store?

Yes. Base44 packages your published app in a native wrapper and generates the files for the App Store and Google Play. Downloading those files requires the Builder plan or higher, and you need your own Apple and Google developer accounts.

Why was my Base44 app rejected by the App Store?

Two causes are documented. Apple’s minimum functionality rule (guideline 4.2) can reject an app that is only a website in a frame. And an app that sells digital goods, such as subscriptions or premium features, through Stripe instead of Apple’s in-app purchase will be rejected, which Base44 warns about because its apps don’t support StoreKit yet. Before you resubmit, run Base44’s readiness scan against Apple’s guidelines, fix what it flags, and show that the app is useful as an app: push notifications, a proper sign-in and screens designed for a phone help.

Can my Base44 app charge for subscriptions inside the mobile app?

Not yet. Digital goods sold inside a mobile app must go through Apple’s and Google’s own payment systems, and Base44 doesn’t support StoreKit or Google Play Billing so far. The documented workaround is selling on the web and unlocking content in the app for paying users.

Does Base44’s mobile app support push notifications?

Yes. You enable them when you generate the store files, upload an Apple push key and Firebase credentials, and send notifications from your backend. Existing installs get push only after you submit an updated build.

Can I get an APK of my Base44 app?

Not directly. Base44 generates an AAB, the format Google Play requires for new apps, and Play produces the APKs each phone downloads. To test on a device, use Play’s internal testing track, or have a developer turn the bundle into an APK with Google’s bundletool.

Is a Base44 app a PWA?

It can be installed like one. Base44 generates the web app manifest for your app, so people can add it to their home screen from the browser and open it full screen, with no store involved. Base44 doesn’t document offline support for the web version.

Do I need a Mac to publish an iPhone app?

Not with Base44’s generated files. If you build the native app yourself from your own code, you need Xcode on a Mac or a cloud build service that provides one.

Sources

Checked on November 10, 2026. Base44 changes quickly; if something here is out of date, tell us.