Base44 Mobile Native Features: How to Get GPS/HealthKit...

Your app works in the phone's browser. Then you built the store version in Base44, installed it, and the feature your app is built around doesn't work. The run tracker stops tracking the moment the screen locks. Apple rejects the build over HealthKit. The receipt camera works on the web and not in the Play Store version. The links people share open in Safari instead of the app. You ask the AI, it spends your credits and tells you it's a platform limitation, and support tells you to submit a feature request. I've seen this happen to a lot of people, and almost always when the app is 90% done.

Base44's app is your website inside a shell you can't touch

What Base44 puts in the stores isn't really your app. It's a small native app that opens your published Base44 site inside it, with no address bar. People call it the wrapper, and so does Base44. In there your app does what a website does on a phone: it shows your pages, asks for the location while it's open, takes photo uploads.

The things people actually get stuck on aren't website things. Tracking with the screen off, reading HealthKit, tapping an NFC tag, a widget on the home screen: each one needs native code inside the app itself, plus a line or two of settings that tell Apple and Google what the app does with it. The normal way to add that code to an app like this is a plugin, a small open-source package that hands one phone feature to your pages. The standard shell for apps built from a website is called Capacitor, and there's a plugin for almost every feature people ask Base44 for.

Base44's wrapper takes no plugins. It's the same shell for every Base44 app on every plan. Base44 builds it and signs it, and you can't add anything to it or change its settings (Apple's own error messages call it “WixOneApp”). Ask the AI for a plugin and at best it writes native code that just sits in your project doing nothing. Ask support and it's “platform-level”. Base44's mobile team said in August that they aren't working on background GPS and can't promise to match what Capacitor does.

Each feature is a plugin and a setting, and Base44's shell takes neither

Here's every native feature people ask for, what Base44's app does with it today, and what it takes on a normal app.

The usual workarounds keep your app on Base44, or rebuild it

When people find out their Base44 app can't use the native feature it needs, they usually try one of four things.

1. Wait for Base44. Every one of these native features has been sitting as a feature request under “review” on Base44's feedback board for months, some for over a year, and the AI can't do anything about the shell in the meantime. If your app needs one of the features above to be the app it is, waiting isn't a plan.
2. Pay a wrapper service. Despia, AppNative, CapWrapper, Median, Natively and others put their own shell around your Base44 site, and the bigger ones do have background GPS, HealthKit, widgets and Face ID. What you've actually done is swap Base44's shell for theirs. It's another shell you can't touch, with its own limits (one of them caps push at 100 notifications on its cheapest plan) and its own list of what you're allowed to use. And now you're on two platforms instead of one: Base44 still runs your app, its backend and its login, the wrapper company runs the phone part, and you pay both. Despia even tells you to replace Base44's login with one of your own.

3. Wrap it yourself with Capacitor. This is what Base44's own community moderators tell everyone to do, and the native part really does work: people have shipped apps this way. You become the developer of the shell (Xcode, Android Studio, signing, a Mac for the iPhone build), which can be doable if you're technical enough.

   The wall is that the app is still Base44's. The code is served by Base44, the backend and the login run on Base44's servers, and your shell is wrapped around something you don't control. So you end up choosing: point the shell at your live Base44 site and the plugins don't work (the pages Base44 serves don't know your shell exists), or bundle the exported code into the app and the login breaks (Base44's sign-in only comes back to Base44's own address). Either way, the half you don't own decides. Fine for an app with no login. Everyone else spends weeks on this and most never get the login working.

4. Rebuild it as a native app. React Native, Flutter or Swift, or what ChatGPT usually suggests: a separate native app that uses Base44 as its backend. That's your whole app written again from scratch. People get quoted “$5K or up” for it, and with Base44 as the backend you're still on Base44, with its login and its bill.

Make your Base44 app a normal app, and every feature opens up

Look at that list again: background GPS, HealthKit, NFC, Bluetooth, the scanner, Face ID, links, the splash screen. Every one of them comes down to the same thing: the shell your app runs in isn't yours. On a normal app the shell belongs to the app's owner, so each item on that list is a plugin and a setting, added to the app you already have and shipped in the next build. Nobody rebuilds an app to give it HealthKit.

The hard part is getting a Base44 app to that point. Base44's export gives you the code, but not your data and not the backend it runs on, and that backend is where your login lives. That's exactly why the do-it-yourself wrap gets stuck on sign-in.

This is why I built EscapeBase44. I hit the same wall on my own app: I couldn't install the libraries I needed, and every time I tried to go a little beyond the basics there was baked-in code Base44 wouldn't let me change. So I reverse-engineered Base44's entire backend until I could get my app out as it was, and then automated the whole move.

EscapeBase44 takes your Base44 app exactly as it is and turns it into a normal app on normal providers, under your own accounts: every screen, every record, every user with their password, your backend functions, all of it. Nothing gets rebuilt. And it gives the app its own native shell:

• The standard Capacitor shell, in your own code. Any plugin can go into it, and the phone settings each plugin needs are kept with your code, so every build carries them.
• Store builds with one click, no Mac. The iPhone build lands in your TestFlight, and the Android build is a signed file ready for Google Play.
• The browser things just work in the app. Location, the camera, the microphone, photo uploads, downloads, sharing and printing, on both phones.
• Push, Sign in with Apple and in-app purchases are already in. Push runs on your own keys, Apple sign-in opens Apple's own sheet, and purchases go through Apple and Google.
• Your splash screen, your rotation, your status bar.
• Keep building with AI, just like you did on Base44. Ask for HealthKit the way you'd ask for a new page, and the AI adds the plugin and its settings; the next store build has it. Changes to your pages reach the installed app right away, and only native changes need a new build.

That's the whole difference. On Base44, the feature your app is about waits on a shell that isn't yours. On a normal app, it's a plugin and a setting away, and you add it the same way you added everything else.

Base44 native features FAQ

• Can a Base44 app use HealthKit?

  No. Base44's iPhone app has no way to read Apple Health, and its builds carry a HealthKit entitlement without the text Apple requires, which gets apps rejected. On a normal app, HealthKit and Android's Health Connect are one plugin plus their permission texts.

• Can a Base44 app track GPS in the background?

  No. It gets the location only while the app is open on the screen, the way a website does, and stops when the screen locks. Background tracking needs a native plugin and a background setting, which Base44's wrapper doesn't take.

• Can I add Capacitor plugins to my Base44 app?

  Not to the app Base44 builds. Its wrapper is the same shell for every app and takes no plugins or settings, so plugin code the AI writes just sits in your project doing nothing.

• Can I wrap my Base44 app with Capacitor myself?

  Yes, and the native part works. What stops most people is sign-in: Base44 runs your login, and it doesn't come back into an app it doesn't recognize, so you end up choosing between working login and working plugins.

• Does a Base44 app have push notifications?

  Yes, since August 2026. You upload your Apple key and Firebase file, and your backend functions send them, at about one integration credit per notification.

• Can a Base44 app use NFC?

  No. Web NFC only exists in Chrome on Android and not inside an app, and iPhone has none at all. NFC needs a native plugin and Apple's NFC permission.

• Is a wrapper service like Despia or Median enough?

  For a feature on their list, it works. You pay them on top of your Base44 plan, you get only the features they built, and your app, its backend and its login stay on Base44.

• Do I have to rebuild my app to get native features?

  No. Once your Base44 app is a normal app with its own native shell, each feature is a plugin and a setting added to the app you already have.

• Can I still build my app with AI after it moves?

  Yes, just like on Base44. You ask for a feature in the chat, and for a native one the AI adds the plugin and its phone settings, which the next store build carries.