Convert Figma Make to an iOS App: Prototype to App Store

Key takeaways

Figma Make produces a web app – React and TypeScript in Figma's examples, any web framework since July 2026 – published on figma.site. There is no App Store export, so you need a native wrapper or your own build.
Harden the prototype first: a real backend and sign-in, no placeholder content, working controls and error states. Apple rejects demos and incomplete apps.
Decide where the app loads from: a custom domain on Figma hosting, or exported code on your own hosting, which adds release control and files under /.well-known/.
WebViewGold, built by our team, wraps the result in an Xcode project with push, Face ID, scanners, haptics and StoreKit; appsubmitter.io signs, lists and submits it in your account.

Our recommended solution

Turn your Figma Make app into a real iOS app with WebViewGold

WebViewGold wraps the Figma Make web app you already have in a native Xcode project and adds push notifications, a native offline screen, deep links, a QR scanner and more – the native value reviewers at the App Store look for. Built by our own team, and we submit WebViewGold apps all the time.

Get WebViewGold How it helps ↓

Can you convert a Figma Make project into an iOS app?

Yes. To convert Figma Make to an iOS app, you load the published – or exported and self-hosted – web app in a native iOS shell, add native features and submit it from your own Apple Developer account. As of October 2026, Figma offers no App Store publishing, so packaging and review are up to you, and with a prototype-first tool most of the work is turning the prototype into a product.

Figma describes Make as an "AI-driven, prompt-to-app tool" for functional prototypes, web apps and interactive UI. It was introduced at Config on May 7, 2025, became available to all users on July 24, 2025 together with a Supabase integration, and moved to a new foundation in July 2026 that supports any web framework – including Vue and Angular – and keeps the code in Git. Figma's own help examples use React with TypeScript and an App.tsx main file.

Don't confuse this with "Make mobile" on Figma's product page: that means opening a Make on your phone to try it and respond to comments – a review tool for your team, not a native app you can publish. Figma documents no wrapper or App Store route, which is why this guide walks through one.

Is your Make app ready for the App Store? A readiness check

Prototype habit	What App Review expects	What to change
Sample users, numbers and testimonials	Guideline 2.1(a): "placeholder text, empty websites, and other temporary content should be scrubbed before submission"	Real data and honest empty states
Only the happy path works	Apple rejects binaries that "crash or exhibit obvious technical problems"	Loading, error, offline and permission-denied states
A login screen with nothing behind it	Demo account info "(and turn on your back-end service!)"	Working authentication with a password demo account
Frames designed for a desktop canvas	An app that fits every supported iPhone – and iPad, if you offer it	Responsive layouts, large touch targets, no horizontal scrolling
Hover effects and tooltips	Touch-first interaction	Tap-friendly alternatives for everything hover revealed
A pricing page without purchases	Guideline 2.1(b): in-app purchases must be complete, visible to the reviewer and functional	Working In-App Purchase, or no pricing until it exists

Treat this table as a gate: the wrapper comes after it, not before. If the app has already been rejected, our article on a Figma Make app rejected under Guideline 5.6 shows how reviewers read prototype behavior and how to recover.

Want your Figma Make app in the App Store without the trial and error?

Book a free consultation call: we check your web app, tell you which native features it needs and what to fix before review. Or hand it off – our App Specialists set up signing and CI/CD, prepare the store listing and submit the app for you.

Free consultation call Book our service →

figma.site, custom domain or your own hosting?

An iOS wrapper needs one stable address. Figma Make gives you three ways to provide it:

Option	How you set it up	Good for	Limits
figma.site address	Publish from Make; you get a URL like `three-random-words.figma.site`	Trying the wrapper on your own devices	A random name that isn't your brand; on Starter, public publishing also puts the file on the Figma Community
Custom domain on Figma hosting	Connect a domain to the published app; Professional plans get ten (shared with Figma Sites), Organization and Enterprise as many as they need	The simplest production setup	Each update to the published version goes live within a minute or two; Figma's publishing docs we reviewed don't cover serving files under `/.well-known/`
Exported code on your hosting	Push to GitHub (all plans, one-way) or download a .zip (Full or Dev seat), then deploy	Release control, staging, universal-link files, your own CDN and monitoring	You run hosting and deployments; edits made in GitHub are overwritten by the next push from Make

Figma-hosted apps run on AWS with domain and routing through Cloudflare, and they aren't indexed by search engines by default – irrelevant for the app, but worth knowing for your marketing site. Whichever option you choose, turn password protection off and don't limit the app to your organization's internal audience: App Review has to be able to load it. Teams whose code already lives in their own repository can use Make on your local code, launched in May 2026, to edit that codebase visually with branches and pull requests, and let their existing pipeline deploy the app.

Four ways from Figma Make to the iPhone

1. A native wrapper around the hosted app

The fastest route: a native iOS project loads your production URL and adds native features around it. Make stays your editor, and content updates reach users without a new build. The trade-off is discipline – new features must still ship with a new build and review notes, because the wrapper always shows what you last published.

