Concepts

Bundled HTML or a live URL: which should your app load?

The same page, built into two Android apps and tested on a real phone: one with the files packed inside, one loading a website. Speed, offline, updates, size and the API catch that decides most projects.

9 min read Updated November 2026 By Faisal Nadeem Tested on a Galaxy A05, November 2026
1 min 49 s explainer with real recordings from the test phone. Captions available.

Bundle your HTML inside the app if the content is mostly fixed, has to work offline or must open instantly. Load a live URL if the content changes every day, depends on server logins or checkout, or is a large site you already run. In our tests on a budget Android phone, a bundled HTML5 game loaded in 0.07 seconds on any connection. The same game as a live URL took 0.51 seconds on Wi-Fi and 1.9 seconds on a slow connection, and with the network cut it showed an error page instead of the game.

Both are ordinary Android apps with the same icon, package name and Play listing. The difference is only where the WebView gets your pages from. This guide shows what that difference does in practice. If you haven't converted anything yet, the complete HTML to APK guide covers the whole process.

What the two options actually are

How we tested

We built four apps with the same Android runtime this site uses and installed them on a Samsung Galaxy A05 (Android 15, WebView 157):

We timed every reload from inside the app's WebView with Chrome DevTools and took the median of three to five runs. We repeated the tests on an emulated slow connection (400 ms latency, 400 kbps) and with the network cut. The screenshots are real captures from the phone.

Bar chart: the bundled game loaded in 0.07 seconds in every test; the live URL took 0.51 seconds on a first visit, 0.10 seconds when cached and 1.90 seconds on a slow connection
The bundled game is equally fast on every connection. The live copy depends on the network and the cache.
Test (Galaxy A05)BundledLive URL
Game, first visit, Wi-Fi0.07 s0.51 s
Game, repeat visit (cached)0.07 s0.10 s
Game, first visit, slow connection0.07 s1.90 s
Recipe page, first visit, real internet0.08 s0.19 s
Recipe page, slow connection0.10 s0.52 s
Network cutWorks normallyError page
Data downloaded per first visit (game)0 bytes48.7 KB
Added to the APK (game)21 KB0 KB

One thing the numbers don't change: app start-up. In our splash screen tests, the time from tapping the icon to seeing the page was almost identical either way on fast Wi-Fi (1.40 s bundled, 1.45 s live). Starting the app and the WebView takes far longer than loading a small page. The gap opens up on slow networks and on heavier pages.

Speed: bundled doesn't care about the network

A bundled page reads its files from the phone's storage, so the connection plays no part. Our game loaded in about 0.07 seconds on Wi-Fi, when cached and on the slow connection. The live copy needed 0.51 seconds on a first visit, even from a computer on the same Wi-Fi. On the slow connection it needed 1.9 seconds, and 1.5 seconds in, the menu still hadn't appeared.

1.5 seconds after a reload on a slow connection: the bundled game shows its full menu; the live copy shows only the title, with the chapter list still missing
Real screenshots, taken 1.5 seconds after reloading on an emulated slow connection.

Caching helps the live URL a lot on repeat visits (0.10 s in our test), but only for files the browser has already stored. A first launch on a train, or the first visit after you update the site, is always the slow case.

Offline: the clearest difference

With the network cut, the bundled app opened exactly as normal. The live-URL app had nothing to show, so the WebView displayed its built-in "Web page not available" error. Many converters swap that error for a friendlier "no connection" screen, and apps built here show one when the phone is really offline. Either way, your content isn't there.

With the network cut, the bundled app shows the recipe page normally while the live-URL app shows a Web page not available error
Same page, same moment, network cut: the bundled copy is unaffected.

If you need a live URL and some offline use, it takes work on the website side: a service worker that caches pages, or a dedicated offline page. That's worth doing, but it's never as complete as having the files inside the app.

Updates: live wins by a mile

