One codebase, real store app
The iOS app loads your published Cline URL inside a native WebView. There is no second project to maintain and no code export.
Why wrapping beats rebuilding for Cline apps
Cline works in your own project with your own model keys, so every token spent porting the app to Swift and Kotlin is billed to you and produces two more codebases to review step by step. WebViewGold wraps the URL you already deploy to, whatever stack and host you chose, and the native shell stays out of Cline's way. When you want native features, Cline adds the JavaScript bridge calls to the web code it already understands.
Keep shipping from Cline
Approve the deploy command (or push) and the app shows the new version on the next launch. Only changes to the native shell itself (icon, new native feature) need a store update.
Native features on top
Push notifications, offline screen, native sharing, biometric login, QR scanner, in-app purchases and deep links are single settings or one-line JavaScript calls.
App Store approval guarantee
Apple App Store approval guarantee – or your money back within 14 days. 96.4% of all WebViewGold apps get approved by the review teams on the first attempt.
What you need
- A published Cline app on a public HTTPS URL (yourproject.vercel.app, yourproject.netlify.app or yourproject.pages.dev or, better, your own domain)
- An Apple Developer Program ($99 per year) to submit to the Apple App Store
- Xcode on a Mac – or the WebViewGold Cloud Builder in your browser (no Mac needed)
- WebViewGold for iOS ($109 one-time, free updates)
- A privacy policy page, a 1024 × 1024 px icon and 30 to 60 minutes
WebViewGold has allowed us the shortest and most efficient time-to-market ever possible from among all the other app platforms we have ever tried during the past 5 years. I don’t know why I hadn’t discovered you sooner, but I am really, really glad I did. Currently nearing 6000 app downloads on both iOS App Store & Google Play Store without any problem!
Cline to App Store: the walkthrough
Eight steps, no coding. Most people finish the native part in under an hour.
Publish your Cline app to a production URL
Deploy the project yourself: approve Cline running your host's CLI (vercel --prod, netlify deploy --prod or wrangler pages deploy) or push to GitHub for automatic deployments. Use the production URL or your domain in WebViewGold. The localhost dev server Cline opens in its browser and tunnel URLs are for development only. Deploy to a permanent HTTPS URL. Custom domain: Add your domain in the hosting provider's dashboard and set the DNS records. See why a custom domain before submission is worth it.
Make it store-ready
Add a privacy policy page, an account deletion option (if users can sign up), and remove builder badges or "download our app" banners. Run the free App Store readiness check on your URL: it flags mixed content, missing viewport tags, builder preview domains and other blockers in seconds.
Get WebViewGold for iOS
One-time payment, free updates. You receive the ready-made Xcode project. If you do not own a Mac, activate the WebViewGold Cloud Builder and do everything in the browser.
Insert your URL and brand the app
Open Config.swift (or the Cloud Builder form) and paste your published URL. Set the app name, upload your icon, pick splash screen and status bar color. No coding needed.
Switch on native features
Enable push notifications, the offline screen, social-login handling, pull-to-refresh, biometric login or the QR scanner with single settings. Everything is optional.
Build and upload
In Xcode: Product → Archive → Distribute to App Store Connect. In the Cloud Builder: click Build, the upload to App Store Connect is done for you.
Create the App Store listing
In App Store Connect add name, subtitle, description, keywords, screenshots, privacy policy URL and the App Privacy answers. Add a demo account in the review notes if needed.
Submit for review
Apple reviews most apps within 24 to 48 hours. Answer reviewer questions in Resolution Center if any come up. Our approval guarantee covers you.
Cline-specific checks before you submit
These are the points that come up most often with Cline projects (Any web stack in your local project; Cline edits the files and runs your build, test and deploy commands).
- Run the store-readiness pass in Plan mode first and review the plan. In Act mode, approve deploy commands one at a time: a production deploy goes straight into the app your users have installed.
- Put the WebViewGold constraints into a rule file in .clinerules/ (Cline also reads AGENTS.md) so every task keeps the app WebView-friendly: no "Download our app" banners, /privacy page, account deletion.
- Use Cline's browser tool on the dev server to screenshot the main screens and look for horizontal overflow, cut-off fixed headers and tap targets under 44px before you deploy.
- Your model API key stays in the editor, but if the app itself calls OpenAI, Anthropic, Gemini or another model API, move those calls to a server route: keys in client code are readable from the published app.
- OAuth providers block embedded WebViews; enable WebViewGold's Social Login Helper for Google and Facebook logins.
Let Cline do the store-readiness work
Paste this into Cline and let it apply the changes reviewers look for. Review the result, then publish.
Prompt for Cline (start in Plan mode)
Start in Plan mode. This web app will be published as native iOS and Android apps that load its production URL inside the WebViewGold WebView wrapper. Read AGENTS.md and .clinerules first, then plan these changes and wait for my approval: 1. Meta viewport tag, no horizontal overflow from 320px to 1024px, 44px tap targets and safe-area-inset padding on fixed headers and footers. 2. /privacy and /terms pages linked from the footer, and a "Delete account" action in settings that removes the user's data and auth record after confirmation. 3. No "Download our app" banners or external promotional links in the main navigation; error and retry states for failed requests. 4. Every model API call and secret moved to server code. 5. A rule file .clinerules/native-app.md that records these rules and points to https://www.webviewgold.com/llms-full.txt for native features (use only the URL schemes and JavaScript variables documented there). In Act mode, start the dev server and use the browser tool to check the main screens after each change. Ask before running any deploy command, and finish with a list of what I still need to do manually.
App Store review: the rules that matter for Cline apps
Apple reviews behavior, not tooling. Nobody is rejected for using Cline; apps are rejected for the points below.
- 4.2
Minimum Functionality
The app must offer more than a repackaged website. Responsive layout, native navigation and at least one native capability (push notifications, offline screen, native sharing, biometric login) make the difference. WebViewGold switches these on with one setting each.
- 2.1
App Completeness
No placeholder content, no dead links, no crashes. If content sits behind a login, provide a demo account in the App Review notes.
- 5.1.1
Privacy
A public privacy policy URL is mandatory. Apps that let users create accounts must also let them delete the account inside the app.
- 4.8
Login Services
If the app uses Google, Facebook or another third-party or social login for the user's account, it must also offer an equivalent login that limits data to name and email, lets users keep their email private and does not track them for advertising. Sign in with Apple is the safe way to meet this. An app that only uses its own email/password login is not affected.
- 3.1.1
In-App Purchase
Digital goods and subscriptions sold inside the app must use Apple's In-App Purchase. Physical goods and real-world services can keep Stripe or PayPal.
- 2.3
Accurate Metadata
Screenshots, description and app name must match what the app does. Do not mention other platforms or "beta" in the listing.
Native features your Cline app gets in the iOS app
Every feature is optional and documented step by step in the WebViewGold for iOS documentation.
Push notifications
Remote push via OneSignal or Pushwoosh, local scheduled pushes via a JavaScript call, permission prompt at the moment you choose.
DocumentationSocial Login Helper
Google and Facebook logins work inside the app; Sign in with Apple is handled automatically.
DocumentationUniversal Links
Links from emails (magic links, password resets) open directly in the app.
DocumentationIn-app purchases
App Store subscriptions and one-time purchases via RevenueCat, triggered from your web app.
DocumentationOffline screen and fallback
A native "Try again" screen when the user is offline, or a local HTML fallback.
DocumentationLoading indicator and splash
Keep the launch screen until the web app is loaded, or show a native spinner.
DocumentationBiometric login
Face ID / Touch ID gate from a JavaScript call.
DocumentationQR and barcode scanner
Native scanner that returns the result to your web app.
DocumentationNative share sheet and haptics
Share dialog and haptic feedback from your web app.
DocumentationCustom CSS and JavaScript
Hide website-only elements and inject code when loaded inside the app.
DocumentationPre-flight checklist for App Store
Tick these off and the review is a formality. The free readiness check verifies the technical half automatically.
- HTTPS everywhere: App Transport Security blocks plain http:// content and invalid certificates.
- Responsive layout from 320 px to iPad widths. Apple also opens iPhone apps on an iPad during review.
- Privacy policy URL ready (a page inside your web app is fine).
- Account deletion available in the app if users can sign up.
- Demo login for the reviewer if content is behind authentication.
- No "Download our app" banners, no links to other app stores, no builder badges inside the app.
- A 1024 × 1024 px app icon without transparency and rounded corners (Apple adds the mask).
- Screenshots for the current iPhone sizes (and iPad if supported) taken from the real app.
- App name of 30 characters or fewer, a subtitle and keywords prepared.
- Export compliance answered (an app that only uses HTTPS qualifies for the standard encryption exemption).
Example: from Cline project to approved app
Say you built a parts and work-order tool for a small bike repair shop with Cline: mechanics see open repairs, log the parts they used and print QR labels for each storage bin. You worked with the model of your choice, kept the rules in .clinerules and deployed to Cloudflare Pages with Supabase behind it. Wrapped with WebViewGold, the app's QR scanner (qrcode://) reads a bin label that encodes a URL such as /parts/1234 and opens that page inside the app, so restocking takes seconds. Because only the shop's staff use it, you distribute the iOS app privately as a custom app through Apple Business Manager and publish a private app on managed Google Play. Each approved deploy from Cline reaches every phone in the shop.
Your first week after launch
- Start each fix in Plan mode and approve the deploy command only after you have checked the change; production goes straight to every installed app.
- Track the model API cost of each task in Cline; small fixes rarely need the largest model.
- Keep .clinerules current with the WebViewGold URL schemes you use, so later tasks do not remove them.
- Reprint QR labels only when the URL structure changes; old labels keep working as long as the routes they encode exist.
- Collect native changes (new permission texts, a new icon, another scanner type) and ship them together in one store update.
What you get with WebViewGold
A complete native app project, not a subscription. Everything below is included in the license and switched on with a setting.
- Complete Xcode project
- Push notifications
- Offline screen
- App icon & splash screen
- Share sheet & haptics
- Deep & universal links
- In-app purchases
- Free updates, white-label
Frequently asked questions
How do I publish a Cline-built app in the App Store and on Google Play?
Deploy the project to a public HTTPS URL, insert that URL into WebViewGold for iOS and Android, build with Xcode and Android Studio or the Cloud Builder, and submit through App Store Connect and the Play Console.
Does it matter which model I use in Cline?
Not for the stores. Apple and Google review the deployed app, not the model that wrote it. Pick the model that handles your stack well, and keep the store-readiness rules in .clinerules or AGENTS.md so any model follows them.
Can Cline add native features through WebViewGold?
Yes. Give it the WebViewGold llms-full.txt; the JavaScript bridge is plain URL schemes and JavaScript variables, so Cline can add push registration, haptics, the share sheet or biometric login to your existing code.
Do I need a Mac to publish an iOS app?
Not with the WebViewGold Cloud Builder: configuration, build and upload to App Store Connect happen in the browser. If you own a Mac, the Xcode project works out of the box.
How long does Apple review take?
Most submissions are reviewed within 24 to 48 hours. First submissions and apps with logins sometimes get a question from the reviewer; answer it in Resolution Center and the review continues.
What if Apple rejects the app?
Rejections name the guideline and the reason, and you can resubmit as often as needed. WebViewGold comes with an App Store approval guarantee: if Apple rejects the app for a non-content reason, you get your money back within 14 days of purchase.
Can Cline test the app the way a reviewer sees it?
Partly. Cline's browser tool shows your deployed site and catches layout problems, but push notifications, the QR scanner, haptics and the other WebViewGold features exist only in the native app. Install the real build through TestFlight on iOS and the internal testing track on Google Play, go through the main flows on a phone, and only then submit.
Which costs keep running after a Cline app is live?
Cline itself only costs model API tokens while you develop. The live app needs hosting (Vercel, Netlify, Cloudflare Pages or your server), your database plan, any model API the app calls for its users, Apple's Developer Program at $99 per year and Google Play's one-time $25 fee. The WebViewGold license is a one-time payment per platform with free updates.
Do I have to resubmit the app every time I change something in Cline?
No. The app loads your published URL, so content and feature changes you publish in Cline are live in the app immediately. A new store version is only needed when the native shell changes, for example a new app icon or an added native feature.
What does it cost in total?
$109 one-time for WebViewGold for iOS (free updates) plus the Apple Developer Program ($99 per year). Optional: the Cloud Builder add-on ($349 per license, one-time) if you want to build in the browser without a Mac, or the Full Service package (from $698 per platform) where our team configures, builds and submits the app for you.
Three ways to get your app into the stores
Same result, different amount of work on your side. All three come with the approval guarantee and 24/7 human support.
Do it yourself
$109 per platform, one-time
The WebViewGold license: a finished Xcode or Android Studio project. Paste your URL, set name and icon, switch on features, build and submit. Free updates forever.
See plans on the main pageCloud Builder
$349 per license, one-time add-on
No Mac, no Xcode, no Android Studio: configure in the browser, we build both apps in the cloud and hand them to App Store Connect and the Play Console.
How the Cloud Builder works Try the free demoFull Service
$698 per platform $798
Send us your URL and icon. Our team configures, builds and delivers your app within 72 hours, white-label, with source projects. Both platforms for $1,158.
Full Service details Powered by
Winter Sale prices valid until December 31, 2026.