Skip to content
← All guides

App Store

How to get a Lovable app into the App Store: the real routes and the traps

By Jan Lipmann, appienceChecked against sources on 10 min read

Lovable does not build native iOS apps - its own FAQ says so and suggests wrapping your published URL with a tool such as Capacitor. Wrapping works, but this guide recommends bundling the built app instead of loading the live URL, and the review traps are mostly not about code: login inside a WebView, missing account deletion, in-app purchase rules and the minimum functionality guideline. Here is what each route involves and what to fix before you submit.

LovableCapacitorExpoApp Store

What you are seeing

You have a working Lovable app on the web, users are asking for an iPhone app, and you have found out that there is no "Publish to App Store" button. Or you already wrapped the app, and Google sign-in fails inside it, or App Review sent it back.

The starting point, from Lovable's FAQ: Lovable builds web apps, "does not generate React Native projects", and names two paths to an installable app: a Progressive Web App, or to "wrap your published URL with a tool such as Capacitor outside Lovable" and submit that to the App Store. Wrapping the published URL is the remote-URL variant (server.url), which Capacitor's own docs say is not intended for production - so this guide recommends bundling the built web app into the native project instead (route 1 below).

How to check it yourself

Before choosing a route, answer these - they decide most of the cost:

  1. Do you need the App Store at all? If users only want an icon on the home screen, a Progressive Web App gets you that without review, a developer account or a Mac.
  2. Does the app sell anything digital (subscriptions, credits, premium features)? Then Guideline 3.1.1 applies: features unlocked in the app must use in-app purchase. The United States storefront allows buttons and links to other purchase methods; elsewhere they need a StoreKit External Purchase Link Entitlement, available only in specific regions (3.1.1(a)). This one question can change your pricing model.
  3. How do users sign in? Google or another social login as the main option means you must also offer an equivalent login that meets 4.8 (Sign in with Apple qualifies), and Google blocks its OAuth flow inside embedded WebViews (Google Developers Blog).
  4. Can users create an account? Then they must be able to delete it in the app (5.1.1(v)).
  5. What would the iPhone app do that the website does not? If nothing, expect a Guideline 4.2 rejection - see our 4.2 guide.
  6. Who will be the seller? An individual developer account shows your personal legal name on the App Store. An organization account shows the company name and requires a legal entity with a D-U-N-S Number. The program costs 99 USD a year (Apple enrollment).

Why it happens

Lovable produces a React web app with a Supabase (PostgreSQL) backend. According to Lovable's FAQ, projects created from 2026-05-13 (2026-06-22 for Enterprise workspaces) use TanStack Start, which renders pages on the server; older projects use React with Vite and render in the browser. Either way it is a web app. The App Store distributes native binaries. Getting from one to the other means either putting the web app inside a native shell (a WebView) or rebuilding the interface in a native or cross-platform framework. Each route keeps your Supabase backend; they differ in how much of the front end you rewrite and how much review risk you carry.

Route 1: Capacitor wrapper (keep the Lovable code)

Capacitor packages your built web assets into an iOS project and gives JavaScript access to native features through plugins. Fastest route, and closest to what Lovable suggests - with one difference: Lovable's FAQ talks about wrapping the published URL, while this guide bundles the built files into the app (see the server.url warning below). You need a Mac: Capacitor 8 requires Xcode 26.0 or newer and Node.js 22 or newer (Capacitor environment setup). Review risk is highest here, because a wrapper that only shows the website is what 4.2 rejects.

Note: Capacitor needs a folder of built static files with an index.html at its root (Capacitor getting started). An older React + Vite Lovable project builds to dist and fits as is. A newer TanStack Start project renders on the server, so it needs a static build first - TanStack Start has an SPA mode for that (spa: { enabled: true }). In a Lovable project, vite.config.ts usually does not call the tanstackStart() plugin itself: it uses defineConfig from @lovable.dev/vite-tanstack-config, Lovable's Vite config wrapper, which forwards its tanstackStart key to the plugin - so the setting goes in as defineConfig({ tanstackStart: { spa: { enabled: true } } }). If your config does call tanstackStart() directly, put it in that call's options instead. By default SPA mode writes its HTML shell to /_shell.html, not index.html, so set spa.prerender.outputPath to /index.html (or rename the file after the build). Do not assume where the files land: the wrapper also runs Nitro on production builds (Cloudflare preset by default, nitro: false turns it off), and the output layout depends on that preset. After npm run build, find the folder that holds the generated index.html (for example find . -name index.html -not -path "./node_modules/*") and point Capacitor's webDir at it. Anything that runs as server code (server functions, server routes) has to move to an API the app calls, such as a Supabase Edge Function. Check this before estimating the work.

Route 2: React Native with Expo (rewrite the interface, keep the backend)

You rebuild the screens in React Native; data, auth and business logic in Supabase stay. More work up front, but the result is an app with native navigation and components, which removes most 4.2 risk. Expo's build and submit service runs in the cloud, and its docs say you do not need a Mac to ship iOS builds (Expo: submit to the App Store). Supabase documents deep-link auth for Expo (Native mobile deep linking).

Route 3: Native Swift app (rewrite the interface in SwiftUI)

The most work and the best fit for apps that lean on the device - camera pipelines, HealthKit, background audio, widgets, Apple Pay and Wallet passes. Supabase has a Swift client, so the backend can still stay. Worth it when the iPhone app is the product rather than a companion to the website.