2. Capacitor around the exported code

Because Make produces a standard web project, a developer can bundle the built files into a Capacitor app and add native plugins. You gain offline-first options and full native control; you lose Make's one-click updates, and over-the-air code updates that change features collide with Guideline 2.5.2 (see 2.5.2 for WebView apps).

3. A progressive web app

Figma doesn't document PWA support for Make, but you can add a manifest through custom head code or in the exported project. iPhone users then add the app to the Home Screen from Safari and, since iOS 16.4, can receive web push. There is no App Store listing and no App Review – and also no store discovery.

4. A native rebuild from your Figma designs

Your Figma designs are a solid spec for a SwiftUI app. This gives the most native result and the most effort: you maintain two front ends, and Make becomes a prototyping step rather than your production tool.

The shortcut from Figma Make to the App Store

WebViewGold: your Figma Make app, native on iOS

Instead of building native features from scratch, start from WebViewGold. You get ready-made Xcode and Android Studio projects for your website, with native modules you switch on in the configuration:

Push notificationsOneSignal or Firebase, for real, personal events
Native offline screenNo browser error pages when the connection drops
Native splash screenApp-like start instead of a loading web page
Deep linksLinks open the right screen inside the app
QR & barcode scannerDevice features the website alone can't offer
In-app purchasesNative purchase flows where the store requires them

No tool guarantees an approval: Apple still judges what your app offers. Use the native features in your main user journey – our App Specialists review your WebViewGold app before it goes to the App Store.

Discover WebViewGold Let us submit your WebViewGold app

Step by step: Figma Make to the App Store with WebViewGold

WebViewGold is the website-to-app solution our own team builds, and it explicitly supports Figma Make projects. You get an Xcode project in Swift that you own; a one-time purchase covers it, with the Extended license needed for In-App Purchases.

Pass the readiness check above: working backend, real accounts, no placeholders.
Make the app phone-first. Prompt Make for a mobile layout or edit the code: viewport-fit=cover in the viewport meta tag, env(safe-area-inset-*) padding for fixed bars, touch targets of at least 44 points, no hover-only actions.
Publish to your production address – custom domain or your own hosting – with password protection off.
Set up app detection. Give WebViewGold a custom user agent and let your code check navigator.userAgent to hide web-only elements such as a website footer or an "install our app" banner. Layout only – features stay the same.
Configure the project. Open it in Xcode or use the separately sold Cloud Builder, enter the URL in Config.swift and set bundle ID, app name, icon and splash screen. If you build the exported code into static files, WebViewGold can also load them from a local HTML folder inside the app, which pins the UI to the reviewed build – single-page routing may need adjustments.
Switch on native modules that fit a Make app: push via OneSignal, Firebase or Pushwoosh for reminders and updates, haptic feedback, the native share dialog, a QR and barcode scanner, Face ID for accounts with personal data, the native offline screen and Apple's in-app rating dialog.
Write purpose strings. Published Make apps can request camera and microphone access, so add NSCameraUsageDescription and NSMicrophoneUsageDescription texts that name the feature, for example "Scan receipts to add expenses".
Test through TestFlight on a real iPhone with the demo account, including denied permissions and Airplane Mode.
Prepare App Store Connect: listing, screenshots from the app, App Privacy details, demo account and Notes for Review that list each feature with test steps.

No Mac and no time? Our team can set up WebViewGold for you. And no tool can promise an approval – the next section covers the rules your Make app still has to meet.

Sign-in, payments, deletion and AI: the iOS rules a Make app must meet

Sign-in

Figma doesn't prescribe which sign-in methods a Make app uses; that depends on what you prompted and built. If you added Google sign-in through Supabase, it breaks inside a wrapper: Google blocks OAuth in embedded WebViews with disallowed_useragent, and its OAuth policy states that a developer "must not direct a Google OAuth 2.0 authorization request to an embedded user-agent under the developer's control". Changing the user agent is therefore no fix. Your options, in order:

Native Google sign-in with ASWebAuthenticationSession or Google's iOS SDK – custom native code in the Xcode project that hands the result to your backend.
Email and password plus Sign in with Apple in the app, with Google sign-in kept on the website. Give Google-only users a way to set a password for the same email.
A hand-off to Safari satisfies Google, but Apple says that linking out to the default browser to sign in "provides a poor user experience and isn't appropriate" under Guideline 4. Treat it as a last resort.

Whenever a social login sets up the primary account, Guideline 4.8 asks for an equivalent privacy-friendly option. Sign in with Apple meets it, and WebViewGold recognizes Apple's sign-in page automatically; just confirm that your auth backend accepts it before you add the button. Details: Guideline 4.8 for WebView apps.

Payments

Figma doesn't document built-in payments for Make, so any checkout is something you added through custom code or backend functions. The App Store rules depend on what you sell: physical goods and services used outside the app need a method other than In-App Purchase, such as Apple Pay or card entry (3.1.3(e)), while digital content and features must use In-App Purchase (3.1.1). WebViewGold's StoreKit integration connects purchases to your web code.

