Short answer
Lovable builds React web apps, so getting one into the Apple App Store means either wrapping the deployed URL in a native iOS shell or rebuilding the front end natively. Most teams wrap first with WebViewGold, add real native features such as push notifications and Sign in with Apple to pass Guideline 4.2, then submit through App Store Connect.
On this page
What Lovable actually gives you
Lovable generates a React and TypeScript front end (Vite, Tailwind, shadcn-style components) and usually connects it to Supabase for the database, authentication, storage and edge functions. You publish it to a Lovable subdomain or your own domain, and you can sync the code to a GitHub repository you own.
That last point matters for the App Store. Because the code lives in your GitHub repository, you are not locked into one route. You can point a native wrapper at the published URL, or you can take the repository and have an agent rebuild screens natively. Lovable itself does not produce an .ipa file, and Apple only accepts apps built with Xcode and signed with your developer certificate.
The three realistic routes
| Route | What you ship | Typical effort | Best when |
|---|---|---|---|
| Native wrapper | An iOS app that loads your Lovable URL plus native features | Days | The web app already works well on a phone |
| Wrapper plus native modules | Same, with deeper features (camera, offline, biometrics) | One to three weeks | Users expect a "real app" feel |
| Native rebuild | SwiftUI or React Native app reusing your Supabase backend | Weeks to months | Heavy offline use, complex gestures, device hardware |
For most Lovable MVPs the first or second route is right. The Supabase backend stays exactly where it is, and every improvement you make in Lovable shows up in the app without a new store release.
Step by step: the wrapper route
- Make the web app phone-ready. Test every screen at 375 px width. Lovable layouts are responsive by default, but check modals, tables and sticky footers, which often break on small screens. Add safe-area padding for the notch and home indicator.
- Publish to a stable production domain. Use a custom domain rather than a preview link. The app will load this URL on every launch, so it must not change.
- Fix authentication for an in-app context. If you use Supabase email or magic links, decide how links open. A magic link tapped in Mail opens Safari, not your app, unless you configure universal links. Many teams switch to one-time codes for mobile. If you offer Google sign-in, note that Google blocks OAuth inside embedded web views, so the login must run in the system browser or via a native SDK.
- Build the iOS shell. With WebViewGold you take an Xcode template, insert your Lovable URL, set the app name, icon and splash screen, and switch on native features such as push notifications, offline handling and native sharing. It is a one-time purchase and you keep the project.
- Add native value. See the next section; this is what decides whether Apple accepts the app.
- Test on real devices with TestFlight. Invite internal testers first, then a small external group. Our guide to TestFlight and Play Console internal testing covers the setup.
- Prepare the listing and submit. Screenshots, privacy nutrition labels, a review note with a demo account, and an account deletion path if users can sign up.
If you prefer not to touch Xcode at all, WeSetupYourWebViewApp does the WebViewGold setup for you and hands over the full source code, usually in about 72 hours.
Passing Guideline 4.2 with a Lovable app
Apple's Guideline 4.2 "Minimum Functionality" rejects apps that are essentially a website in a frame. Lovable apps are particularly exposed because many are early MVPs with a few screens. Reviewers look for features that only make sense in an app. Concrete options that fit typical Lovable products:
- Push notifications tied to real events in your Supabase data (a new message, an approved request, a reminder). Our article on push notifications for AI-built apps explains the server side.
- Sign in with Apple, which Apple expects anyway if you offer other third-party logins (Guideline 4.8).
- Camera or photo library access for uploads that go into Supabase Storage.
- Biometric unlock for apps holding personal data.
- Native share sheet and haptics so actions feel like iOS.
- Offline screen that explains connectivity loss instead of a blank page.
Then write a short review note explaining which native features exist and where to find them. Reviewers spend minutes, not hours, on an app.
For the full reasoning behind 4.2, see our deep dive on Guideline 4.2 and web-based apps.
Lovable-specific review risks
Placeholder content. Lovable makes it easy to ship screens with lorem ipsum, stock avatars or "coming soon" tabs. Apple rejects incomplete apps under Guideline 2.1. Remove every unfinished route before submitting.
Login walls without a demo account. If the first screen is a Supabase login, the reviewer needs credentials. Create a dedicated review account with realistic sample data.
Account deletion. Apple requires in-app account deletion for apps that allow account creation. With Supabase this means an edge function that deletes the auth user and their rows, triggered from a settings screen.
Payments for digital content. If your Lovable app sells subscriptions through Stripe, Apple requires In-App Purchase for digital goods consumed in the app. Physical goods and real-world services can keep Stripe.
External links that leave the app. Links to your marketing site or docs should open in an in-app browser, not replace the app view.
When a native rebuild makes sense
Some Lovable projects outgrow the wrapper: heavy offline workflows, complex drag interactions, or Bluetooth hardware. Because your Supabase backend is already API-shaped, an agent such as Claude Code or Codex can generate a SwiftUI or React Native client against the same tables and row-level security policies. Keep the Lovable web app as the admin console and build the mobile client separately. Expect to review every generated screen; the backend reuse saves time, but UI parity does not come for free.
Submitting and handling rejection
Upload the build from Xcode or a CI pipeline, attach it to a version in App Store Connect, and answer the export compliance, content rights and age rating questions honestly. First reviews commonly take a day or two, but do not plan a launch date around that.
If Apple rejects the app, read the cited guideline carefully and reply in Resolution Center with specifics rather than resubmitting blindly. appsubmitter.io handles submissions, store listings and rejection responses in your own developer accounts if you would rather not learn App Store Connect from scratch. We see the same patterns repeatedly when we move Lovable prototypes into production: the code is rarely the blocker; the review details are.
FAQ
Can Lovable export an iOS app directly?
No. Lovable produces a web application. To get an iOS app you either wrap the deployed URL in a native shell such as WebViewGold or rebuild the client natively. Both routes can reuse your Supabase backend unchanged.
Will Apple reject a Lovable app wrapped in a web view?
It can, if the app offers nothing beyond the website. Apps that add push notifications, Sign in with Apple, camera uploads or offline handling, and that feel complete, regularly pass. The decisive factor is native value, not the technology.
Do I need to resubmit to Apple every time I change the app in Lovable?
Not for content and UI changes in the web app; the wrapper loads the live version. You need a new build when you change native features, the app icon, permissions or the starting URL.
How long does it take to get a Lovable app into the App Store?
With a polished web app, a developer account ready and a wrapper, one to two weeks including TestFlight and review is realistic. Company developer accounts need a D-U-N-S number, which can add days.