Hosted wrapper services that turn a URL into an app are a variant of route 1, usually loading your live site from the web. They carry the same 4.2 risk, and Capacitor's documentation states that loading an external URL (server.url) "is not intended for use in production" (Capacitor config).

How to fix it

Wrapping a Lovable app with Capacitor, step by step

  1. Connect the Lovable project to GitHub (Git sync creates a new repository from the project) and clone it on a Mac.
  2. Make sure the web build produces static files with an index.html (see the note on TanStack Start above). Install Capacitor and initialise it; when asked for the web assets directory, give the build output folder that contains index.html - dist for a React + Vite project; for TanStack Start in SPA mode, the folder where your build put index.html.
  3. Add the iOS platform, build the web app and copy it into the native project.
  4. Open the project in Xcode, set the bundle identifier and signing team, and run it on a real iPhone.
  5. Fix what breaks on device: sign-in, links that open outside the app, file uploads, safe areas, offline behaviour.
  6. Archive, upload to App Store Connect, test through TestFlight, then submit for review.
npm i @capacitor/core
npm i -D @capacitor/cli
npx cap init            # app name, bundle id, web dir (dist for Vite, folder with index.html for TanStack SPA)
npm i @capacitor/ios
npx cap add ios
npm run build && npx cap sync
npx cap open ios
Commands from the Capacitor getting started guide. Run npm run build && npx cap sync again after every change to the web code.
Warning: Do not point server.url at your live site to skip rebuilding. Besides Capacitor's own warning, an app whose features change without a new build risks being read as breaking Guideline 2.5.2, which says apps may not download or execute code that "introduces or changes features or functionality of the app".

The traps that stop first submissions

  • Google sign-in inside the WebView: Google rejects OAuth requests from embedded WebViews with a disallowed_useragent error. Open the sign-in in the system browser and return to the app through a deep link, and add that link to Supabase's redirect URL allow list (Auth settings, Additional Redirect URLs).
  • Login options: if Google or another third-party login sets up the user's primary account, 4.8 requires an equivalent login option that limits data collection to name and email, lets users keep their email private and does not track them for advertising without consent. Sign in with Apple is the usual choice. Exceptions include apps that use only your own account system and education or enterprise apps that require an existing organisation account (4.8).
  • Account deletion: a visible, working "Delete account" in the app that actually deletes the account and its data (5.1.1(v)). Deleting a Supabase auth user needs a server-side call, so this means an Edge Function or a secured database function, not front-end code.
  • Payments: digital features unlocked in the app must use in-app purchase, and apps "may not use their own mechanisms" to unlock them (3.1.1) - so an embedded Stripe checkout for them is not allowed on any storefront. What the United States storefront allows is buttons, external links or other calls to action that send users to a purchase outside the app, such as a web checkout; in other storefronts that needs a StoreKit External Purchase Link Entitlement, available only in specific regions (3.1.1(a)). Plan in-app purchase or a different model before you submit.
  • Privacy: a privacy policy URL is required for every app, and the App Privacy answers in App Store Connect must include data collected by third-party code you integrate (Manage app privacy). If the app sends personal data to an AI provider, disclose it and ask for permission first (5.1.2(i)).
  • Reviewer access: if the app needs a login, put a working demo account in App Review Information (2.1).
  • Keys in the build: everything in the web bundle ships inside the app and can be extracted. Only the Supabase publishable (anon) key belongs there - and only if your tables are protected by RLS. See how to check that.
  • Minimum functionality: bundle the assets, handle no network, use app navigation, and add the native features your product needs (4.2).

When to get help

  • Sign-in, deep links or push notifications work in the simulator but not on a device, and you have run out of AI prompts to try.
  • You sell subscriptions or credits and need to decide between in-app purchase and a different model before launch.
  • You have a launch date and cannot afford a second or third rejection cycle.
  • You are deciding between a wrapper and a rewrite and want an estimate of both before committing.

Sources

Primary documentation this guide was checked against. Platforms change - if something here no longer matches, the source wins.

Frequently asked questions

Can Lovable publish my app to the App Store directly?
No. Lovable builds web apps and does not generate React Native projects. Its FAQ suggests a Progressive Web App, or wrapping your published URL with a tool such as Capacitor outside Lovable and submitting that. Loading the published URL is the remote-URL setup Capacitor does not recommend for production, so bundle the built web app into the native project instead.
Do I need a Mac to publish a Lovable app on iOS?
For the Capacitor route, yes: building iOS apps needs macOS and Xcode (Capacitor 8 requires Xcode 26.0 or newer), unless you use a cloud build service. A React Native rewrite with Expo can be built and submitted without a Mac.
How much does it cost to publish on the App Store?
The Apple Developer Program costs 99 USD a year, with local prices shown during enrollment. Development work for the wrapper or rewrite is on top of that.
Why does Google sign-in fail inside my wrapped app?
Google blocks its OAuth sign-in in embedded WebViews and returns a disallowed_useragent error. Open the sign-in in the system browser and return to the app with a deep link that is on your Supabase redirect URL allow list.

Related guides

Fixed-price audit

Want someone to check the whole app, not just this?

A review of data security, production readiness and App Store readiness for apps built with AI tools. 900 USD, a ranked list of fixes within 5 business days.