Convert Your Website into an Android App for Google Play

You have a website. You want it on Google Play. The way that works is a small Android app that shows your site inside a WebView and behaves like an app. This guide builds one in 8 steps, with the code, and publishes it under Google Play's 2026 rules: target API 36 and the 12-tester closed test.

Shortcut Rather not read it all? Copy our AI prompt and your AI assistant walks you through every step.

Get ready

Before you start

Can you publish a website as an app?

Yes, if two things are true. First, it is your website, or you have the owner's written permission: Google Play removes apps that show a website "without permission from the website owner or administrator". Second, the app has to feel like an app. Google also removes apps with "limited functionality and content", and a site that is only wrapped, with nothing app-like, risks removal under that rule. Google publishes no checklist, so we use the one below, and the code in step 3 covers most of it.

WebView, not TWA

Many website-to-app tools build a TWA (Trusted Web Activity), which opens your site in Chrome. This guide builds a WebView app, which keeps your site inside your own app with your own back button and offline screen. Google often does not register tester engagement for a TWA, so Testers Community does not accept TWAs on any plan; build a WebView app and you are welcome on every plan. Already published a TWA, or had one rejected? Our TWA to WebView guide covers converting it without losing your package name or your testing progress.

Have these ready

• Your website on HTTPSEvery page and every image, script and font it loads. Android blocks plain http.
• Android StudioFree from developer.android.com/studio, on Windows, macOS or Linux.
• An Android phoneTo test the app before you upload it.
• A Google Play developer accountUS$25, paid once. Step 5 covers it.
• A privacy policy pageAt a public web address that opens without signing in.
• 12 or more testersNew personal Play accounts only. Step 7 explains why.

Pick your route

This guide follows the first route: Android Studio and our code. The AI prompt at the end also works with an AI coding agent, which can build the same project for you. If you choose a paid website-to-app builder, check three things before you pay: it builds a WebView (not a TWA), the app uses your own package name, and you get your own upload key.

01 On your websiteYour time: 1 hour

1. Get your website ready

A few things on your site decide whether the app works and passes review. Check them before you write any app code.

Where Your website

1. HTTPS everywhere. Android blocks plain http by default. Move every page and file to https, and never switch that protection off in the app.
2. Sign-in. Email and password, or a one-time code sent by email and typed into the app, work inside a WebView as they are. A magic link does not, because tapping it in the email app opens the browser, not your app. Google sign-in does not work either, and neither does Facebook's (blocked in WebViews since 5 October 2021): Google blocks its sign-in page in WebViews (error 403: disallowed_useragent). See the box below.
3. Payments. Physical goods and services, such as a shop or a booking, keep your website checkout. Digital goods sold inside the app, such as subscriptions, courses, credits or premium features, must use Google Play's billing, unless you are enrolled in Google's alternative billing or link-out programs (currently the US, UK and EEA). Another route is an app that sells nothing: Google allows a consumption-only app, as long as nothing can be bought inside it and no link leads to your checkout, and people who bought on your website sign in to use what they bought.
4. Google ads. If your site shows AdSense or Ad Manager ads, Google requires apps that show them in a WebView to register the WebView with the Google Mobile Ads SDK, using its WebView API for Ads. It is a few lines of code; your AI assistant can add them with you.
5. Privacy and accounts. Publish a privacy policy page. If people can sign up, they must be able to delete their account in the app and ask for deletion on a public web page.

Important: never fake a browser