Change a live website and every app user sees it the next time a page loads. No new build, no store review. A bundled app only changes when you publish a new version: rebuild with the new files, raise the version code, upload, wait for review, then wait for users to update. If your content changes daily (prices, news, stock), that cycle is a real cost. If it changes a few times a year, it hardly matters.

Size: smaller than you'd think

Bundling adds your files to the APK, but text compresses well. Our 64 KB game added just 21 KB to the app. Images and video are what make bundled apps big, because they're already compressed. Measure before you decide that bundling is too heavy.

APK Size CalculatorEstimate your app's size before you build Open the tool

The catch most people hit: APIs and CORS

A bundled page can still use the internet. It can fetch data, send forms and call your API. But it runs under its own address (https://appassets.androidplatform.net in apps built here), so to your server every request is cross-origin. We tested it from inside the bundled app:

Request from the pageBundled pageLive page on the same site
A server that sends no CORS headersBlocked ("Failed to fetch")Works (same origin)
A server that sends Access-Control-Allow-OriginWorksWorks

So if a bundled app talks to your own backend, the backend has to allow the app's origin:

Access-Control-Allow-Origin: https://appassets.androidplatform.net
Access-Control-Allow-Methods: GET, POST, OPTIONS
Access-Control-Allow-Headers: Content-Type, Authorization

Check which origin your converter uses: run location.origin in the app's page through Chrome remote debugging. Cookie-based logins are harder still. A session cookie from example.com is third-party to a bundled page, so log in with a token you send in a header instead. A live URL avoids all of this, because the page and the server share the same origin.

JavaScript modules: depends on how the files are served

<script type="module"> is blocked on file:// pages, which is why many guides tell you to avoid it in bundled apps. That rule depends on the converter. Apps built here serve bundled files over the https:// asset address, and in our test a page importing one module from another worked normally. If your converter uses file://, bundle your scripts into one file. Our project structure guide shows how.

Which should you choose?

Your projectChooseWhy
HTML5 game, calculator, quiz, catalogue, manualBundledInstant, offline, nothing to host
Event guide, menu, brochure that changes a few times a yearBundledOffline matters more than instant updates
Shop with checkout, booking site, members areaLive URLLogins, payments and stock live on the server
News, blog, prices or stock that change dailyLive URLUpdates without a new release
Big existing website (WordPress, Shopify, Wix)Live URLToo big and too dynamic to bundle
App screens in HTML, data from your own APIBundled + APIFast, works offline, fresh data. Needs CORS on the API

Common mistakes

What to do next

If you're bundling, get the layout right for a phone first with the mobile-ready guide, then zip your site and follow the ZIP to APK guide. If you're loading a live URL, read WebView vs native to understand what the wrapper can and can't add on top of your site.

Questions people ask

Can a bundled HTML app still use the internet?

Yes. A bundled page can fetch data, call APIs and load images from the web. Its files simply come from inside the app. Requests to your own server count as cross-origin, so the server has to send the right CORS headers for the app's origin.

Does an app that loads a live URL update automatically?

The content does. Change the website and users see it on their next page load, with no new app version. Changes to the app itself, such as the icon, name, splash screen or permissions, still need a new release.

Is a bundled HTML app faster than a live URL?

For loading pages, yes. In our tests a bundled game loaded in 0.07 seconds on any connection, against 0.51 seconds live on Wi-Fi and 1.9 seconds on a slow connection. App start-up time was about the same either way.

Can I switch from a live URL to bundled files later?

Yes. Rebuild the app with the files inside, keep the same package name and signing key, and raise the version code. Users get it as a normal update.

Does bundling make my APK much bigger?

Usually not. HTML, CSS and JavaScript compress well: our 64 KB game added 21 KB to the APK. Large images, audio and video are what add real size.

Read next

Ready to turn your site into an app?

Upload an HTML file or a ZIP, set your icon and name, and download a signed Android app. No Android Studio, no command line.

Open the builder