Skip to content
Tosin Peter

HomeBlog

Publish a Lovable app to the App Store and Google Play

Lovable builds web apps, not native ones. How to wrap yours with Capacitor, pass Apple and Google review, and avoid the rejections that catch most founders.

Tosin Peter11 min read

  • Lovable
  • App Store
  • iOS
  • Android

You can publish a Lovable app to the App Store and Google Play, but not from inside Lovable. Lovable builds web apps. To get one into the stores, you wrap it in a native shell (usually Capacitor), build it in Xcode and Android Studio, and submit it from your own developer accounts. The wrapping takes an afternoon. Getting through review is where most founders lose weeks.

This guide covers both: the build steps, and the review problems I’d fix before you submit, not after the first rejection.

Can Lovable make a mobile app?

Not a native one. Lovable’s own FAQ says it builds web applications and doesn’t generate React Native projects. It gives two options: make your app a Progressive Web App (PWA) that people add to their home screen, or wrap your published app with a tool such as Capacitor, outside Lovable, and submit that to the stores.

Don’t confuse this with the Lovable mobile app that launched in April 2026. That’s an app for building with Lovable from your phone. It doesn’t turn your project into a store app.

So the real choice is between three routes:

Route Time to the stores Works for Main risk
PWA (no store) Same day Internal tools, early testing Not in the App Store, limited iOS features
Capacitor wrapper Days to a couple of weeks Most Lovable apps with real users Apple’s “repackaged website” rejection
Native rebuild (Expo, Flutter) Weeks to months Apps where mobile is the product Cost, and a second codebase

For most founders with a working Lovable app, Capacitor is the right first step. It keeps one codebase and Lovable keeps working on the web version.

What you need before you start

  • An Apple Developer Program membership ($99 a year) and a Google Play developer account ($25 one-off). Enrol as your company if you have one, not as an individual. More on why below.
  • A Mac with Xcode 26 or later. Since 28 April 2026, Apple only accepts uploads built with Xcode 26 and the iOS 26 SDK. Capacitor 8 needs Xcode 26 as well.
  • Android Studio (2025.2.1 or later for Capacitor 8) and Node.js 22+.
  • Your Lovable project synced to GitHub, so you can work on the code locally.
  • A real iPhone and a real Android phone to test on. Simulators hide the bugs reviewers find.

If you’re on a personal Google Play account created after 13 November 2023, add two weeks to your plan now. Google requires a closed test with at least 12 testers, opted in for 14 days in a row, before you can apply for production. Start recruiting testers the day you start this project.

How to wrap a Lovable app with Capacitor

1. Get the code locally

Connect the project to GitHub in Lovable, clone the repo and run it:

git clone https://github.com/you/your-lovable-app.git
cd your-lovable-app
npm install
npm run build

Check what npm run build produces. Older Lovable projects are Vite single-page apps and build into dist/. Projects created since May 2026 use TanStack Start with server rendering, which a phone can’t run. For those, switch on TanStack Start’s SPA mode so the build produces a static shell, and move anything that runs as a server function behind an API on your deployed site. This is the step most wrapper guides skip, because they were written for the old stack.

2. Add Capacitor

npm i @capacitor/core
npm i -D @capacitor/cli
npx cap init

cap init asks for an app name and an app ID. The app ID is a reverse-domain bundle identifier like com.yourcompany.yourapp. Choose carefully: you can’t change it after the app is in the stores.

Then point Capacitor at your build folder in capacitor.config.ts:

import type { CapacitorConfig } from "@capacitor/cli";

const config: CapacitorConfig = {
  appId: "com.yourcompany.yourapp",
  appName: "Your App",
  webDir: "dist",
};

export default config;

3. Bundle the build. Don’t just load your URL

Many guides, and Lovable’s FAQ, describe wrapping your published URL: you set server.url to https://yourapp.lovable.app and the app is a browser window onto your site. It’s fast, and it’s the version Apple rejects most.

Capacitor’s own docs say server.url is meant for live reload during development, not for production. A remote-URL app also shows a white screen with no signal, and every reviewer sees exactly what they’d see in Safari. Bundle the built files into the app instead, and let them call your Supabase backend over the network.

4. Add the platforms and open them

npm i @capacitor/android @capacitor/ios
npx cap add android
npx cap add ios
npm run build && npx cap sync
npx cap open ios

Run npm run build && npx cap sync every time you change the web code. Then build and run on your devices from Xcode and Android Studio.

5. Fix what breaks on a phone

These are the things that work on the web and break once wrapped:

  • Google sign-in. Google blocks OAuth sign-in inside embedded web views with a disallowed_useragent error. Open the sign-in in the system browser (Capacitor’s Browser plugin or a native sign-in plugin) and return to the app through a deep link. Add that deep link to Supabase’s Redirect URLs too.
  • Email links. Confirmation and password-reset emails open the website, not the app. Either accept that, or set up universal links (iOS) and app links (Android).
  • Payments. Stripe checkout for digital features won’t pass Apple review in most countries. See below.
  • Safe areas and the keyboard. Content under the notch, inputs hidden by the keyboard and a bounce on scroll all make the app feel like a website. Reviewers notice.
  • Permissions. If you use the camera, photos or location, add a clear purpose string in Info.plist. A missing one crashes the app the moment the feature is used.

Why Apple rejects Lovable apps (and how to avoid it)

Guideline 4.2: “repackaged website”

This is the big one. Apple’s guideline 4.2 says an app must offer features and an interface that lift it beyond a repackaged website. If the reviewer can’t tell your app from your site, it’s rejected.