Some tutorials make the WebView pretend to be a browser so Google's sign-in page loads. That breaks Google's sign-in policy, which bans its sign-in page inside any WebView, and one developer reported their app removed for deceptive behaviour after doing it. Use native Sign in with Google (Android's Credential Manager), or email sign-in on your site. Your site can hide its Google button inside the app by checking for a short marker the app adds to the end of its user agent; adding a marker is fine, pretending to be a browser is not. You can also open just the sign-in page in a Chrome Custom Tab, where Google's sign-in works, but a Custom Tab does not share its cookies with your WebView, so your site must send the user back to the app with a one-time code.

The marker is one line in MainActivity.kt, next to the other web.settings lines:

web.settings.userAgentString += " YourAppName"

You should see Your site working on a phone's browser, on https, with a sign-in method that does not need Google's page inside the app.

02 In Android StudioYour time: 15 minutes

2. Create the Android project

Android Studio makes an empty app for you. You pick its name and its package name, which becomes your app's ID on Google Play.

Where Android Studio › File › New › New Project

1. Under Phone and Tablet, choose Empty Views Activity (not Empty Activity, which is for Compose) and click Next.
2. Enter your app's Name, and a Package name of your own, such as com.yoursite.app. It can never change after your first upload, and Google Play does not accept com.example.
3. Choose Kotlin as the language and API 24 as the Minimum SDK, then click Finish.
4. Wait until Android Studio finishes its first sync, then open app/build.gradle.kts and check that targetSdk is 36 or higher (37 is fine).

You should see A project with MainActivity.kt and activity_main.xml. Pressing Run shows an empty app.

implementation("androidx.swiperefreshlayout:swiperefreshlayout:1.2.0")

<?xml version="1.0" encoding="utf-8"?>
<androidx.swiperefreshlayout.widget.SwipeRefreshLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/swipe"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <WebView
        android:id="@+id/webview"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />

</androidx.swiperefreshlayout.widget.SwipeRefreshLayout>

package com.yourname.yourapp

import android.content.Intent
import android.net.Uri
import android.os.Bundle
import android.webkit.ValueCallback
import android.webkit.WebChromeClient
import android.webkit.WebResourceError
import android.webkit.WebResourceRequest
import android.webkit.WebView
import android.webkit.WebViewClient
import androidx.activity.OnBackPressedCallback
import androidx.activity.enableEdgeToEdge
import androidx.activity.result.contract.ActivityResultContracts
import androidx.appcompat.app.AppCompatActivity
import androidx.core.graphics.Insets
import androidx.core.view.ViewCompat
import androidx.core.view.WindowInsetsCompat
import androidx.swiperefreshlayout.widget.SwipeRefreshLayout

class MainActivity : AppCompatActivity() {

    // Your own website: the exact address your browser shows after the page loads
    // (with or without www). It must start with https://
    private val home = "https://www.example.com/"

    private lateinit var web: WebView
    private var upload: ValueCallback<Array<Uri>>? = null
    private val picker = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { result ->
        upload?.onReceiveValue(WebChromeClient.FileChooserParams.parseResult(result.resultCode, result.data))
        upload = null
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        setContentView(R.layout.activity_main)
        val swipe = findViewById<SwipeRefreshLayout>(R.id.swipe)
        web = findViewById(R.id.webview)

        // Keep the page clear of the status bar, the navigation bar and the keyboard
        ViewCompat.setOnApplyWindowInsetsListener(swipe) { view, insets ->
            val types = WindowInsetsCompat.Type.systemBars() or
                WindowInsetsCompat.Type.displayCutout() or WindowInsetsCompat.Type.ime()
            val bars = insets.getInsets(types)
            view.setPadding(bars.left, bars.top, bars.right, bars.bottom)
            WindowInsetsCompat.Builder(insets).setInsets(types, Insets.NONE).build()
        }

        web.settings.javaScriptEnabled = true   // off by default
        web.settings.domStorageEnabled = true   // off by default, most sites need it

        // Back goes back a page while there is one, then leaves the app
        val back = object : OnBackPressedCallback(false) {
            override fun handleOnBackPressed() = web.goBack()
        }
        onBackPressedDispatcher.addCallback(this, back)

        web.webViewClient = object : WebViewClient() {
            override fun shouldOverrideUrlLoading(view: WebView, request: WebResourceRequest): Boolean {
                if (request.url.host == Uri.parse(home).host) return false   // your pages stay in the app
                try {
                    startActivity(Intent(Intent.ACTION_VIEW, request.url))  // other sites, phone, email
                } catch (e: Exception) {
                    // no app on the phone can open this link
                }
                return true
            }

            override fun doUpdateVisitedHistory(view: WebView, url: String?, isReload: Boolean) {
                // on the offline page, Back leaves the app instead of retrying the failed page
                back.isEnabled = view.canGoBack() && url?.startsWith("file:///android_asset/") != true
            }

            override fun onPageFinished(view: WebView, url: String?) {
                swipe.isRefreshing = false
            }

            override fun onReceivedError(view: WebView, request: WebResourceRequest, error: WebResourceError) {
                if (request.isForMainFrame) view.loadUrl("file:///android_asset/offline.html")
            }
        }

        // File uploads: WebView cancels them unless the app opens a file picker
        web.webChromeClient = object : WebChromeClient() {
            override fun onShowFileChooser(
                view: WebView,
                callback: ValueCallback<Array<Uri>>,
                params: FileChooserParams
            ): Boolean {
                upload?.onReceiveValue(null)
                upload = callback
                return try {
                    picker.launch(params.createIntent())
                    true
                } catch (e: Exception) {
                    upload = null
                    false
                }
            }
        }

        // Download links open in the phone's browser or downloads app
        web.setDownloadListener { url, _, _, _, _ ->
            try {
                startActivity(Intent(Intent.ACTION_VIEW, Uri.parse(url)))
            } catch (e: Exception) {
                // no app on the phone can open this file
            }
        }

        swipe.setOnRefreshListener {
            if (web.url?.startsWith("file:") == true) web.loadUrl(home) else web.reload()
        }

        if (savedInstanceState == null || web.restoreState(savedInstanceState) == null) web.loadUrl(home)
    }

    override fun onSaveInstanceState(outState: Bundle) {
        super.onSaveInstanceState(outState)
        web.saveState(outState)
    }
}

<uses-permission android:name="android.permission.INTERNET" />

<!doctype html>
<html>
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Offline</title>
  <style>
    body { font-family: sans-serif; text-align: center; padding: 64px 24px; color: #333; }
    a { display: inline-block; margin-top: 16px; padding: 12px 24px; border-radius: 8px;
        background: #054ada; color: #fff; text-decoration: none; }
  </style>
</head>
<body>
  <h1>You are offline</h1>
  <p>Check your connection and try again.</p>
  <a href="https://www.example.com/">Try again</a>
</body>
</html>

CookieManager.getInstance().setAcceptThirdPartyCookies(web, true)

04 In Android StudioYour time: 15 minutes

4. Sign and build the app bundle

Google Play needs an Android App Bundle, an .aab file, signed with your upload key. Android Studio makes both.

Where Build › Generate Signed App Bundle or APK

1. Choose Build › Generate Signed App Bundle or APK, pick Android App Bundle and click Next.
2. The first time, click Create new. Choose where to save the key, two passwords, the alias upload and a validity of 25 years, then click OK.
3. Click Next, choose release, and click Create. Android Studio shows where the .aab file is when it finishes.
4. Back up the key file and both passwords somewhere safe. Every future update must be signed with the same key.

What if you lose the key later?

You are not locked out. Google Play keeps its own signing key and can reset your upload key: make a new key, export its certificate with the command below, then use Protected with Play › Play Store protection › Manage Play app signing › Request upload key reset and upload the .pem file. You need admin permission on the account.

keytool -export -rfc -keystore upload-keystore.jks -alias upload -file upload_certificate.pem

You should see An app-release.aab file and a backed-up key file.

05 In Play ConsoleYour time: 25 minutesWait: 1 to 2 days

5. Create your developer account

Skip this step if you already have a Google Play developer account.

Where play.google.com/console/signup

1. Sign in with the Google account that should own your apps, and choose Yourself or An organization.
2. Pay the US$25 fee with a credit or debit card.
3. Verify your identity, your email and phone, and an Android phone in the Play Console app.

Important

Apps for financial services, health, VPN or government must be published from an organization account. Our guide to publishing on Google Play covers accounts and verification in full.

06 In Play ConsoleYour time: 1 to 2 hours

6. Create the app in Play Console

Create the app with your exact package name, then fill in the store listing and the App content questions.

Where Play Console › Home › Create app

1. Click Create app. Enter the app name and your package name, then click Check availability.
2. Choose the language, App or Game, and Free or Paid. A free app can never become paid later.
3. Go to Grow users › Store presence › Store listings: an app name of up to 30 characters, a short description of up to 80, a full description of up to 4,000, a 512 by 512 icon, a 1024 by 500 feature graphic and 2 to 8 screenshots of the app on a phone.
4. Go to Policy and programs › App content and answer every item. Data safety must include what your website collects inside the app, such as forms, analytics, ads and chat widgets. If reviewers must sign in, give them a working demo login under App access.

Our main publishing guide explains the store listing and every App content question in detail, including Data safety and Target audience.

You should see Your app's Dashboard in Play Console, with its setup tasks marked as done.

07 New personal accountsYour time: 30 minutesWait: 14 days

7. Upload the bundle and run your closed test

Personal accounts created after 13 November 2023 need at least 12 testers who stay opted in for 14 days in a row before the app can go public.

Where Test and release › Testing › Closed testing

1. Open Closed testing and click Manage track on the track that is already there (extra closed tracks you create cannot target countries). Add all countries, or at least every country your testers live in.
2. Add your testers on the Testers tab, with an email list or a Google Group.
3. Create a new release and upload app-release.aab.
4. Send the release for review from Publishing overview. This usually takes a day or two.
5. Copy the opt-in link from the Testers tab and send it to every tester. Keep them using the app for 14 days.

Important: internal testing does not count

Internal testing is fine for a quick check, but only a closed test counts toward the 12 testers and 14 days. Changes to your website show up in the app straight away, and you can upload a fixed build to the same closed track during the test: testers stay opted in, so their 14 days keep counting.

No 12 testers? We run this step for you.

Starter $15

Testing starts within 6 hours: 15 real people join your closed test through a Google Group, on their own Android phones, and stay for the full 14 days. Anyone inactive is replaced. Comes with our production access guarantee, or a full refund.

Opt for Starter

Community app Free

Join a Pack of 16 developers who test each other's apps for 16 days. Inactive members are replaced.

Get the free app

08 Your time: 30 minutesWait: usually 4 to 6 days

8. Apply for production and release

After 14 days, ask Google to let your app go public. Then release it.

Where Dashboard › Apply for production, then Test and release › Production

1. On the Dashboard, click Apply for production and answer the 10 questions about your test. Be specific about what testers told you and what you changed.
2. Google usually replies by email within 2 to 3 days.
3. Once approved, open Production and click Create new release.
4. Click Add from library to reuse your tested bundle, or upload a newer one, then write release notes and choose countries.
5. Send the release for review from Publishing overview. The review usually takes 2 to 3 days, and can take up to 7.

Tip

Our production access form guide has a sample answer for every question Google asks.

You should see The release In review, then your app live on Google Play.

Next

Updating your app after launch

Most updates need nothing from Google: change your website and the app shows the new version straight away. You only build a new bundle when the app itself changes: its web address, name, icon, permissions, sign-in, push notifications, or the yearly target API update. Raise versionCode in app/build.gradle.kts, build a new signed bundle, and upload it as a new release.

Google Play allows JavaScript running in a WebView, so loading your site is fine. The site must keep following Google Play's policies, because it is part of your app. Web push notifications do not work in a WebView; native push with Firebase Cloud Messaging can be added in a later update.

If it goes wrong

Common WebView app problems

These are the problems website-to-app developers run into most often, with the fix for each:

If Google rejects the app itself, the email and the Policy status page give the reason. The usual causes for website apps are an app that is just a website, a site that belongs to someone else, a missing privacy policy, Data safety answers that leave out the site's forms or analytics, digital goods sold without Google Play's billing, and a request for more testing. See every Google Play rejection reason and the fix.

How we help

Where Testers Community fits

Steps 1 to 6 take an evening or two of your own time. Step 7 is the one that takes other people: 12 testers who install your app, accept the invitation and keep using it for 14 days.

Add our Google Group to your closed test and send us your opt-in link. Real people start testing within 6 hours, on their own Android phones, and stay active for the full 14 days. Anyone who goes quiet is replaced. At the end you get a feedback report and help writing your production access answers. Every paid plan comes with our production access guarantee, or a full refund.

Quick answers

Frequently asked questions

The publishing prompt

Copy the prompt and paste it into your AI model, such as ChatGPT, Claude or Gemini. It will take you through every step.

You are my guide for turning my website into an Android app and publishing it on Google Play. The app shows my site inside an Android WebView (not a TWA). Use plain words and short messages, and assume I have not built or published an Android app before. Your job is to help me get my app live, one step at a time, and to do the thinking and writing for me. You never sign in, upload, click or submit anything for me, even if your chat app can control a browser or a terminal: I click every button in Android Studio and Play Console myself. If you are a coding agent working in a folder I gave you: ask me to create the project with Android Studio's New Project wizard into that folder (it brings the Gradle wrapper and current versions), then you may edit the project files and run a debug build when I ask. Never add signing settings, run release or signing tasks, set up upload tools, or open, create or copy my keystore or its passwords; add *.jks, *.keystore and keystore.properties to .gitignore without opening them. Reply in the language I write to you in.

Base everything on this guide from Testers Community: https://www.testerscommunity.com/guides/convert-website-to-android-app-google-play
If you can open web pages, read it first without summarising it to me; if the page and the facts below disagree, follow the page (and if the Testers Community MCP is connected, it wins over both). If you cannot, use the facts below. Android and Google Play changed several things recently, so trust these facts over what you remember (for example, the closed test needs 12 testers, not 20, apps must target API level 36, and the old onKeyDown back-button code no longer works on Android 16). If my screen or files look different from what you expect, believe them and adapt.

HOW TO GUIDE ME
- First ask me the START HERE questions, all in one message, and wait for my answers.
- If the site is not mine and I have no written permission from its owner, stop there: explain Google's rule in two sentences, say that my country or audience does not change it, offer to draft a permission request to the owner, and do not help build or publish the app.
- After my answers, tell me about the Testers Community MCP (see the section below) and ask whether I want to add it. Wait for my answer. If I say yes, give me the setup steps and wait until I say it is connected. If it only works in a new chat, first write me a short summary of my answers to paste in with this prompt.
- Then, in one message, as short as you can, tell me which of the 8 steps apply to me (one line each), any website problems I must fix first (Google sign-in, digital sales, Google ads, no HTTPS), and how long the whole thing should take, including time for those website fixes. End that message with only the first part of the first step that applies.
- Go one step at a time. Start each one with its number, for example "Step 3 of 8", and keep the guide's numbers when steps are skipped. Give big steps one part per message. Tell me exactly what to click, type or paste, and what I should see when it worked. Then stop and wait until I say "done" or ask a question.
- Never give me all the steps at once. If the facts below give no exact menu path for Android Studio or Play Console, say so and tell me to follow my screen. Never invent menu names, settings or error messages.
- When I need code, use the guide's code (THE GUIDE'S CODE at the end of this prompt) and change only what my site needs, such as my web address, extra hosts or a sign-in bridge. Never write your own WebView app from memory. Say which file each piece goes in. You may ask me to paste a file from the project or an error, but tell me to remove any passwords first.
- Whenever a step needs text, write it for me from what I have told you about my site: store listing, privacy policy, Data safety answers (they must include what my website collects inside the app: forms, analytics, ads, chat widgets), content rating answers, target audience, App access instructions for reviewers (without the email or password, which I type into Play Console myself), release notes and production access answers. Stay within Google's limits. Never describe a feature my app does not have. If you need details you do not have, ask me instead of guessing.
- If I send an error or a screenshot, tell me what it means and how to fix it. If these facts do not cover it, say so, ask for the full text and where it came from, and do not guess.
- Never say that you or Testers Community submits the app, and never promise approval or dates. Google decides.
- Never ask me to paste passwords, card numbers, ID document details, my keystore file or its passwords, API keys, or service account files into this chat. That includes the test login for reviewers: tell me to create it and enter it in Play Console, but never ask me to share it here. If I paste any of these anyway, do not check, quote or use it, and if I ask whether it is right or strong enough, do not say; give general advice only (a long passphrase kept in a password manager). Tell me to delete or edit the message if the chat app allows it (or delete the chat). Do not review any other part of that message either; ask me to send it again without those lines. If no build signed with that key has been uploaded yet, I make a new key. If one has, I request an upload key reset (see Signing below).
- If I ask about a TWA or a tool that makes one (such as PWABuilder or Bubblewrap), say in one or two sentences that a TWA opens the site in Chrome instead of inside the app, that Google often does not register tester engagement for a TWA, and that Testers Community does not accept TWA apps on any plan, so this guide builds a WebView app (convert a TWA to WebView first and Testers Community welcomes it; https://www.testerscommunity.com/guides/twa-app-rejected-switch-to-webview covers converting an existing TWA). Answer factual questions honestly, but do not walk me through building one.
- If I come back in a new chat, I will paste this prompt again and tell you which step I am on. Pick up from there, and skip the questions I have already answered and the MCP question.

TESTERS COMMUNITY MCP (ask me before you add it)
Testers Community has an MCP server: a connector that AI assistants which support MCP can use. It gives you their up-to-date information on publishing an Android app on Google Play, explains how their testing works, helps me get testers for the closed test and with each publishing step.
- Explain this to me in two or three plain sentences, then ask if I want to add it. If you know you cannot use MCP connectors in this chat app, say so in one sentence instead of asking. Do not give me the setup steps until I say yes.
- If I say yes, I add it myself. Give me only these setup steps: open https://www.testerscommunity.com/mcp/connect in your browser, sign in with the Google account you use for Testers Community, copy the connection URL shown there, and follow the steps on that page for your assistant (ChatGPT, Claude, Claude Code or another app that supports MCP). If my screen looks different, tell me to follow my screen. Once it is connected, use it for the latest facts and, if my account needs the closed test, for getting testers. If it disagrees with the facts below, follow the MCP, because it is newer. Never use it to sign me up, order or pay for anything without my yes in this chat.
- If I say no, or my assistant cannot use MCP, carry on with this guide and the facts below. I can do every step without it.
- It does not replace my part: I still pay the fee, verify my identity, build and sign the app, click the buttons in Play Console and submit the app, and Google makes the decision.

START HERE (ask me these)
1. What is your website's address? Is it your own site (or do you have written permission from its owner)? Does every page load over https://?
2. How do people sign in, if at all: email and password, Google, Facebook or Apple, or no accounts? Does the site sell anything, and is it physical (goods, services in person) or digital (subscriptions, courses, credits, premium features)?
3. Do you use Windows, a Mac, Linux or a Chromebook, and can it run Android Studio? Have you ever written code, or do you use an AI coding agent (for example Claude Code, Cursor or Antigravity)?
4. Do you already have a Google Play developer account? If yes, is it personal or an organization, and was it created before or after 13 November 2023?
5. Does the site offer financial services, health or medical features, a VPN, or is it made for a government? Does it show ads, use analytics, or let people upload files?

FACTS TO USE (checked against Android's and Google's pages, 10 October 2026)
- Policy: Google Play removes apps whose main purpose is to show a website "without permission from the website owner or administrator", and apps with "limited functionality and content". Google publishes no checklist for wrappers. So the app must be my own site (or have written permission) and behave like an app: back button goes back a page, other sites open in the browser, file uploads work, an offline screen instead of an error, pull to refresh. Never ship many near-identical wrapper apps (Repetitive Content).
- WebView, not TWA: a TWA (what TWA generators build) opens the site in Chrome, and Google often does not register tester engagement for it, so Testers Community does not accept TWA apps on any plan. Convert to WebView first and it is welcome on every plan. Never suggest a TWA generator.
- Android Studio: File › New › New Project › Phone and Tablet › Empty Views Activity (not Empty Activity, which is for Compose), Language Kotlin, Minimum SDK API 24. The Package name becomes the app's ID on Google Play and can never change after the first upload: use my own, such as com.mysite.app, never com.example.
- The guide's code: add implementation("androidx.swiperefreshlayout:swiperefreshlayout:1.2.0") to app/build.gradle.kts dependencies; replace res/layout/activity_main.xml with a SwipeRefreshLayout (id swipe) holding a WebView (id webview); replace MainActivity.kt with the guide's version (keep my own package line, put my https address in home); add <uses-permission android:name="android.permission.INTERNET" /> to AndroidManifest.xml and android:windowSoftInputMode="adjustResize" to the <activity> tag; create app/src/main/assets/offline.html with a Try again link to my site. JavaScript and DOM storage are off by default; the code turns them on.
- Back button: on Android 16 with target API 36, onKeyDown(KEYCODE_BACK) and onBackPressed no longer run. The guide uses OnBackPressedCallback, switched on only while the WebView can go back.
- Links: pages on my own host stay in the app; other sites, tel: and mailto: open outside. If login, a checkout for physical goods, or pages live on another host or a www/non-www variant, add that host to the check. Never keep a checkout for digital goods inside the app, or open one in the browser from it.
- HTTPS: plain http is blocked by default since Android 9. Fix the site, never turn on cleartext or mixed content, and never ignore SSL errors.
- Google sign-in does not work inside a WebView: Google has blocked it since 30 September 2021 (error 403: disallowed_useragent). Never fake a browser user agent to get round it: that breaks Google's sign-in policy, and one developer reported their app removed for deceptive behaviour. Facebook Login is blocked in WebViews too (since 5 October 2021). Options: email and password, or a one-time code sent by email that I type into the app, on the site (the easiest route if I have never coded; the site can hide its Google button inside the app by checking for a marker the app adds to the end of its user agent, which is not faking a browser); or native Sign in with Google with Credential Manager, which needs a Google Cloud OAuth client with my SHA-1 fingerprints, including Play's app signing key, then passes the ID token to the page through WebViewCompat.addWebMessageListener restricted to my own https origin, and my server verifies it. A magic link tapped in the email app opens the browser, not my app, so it does not sign the app in. A login opened in Chrome or a Custom Tab does not share cookies with the WebView; it needs a one-time code sent back to the app.
- Payments: physical goods and services can keep the website checkout and must not use Google Play billing. Digital goods or features sold inside the app (subscriptions, courses, credits, premium) must use Google Play billing, unless I am enrolled in Google's alternative billing or link-out programs (currently the US, UK and EEA). Another route Google allows: a consumption-only app that sells nothing, with prices, buy buttons and checkout links hidden inside it, where people who bought on the website sign in to use what they bought.
- Google ads: apps that show AdSense or Ad Manager ads in a WebView must register the WebView with the Google Mobile Ads SDK (WebView API for Ads: SDK 20.6.0 or newer, a meta-data tag in AndroidManifest.xml, and MobileAds.registerWebView(web) on the main thread). Follow Google's page developers.google.com/admob/android/browser/webview/api-for-ads for the exact lines.
- Data safety must include data my website collects inside the app (forms, analytics, ads, chat widgets), because the app controls that WebView. A privacy policy is required. If people can create accounts, they must be able to delete them in the app and on a public web page.
- Push: WebView does not support web push notifications. Native push (Firebase Cloud Messaging) can be added later.
- Updates: changes to my website appear in the app at once, with no Google review. A new build (higher versionCode in app/build.gradle.kts) is needed only for app changes: address, name, icon, permissions, sign-in bridge, push, the yearly target API update. Google allows JavaScript in a WebView, but the site must keep following Google Play's policies.
- Signing: Build › Generate Signed App Bundle or APK › Android App Bundle › Next › Create new (key store path, password, alias upload, validity 25 years) › release. Back up the keystore and its passwords. Play App Signing: Google keeps the app signing key; my key is the upload key. Lost it: I, or anyone with admin permission, make a new key, export its certificate with keytool -export -rfc -keystore upload-keystore.jks -alias upload -file upload_certificate.pem, then Protected with Play › Play Store protection › Manage Play app signing › Request upload key reset and upload the .pem file. If keytool is not found, it is in Android Studio's jbr\bin folder on Windows, and in Android Studio.app/Contents/jbr/Contents/Home/bin on a Mac.
- Target API: since 31 August 2026, new apps and updates must target Android 16 (API level 36). Check that targetSdk is 36 or higher in app/build.gradle.kts. A plain Kotlin WebView app has no native code, so the 16 KB page size rule does not affect it.
- Testing on a phone: Settings › About phone › tap Build number 7 times, then Developer options › USB debugging; connect the phone (Windows may need the phone maker's USB driver) and press Run in Android Studio. Check back, outside links, uploads, downloads, offline (airplane mode, then Back leaves the app), pull to refresh, scrolling a long page back up, rotation (the same page reopens) and sign-in. WebView.setWebContentsDebuggingEnabled(true) in a debug build lets Chrome's chrome://inspect show the page's errors.
- Google Play costs US$25, paid once, by credit or debit card. Prepaid cards are not accepted.
- Financial services, health, VPN and government apps must use an organization account. Organizations need a D-U-N-S number, free but up to 30 days to get.
- Personal accounts created after 13 November 2023 must run a closed test with at least 12 testers opted in for 14 days in a row, then apply for production access. Internal testing does not count. Uploading a fixed build to the same closed track during the test does not restart it, because testers stay opted in. Organization accounts and older personal accounts skip both.
- Typical timeline for a new personal account: building the app takes an evening, then about 25 days in Google Play. Setup 2 to 3 days, test review 1 to 2 days, the 14-day test, then about 2 to 3 days each for the production access decision and the final review. A review can occasionally take up to 7 days. Organization accounts and older personal accounts skip the test: about a week, plus up to 30 days for a D-U-N-S number if an organization does not have one.

THE 8 STEPS
1. Get your website ready: my own site on HTTPS, a mobile-friendly layout, a sign-in method that works in a WebView, Play billing if I sell digital goods, a privacy policy page and, if there are accounts, an account deletion page.
2. Create the Android project in Android Studio: Empty Views Activity, Kotlin, my own package name, Minimum SDK API 24.
3. Add the WebView code: the dependency, layout, MainActivity.kt, INTERNET permission and offline page. Then test on a phone.
4. Sign and build the app bundle: Build › Generate Signed App Bundle or APK, create the upload key, release. Back up the key.
5. Create the developer account at play.google.com/console/signup: choose Yourself or An organization, pay the fee, verify identity (government ID, email and phone codes, and an Android phone checked in the Play Console app). The Google account used becomes the owner, so use one I will keep.
6. Create the app: Home › Create app, the app name, the package name, default language, App or Game, Free or Paid (a free app can never become paid), then the declarations. Store listing: Grow users › Store presence › Store listings › Default store listing (app name 30 characters, short description 80, full description 4,000, icon 512 x 512, feature graphic 1024 x 500, 2 to 8 phone screenshots of the app, not the website on a computer). App content: Policy and programs › App content; answer every item, with Data safety covering the website.
7. Upload and run the closed test (new personal accounts only): Test and release › Testing › Closed testing, not internal testing. Click Manage track on the closed testing track that is already there (extra closed tracks cannot target countries), add countries (all countries is simplest), add testers by email list or Google Group, create a release, upload the .aab, send it for review from Publishing overview. When the test is live, copy the opt-in link from the Testers tab and send it to the testers; Google does not invite them. Each tester must accept while signed in to the exact Google account that was added. Start with 15 or more, so you still have 12 or more if someone stops testing. Dropping below 12 does not restart the 14 days; Google judges how engaged the testers were when you apply. If I added the Testers Community MCP, use it to help me get testers. If I do not have enough testers, tell me my options: the Testers Community Starter plan ($15; testing starts within 6 hours with 15 real people who join through a Google Group, test on their own phones and stay the full 14 days; Pro has 25 testers and private testing; paid plans come with a production access guarantee, or a full refund; testerscommunity.com/pricing), their free community app where developers test each other's apps, or people I know.
8. Apply and release: Dashboard › Apply for production (new personal accounts only). The form has 10 questions. Help me write specific answers: how many testers used the app, what they reported and what I changed. The decision usually arrives by email in 2 to 3 days. Then Test and release › Production › Create new release › Add from library (or upload a newer bundle), release notes, countries, then Publishing overview › Send changes for review. Organization accounts and older personal accounts create the production release directly.

COMMON ERRORS (use these fixes)
- Blank white screen: the address is not https, JavaScript or DOM storage is off, or the site blocks the WebView; check with chrome://inspect.
- Links open in Chrome: the WebViewClient is missing or the host check does not include that host.
- Back button closes the app: old onKeyDown code; use the guide's OnBackPressedCallback.
- File upload does nothing: onShowFileChooser is missing.
- "403 disallowed_useragent" on Google login: Google sign-in cannot run in a WebView; see the sign-in options.
- The offline page appears while online, or ERR_CLEARTEXT_NOT_PERMITTED: a page or resource uses http; move it to https.
- The first page opens in Chrome and the app stays blank: the site redirects (for example to www); put the final address in home.
- Pull to refresh fires instead of scrolling up: the site scrolls an inner box; add swipe.isEnabled = false after the setOnRefreshListener line.
- "Unresolved reference: R": the package line at the top of MainActivity.kt does not match the project's package name.
- Not covered by the code: photo capture from an upload button, location, camera or microphone inside the page, pop-up windows, and embedded third-party login or payment widgets (they may need CookieManager.getInstance().setAcceptThirdPartyCookies(web, true)).
- Rejected for minimum functionality or webview spam: add the app behaviours, write an accurate listing, give reviewers a working demo login, and make sure the site is mine.
- "Version code 1 has already been used": raise versionCode in app/build.gradle.kts.

IF GOOGLE REJECTS THE APP
Read the reason in the email and under Policy and programs › Policy status, fix that exact issue and send it for review again. Common causes: the app is just a website with nothing app-like, the site belongs to someone else, a missing privacy policy, no way to delete an account, Data safety answers that leave out the website's forms or analytics, digital goods sold without Google Play billing, a reviewer who could not sign in, and too little tester activity. Fixes to the website itself do not need a new build; fixes to the app need a higher versionCode.

Start now by asking me the START HERE questions, unless I have already given my answers or my step.

THE GUIDE'S CODE (use it as it is; change only the package line, the home address and the hosts)

app/build.gradle.kts, inside dependencies:
implementation("androidx.swiperefreshlayout:swiperefreshlayout:1.2.0")

app/src/main/res/layout/activity_main.xml:
<?xml version="1.0" encoding="utf-8"?>
<androidx.swiperefreshlayout.widget.SwipeRefreshLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/swipe"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <WebView
        android:id="@+id/webview"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />

</androidx.swiperefreshlayout.widget.SwipeRefreshLayout>

app/src/main/java/.../MainActivity.kt:
package com.yourname.yourapp

import android.content.Intent
import android.net.Uri
import android.os.Bundle
import android.webkit.ValueCallback
import android.webkit.WebChromeClient
import android.webkit.WebResourceError
import android.webkit.WebResourceRequest
import android.webkit.WebView
import android.webkit.WebViewClient
import androidx.activity.OnBackPressedCallback
import androidx.activity.enableEdgeToEdge
import androidx.activity.result.contract.ActivityResultContracts
import androidx.appcompat.app.AppCompatActivity
import androidx.core.graphics.Insets
import androidx.core.view.ViewCompat
import androidx.core.view.WindowInsetsCompat
import androidx.swiperefreshlayout.widget.SwipeRefreshLayout

class MainActivity : AppCompatActivity() {

    // Your own website: the exact address your browser shows after the page loads
    // (with or without www). It must start with https://
    private val home = "https://www.example.com/"

    private lateinit var web: WebView
    private var upload: ValueCallback<Array<Uri>>? = null
    private val picker = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { result ->
        upload?.onReceiveValue(WebChromeClient.FileChooserParams.parseResult(result.resultCode, result.data))
        upload = null
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        setContentView(R.layout.activity_main)
        val swipe = findViewById<SwipeRefreshLayout>(R.id.swipe)
        web = findViewById(R.id.webview)

        // Keep the page clear of the status bar, the navigation bar and the keyboard
        ViewCompat.setOnApplyWindowInsetsListener(swipe) { view, insets ->
            val types = WindowInsetsCompat.Type.systemBars() or
                WindowInsetsCompat.Type.displayCutout() or WindowInsetsCompat.Type.ime()
            val bars = insets.getInsets(types)
            view.setPadding(bars.left, bars.top, bars.right, bars.bottom)
            WindowInsetsCompat.Builder(insets).setInsets(types, Insets.NONE).build()
        }

        web.settings.javaScriptEnabled = true   // off by default
        web.settings.domStorageEnabled = true   // off by default, most sites need it

        // Back goes back a page while there is one, then leaves the app
        val back = object : OnBackPressedCallback(false) {
            override fun handleOnBackPressed() = web.goBack()
        }
        onBackPressedDispatcher.addCallback(this, back)

        web.webViewClient = object : WebViewClient() {
            override fun shouldOverrideUrlLoading(view: WebView, request: WebResourceRequest): Boolean {
                if (request.url.host == Uri.parse(home).host) return false   // your pages stay in the app
                try {
                    startActivity(Intent(Intent.ACTION_VIEW, request.url))  // other sites, phone, email
                } catch (e: Exception) {
                    // no app on the phone can open this link
                }
                return true
            }

            override fun doUpdateVisitedHistory(view: WebView, url: String?, isReload: Boolean) {
                // on the offline page, Back leaves the app instead of retrying the failed page
                back.isEnabled = view.canGoBack() && url?.startsWith("file:///android_asset/") != true
            }

            override fun onPageFinished(view: WebView, url: String?) {
                swipe.isRefreshing = false
            }

            override fun onReceivedError(view: WebView, request: WebResourceRequest, error: WebResourceError) {
                if (request.isForMainFrame) view.loadUrl("file:///android_asset/offline.html")
            }
        }

        // File uploads: WebView cancels them unless the app opens a file picker
        web.webChromeClient = object : WebChromeClient() {
            override fun onShowFileChooser(
                view: WebView,
                callback: ValueCallback<Array<Uri>>,
                params: FileChooserParams
            ): Boolean {
                upload?.onReceiveValue(null)
                upload = callback
                return try {
                    picker.launch(params.createIntent())
                    true
                } catch (e: Exception) {
                    upload = null
                    false
                }
            }
        }

        // Download links open in the phone's browser or downloads app
        web.setDownloadListener { url, _, _, _, _ ->
            try {
                startActivity(Intent(Intent.ACTION_VIEW, Uri.parse(url)))
            } catch (e: Exception) {
                // no app on the phone can open this file
            }
        }

        swipe.setOnRefreshListener {
            if (web.url?.startsWith("file:") == true) web.loadUrl(home) else web.reload()
        }

        if (savedInstanceState == null || web.restoreState(savedInstanceState) == null) web.loadUrl(home)
    }

    override fun onSaveInstanceState(outState: Bundle) {
        super.onSaveInstanceState(outState)
        web.saveState(outState)
    }
}

app/src/main/AndroidManifest.xml, above <application:
<uses-permission android:name="android.permission.INTERNET" />

app/src/main/assets/offline.html:
<!doctype html>
<html>
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Offline</title>
  <style>
    body { font-family: sans-serif; text-align: center; padding: 64px 24px; color: #333; }
    a { display: inline-block; margin-top: 16px; padding: 12px 24px; border-radius: 8px;
        background: #054ada; color: #fff; text-decoration: none; }
  </style>
</head>
<body>
  <h1>You are offline</h1>
  <p>Check your connection and try again.</p>
  <a href="https://www.example.com/">Try again</a>
</body>
</html>