Account deletion

Guideline 5.1.1(v) is short: "If your app supports account creation, you must also offer account deletion within the app." Build a delete option that removes the user and their data on the server – in a backend function, because deleting accounts needs privileges that must never ship inside the app – and revoke Sign in with Apple tokens.

AI features and privacy

If your Make app sends prompts, photos or recordings to an AI model, Guideline 5.1.2(i) requires you to "clearly disclose where personal data will be shared with third parties, including with third-party AI, and obtain explicit permission before doing so". Mirror that in your privacy policy and App Privacy details, along with everything your Supabase database stores.

Rejections to expect – and getting the app submitted

These are the guidelines that matter most for apps that started in Figma Make:

2.1 App Completeness for leftover prototype content or a demo account that doesn't work – see 2.1 for WebView apps.
4.2 Minimum Functionality when the app adds nothing to the website – see 4.2 for WebView apps.
4.3 Spam when the app looks like countless generated apps or you publish several variants of one Make file.
5.6 Developer Code of Conduct when features look hidden or the published version changes during review.
5.1.1 for vague purpose strings or forced data collection – see 5.1.1 for WebView apps.

appsubmitter.io handles the submission side: certificates, provisioning profiles and code signing, a CI/CD pipeline with fastlane, the App Store listing and App Privacy details, AI-powered pre-submission checks reviewed by a human App Specialist, the submission and all communication with App Review – in your own Apple Developer account. Changes to your Make file or code aren't part of the package, but we discuss and quote them upfront, and your app doesn't have to be finished when you book. Book the iOS service or start with a free consultation call. For Google Play, continue with converting Figma Make to an Android app.

Checklist before you submit

No placeholder text, sample users or invented numbers remain anywhere in the app.
Every button and menu item works, and errors, empty lists and lost connections have their own states.
The app loads a custom domain or your own hosting – not a random figma.site address.
Password protection is off and the app isn't restricted to an internal audience.
Layouts work on every supported iPhone, with safe areas and touch-sized controls.
Google sign-in is native or stays on the web; the app offers Sign in with Apple next to any social login.
Camera and microphone prompts carry purpose strings that name the feature.
Digital content uses In-App Purchase; physical goods and services use other payment methods.
Users can delete their account inside the app, and deletion happens on the server.
AI features disclose data sharing and ask for explicit permission first.
The demo account and Notes for Review let the reviewer test every feature.

Frequently asked questions

Can I publish a Figma Make app on the App Store?

Yes, once it works as a real app. Figma Make has no App Store export, so you wrap the published or self-hosted web app – for example with WebViewGold – and submit it from your own Apple Developer account. Apple rejects demos and placeholder content, so harden the prototype before you submit.

Do I need a paid Figma plan to turn a Make file into an iOS app?

For a real app, yes. Make is included with Full seats on paid plans, Starter users can only publish to the public web if they also publish the file to the Figma Community, custom domains start with the Professional plan and downloading code requires a Full or Dev seat. Push to GitHub is available on all plans.

Do I need a Mac to convert Figma Make to an iOS app?

Not necessarily. Xcode runs only on macOS, but WebViewGold's Cloud Builder, sold separately, configures, builds and uploads the iOS app in your browser. You can also have our team set up WebViewGold for you and let appsubmitter.io run code signing and submission through a CI/CD pipeline.

Should I keep Figma hosting or export the code?

Keep Figma hosting with a custom domain if you want the simplest setup and can stop updating the published version during review. Export through Push to GitHub or a code download if you need release control, a staging environment, files under /.well-known/ for universal links or a tighter integration with your own backend.

Can I update the iOS app from Figma Make without a new release?

Content and bug fixes, yes – the wrapper loads the current published version. New features, purchases or a different purpose need a new build whose Notes for Review describe them. Note that Figma requires older Make files to be upgraded and republished; do that before submitting, not during review.

Does Apple accept apps built with AI tools like Figma Make?

Yes. Apple said in March 2026 that it has no rules specific to vibe coding and enforces its existing guidelines. Its actions at the time concerned tool apps that generate and run code inside the iOS app, under Guideline 2.5.2 – not apps built with AI tools. Your Make app is judged like any other app.

How long does App Review take for a Figma Make app?

There is no published standard. Apple's guidelines only say that App Review looks at each submission as soon as it can, that complex or novel apps can need more scrutiny and that repeated rejections slow things down. For a critical bug fix or a time-bound event, you can request an expedited review.

Sources and further reading

Store policies and third-party products change regularly – always check the current versions. This article is independent advice and not affiliated with or endorsed by Apple, Google or any other company or product mentioned; all trademarks belong to their owners. WebViewGold and appsubmitter.io are made by our team at jocapps GmbH.

Convert Figma Make to an iOS App: From Prototype to App Store Release