What helps, roughly in order:

  1. Bundle the code (step 3 above) and make the app work, or at least fail gracefully, offline.
  2. Use the phone. Push notifications, camera or photo upload, biometric login, haptics, a home-screen widget, share sheet. One or two that fit the product are enough. Don’t bolt on features nobody uses.
  3. Look like an app. A bottom tab bar instead of a website header and hamburger menu. No cookie banners, no web footer, no links that open your marketing pages.
  4. Explain it in the review notes. Tell the reviewer which native features to try and where. They spend minutes on your app, not hours.

Guideline 4.2.6: apps made with app generators

Apple rejects apps created from a commercial template or app-generation service unless the content’s owner submits them. Submit from your own developer account, enrolled as your business, with you as the Account Holder. Don’t let a freelancer publish it under theirs. You’ll also need it to be yours when you sell the company or change developers.

Guideline 3.1.1: in-app purchase

If people pay for digital features or content inside the iPhone app, Apple requires in-app purchase. Your Lovable app’s Stripe checkout doesn’t count. The usual fix is RevenueCat, which works in Capacitor and handles both stores. If you’ve already been rejected over purchases that won’t load, my guide to Guideline 2.1(b) and in-app purchases covers that.

One exception changed recently: on the US storefront, Apple’s current guidelines let apps include buttons and links to pay on the web without a special entitlement. Outside the US, those links are still restricted. If you sell worldwide, plan for in-app purchase.

Guideline 4.8: Sign in with Apple

If you offer Google sign-in for the main account, Apple requires an equivalent option that limits data to name and email and lets users hide their email. In practice that’s Sign in with Apple. Supabase supports it.

Guideline 5.1.1(v): account deletion

If users can create an account in the app, they must be able to delete it in the app. A “contact us” email isn’t enough. This needs a real backend function that deletes the user and their data, not just a button.

Guideline 2.1: a demo account that works

If the app has a login, give the reviewer a demo account and make sure the backend is live during review. A paused Supabase project or an expired test account means an instant rejection.

Publishing the Android version on Google Play

Google Play is more forgiving about wrappers, but it isn’t a free pass. Google has long removed apps that are just a web view of an existing website, and it asks the same question Apple does: what can people do in the app that they can’t do on the site?

The practical steps:

  1. Target the right API level. Since 31 August 2026, new apps and updates must target Android 16 (API level 36) or higher.
  2. Build a signed release bundle (.aab) in Android Studio, and keep the upload key safe. Losing it is painful.
  3. Run the closed test if your account needs it: 12 testers, 14 days in a row. Testers who drop out don’t count, and opting back in restarts their clock. Google also says it may ask you to keep testing if engagement was too low, so give testers real tasks, not just an install link.
  4. Apply for production from the dashboard. You’ll answer questions about the test, your audience and what you changed. Google says review usually takes seven days or less.
  5. Complete the store listing: data safety form, content rating, privacy policy URL, screenshots from the real app.

Your pre-submission checklist

Run through this before you press Submit:

  • Built with Xcode 26+ (iOS) and targeting API 36+ (Android)
  • Web code bundled into the app, not loaded from server.url
  • Works on a real iPhone and Android phone, including a slow connection
  • At least one or two native features that make sense for the product
  • Google sign-in opens in the system browser; Sign in with Apple offered alongside it
  • In-app account deletion that really deletes the data
  • Digital purchases go through in-app purchase (or you’ve checked the storefront rules)
  • Demo account in the review notes, backend live
  • Privacy policy URL, App Privacy answers and Play data safety form match what the app collects
  • Supabase row-level security checked on every table (a store launch brings traffic and attention)
  • Published from your own company developer accounts

That last security point matters more than it sounds. In September 2026, UpGuard reported more than 16,000 Supabase databases with publicly readable tables. An app store listing puts your app in front of far more people than a link on X. If you haven’t checked yours, my post on common Lovable app issues shows how to test it in five minutes.

When to bring in a developer

You can do all of this yourself if you’re comfortable in Xcode and a terminal. The places where founders usually get stuck, and where an hour of expert time saves a week, are:

  • A TanStack Start project that needs SPA mode and its server functions moved out
  • Google or Apple sign-in that loops back to the website instead of the app
  • In-app purchases with RevenueCat alongside an existing Stripe web subscription
  • A second or third 4.2 rejection, where the fix is product and design, not more code

If that’s where you are, I take Lovable apps to production, including wrapping them for iOS and Android and getting them through review. You can also tell me about your app and I’ll tell you whether a wrapper will pass or whether you need a native build.

FAQ

Can I publish a Lovable app to the App Store?

Yes, but not directly from Lovable. You export the code through GitHub, wrap it with Capacitor, build it in Xcode on a Mac and submit it from your own Apple developer account. Expect Apple to check that it’s more than a repackaged website.

How long does it take to get a Lovable app on the App Store?

The wrapping can take a day or two. Apple’s review itself is often quick, but a rejection adds days each time. On Google Play, a new personal account adds at least 14 days for the required closed test.

Will Apple reject a Lovable app wrapped in a web view?

It can, under guideline 4.2, if the app looks and behaves like your website. Bundling the code, adding native features that fit the product and an app-like interface make approval far more likely. There’s no guarantee either way.

Should I use a PWA instead?

A PWA is fine for testing with early users or for internal tools. It can’t be found in the App Store, and installation on iPhone is a manual “Add to Home Screen” step most users never take. If people will look for you in the stores, you need a store app.

Do I need to rebuild my Lovable app in React Native or Flutter?

Usually not for a first store release. A well-built Capacitor app passes review and serves most products. A native rebuild is worth it when the mobile experience is the product, or you need heavy offline use, complex animations or deep hardware access.

Further reading

Building something like this?

Tell me about it and let's see if I can help.

Work with me

More posts