Google Play: what it is, app publishing, and developer console

What is Google Play?

Google Play is Google's digital distribution platform combining an app store, games, movies, books, and music. Launched on October 22, 2008 under the name Android Market, the platform was rebranded as Google Play in March 2012. Unlike Apple's App Store, Google Play is not the only channel for installing Android apps — users can install APKs from third-party sources (sideloading), use alternative stores (Samsung Galaxy Store, Amazon Appstore, F-Droid), but the majority of users use Google Play.

According to Google I/O 2026, Google Play's monthly audience exceeds 2.8 billion active users from 190+ countries. The number of available apps is over 3.2 million. The average app price is lower than in the App Store — many developers use a free model with ads or In-App Purchases. Google Play also includes sections for tablets (Large Screen Apps), Wear OS, Android TV, Android Auto, and Chromebook.

Google Play offers unique Android tools: Google Play Protect — a built-in antivirus that checks every app before and after installation; Android Vitals — app performance analytics (ANR, crash rate, startup time); Google Play Integrity — an API for verifying device and app authenticity (replacement for SafetyNet Attestation). Play Integrity is mandatory for apps handling sensitive data and payments.

Google Play Console: features and setup

Google Play Console is the central developer tool for managing apps on Google Play. Available at play.google.com/console. Getting started requires a developer account (one-time payment of $25) and identity verification. Play Console provides the full app management lifecycle: from uploading the first AAB to sales analytics and crash reports.

Main Play Console sections: Dashboard — overall statistics for all apps (installs, uninstalls, crashes, rating, revenue); Release — version and track management (Production, Open Beta, Closed Beta, Internal Testing); Growth — promotion tools (Google Ads, Promo Codes, Store Listing Experiments); Quality — Android Vitals (ANR rate, crash rate, startup time, render time); Monetization — product and subscription setup, Google Play Pass; Users & Permissions — team access management.

Testing tracks on Google Play — a key difference from the App Store. Internal Testing — up to 100 testers, no review required, updates published instantly. Closed Testing (Alpha) — up to 100 testers, requires review. Open Testing (Beta) — unlimited testers, the app is available on Google Play for anyone registered in the test. It is recommended to publish the app first in Internal Testing, then in Closed/Open Beta, and only then in Production.

// Google Play Billing Library 6.x — subscription check
import com.android.billingclient.api.BillingClient
import com.android.billingclient.api.BillingClientStateListener
import com.android.billingclient.api.BillingFlowParams
import com.android.billingclient.api.PurchasesUpdatedListener
import com.android.billingclient.api.QueryProductDetailsParams
import kotlinx.coroutines.tasks.await

class PlayBillingManager(
    private val context: Context
) {
    private val billingClient = BillingClient.newBuilder(context)
        .setListener(purchasesUpdatedListener)
        .enablePendingPurchases()
        .build()

    private val purchasesUpdatedListener = PurchasesUpdatedListener { billingResult, purchases ->
        if (billingResult.responseCode == BillingClient.BillingResponseCode.OK && purchases != null) {
            // Purchase successful — process purchases
            purchases.forEach { purchase ->
                handlePurchase(purchase)
            }
        }
    }

    suspend fun startConnection() {
        billingClient.startConnection(object : BillingClientStateListener {
            override fun onBillingSetupFinished(result: BillingResult) {
                if (result.responseCode == BillingClient.BillingResponseCode.OK) {
                    // Client ready for work
                }
            }
            override fun onBillingServiceDisconnected() {
                // Reconnection
            }
        })
    }

    suspend fun querySubscription(productId: String): ProductDetails? {
        val params = QueryProductDetailsParams.newBuilder()
            .setProductList(
                listOf(
                    QueryProductDetailsParams.Product.newBuilder()
                        .setProductId(productId)
                        .setProductType(BillingClient.ProductType.SUBS)
                        .build()
                )
            )
            .build()

        val result = billingClient.queryProductDetails(params)
        return result.productDetailsList?.firstOrNull()
    }

    private fun handlePurchase(purchase: Purchase) {
        // Server-side purchase verification
        // 1. Send purchaseToken to your server
        // 2. Server verifies via Google Play Developer API
        // 3. On success — unlock functionality
        val purchaseToken = purchase.purchaseToken
        val productId = purchase.products.firstOrNull()
        println("Purchase: $productId, Token: $purchaseToken")
    }
}

The PlayBillingManager class demonstrates working with Google Play Billing Library 6.x: establishing a connection with BillingClient, requesting product details (subscription or one-time purchase), handling purchase results via PurchasesUpdatedListener. Verification should be done on the server via the Google Play Developer API with a purchaseToken — never trust only local validation, as the purchase could be forged.

The process of publishing an app on Google Play

Publishing on Google Play is a multi-stage process that includes account registration, app preparation, Play Console setup, AAB upload, passing review, and publication. Compared to the App Store, the process is less formalized: Google relies on automated checks (Play Integrity, malware scanning via Google Play Protect) rather than manual moderation of every app.

Stage 1: Developer account registration

Publishing requires a Google account and registration in Google Play Console for $25 (one-time payment). After payment, identity verification is required: upload an ID document (passport or driver's license) and confirm your address. The verification process takes from 24 hours to 2 weeks. Without verification, the app will not be published in the Production track.

Stage 2: Building the AAB and filling out the Store Listing

Google has recommended the AAB (Android App Bundle) format since August 2021 — APK is no longer accepted for new apps. AAB allows Google Play to generate optimized APKs for each device type (different ABIs, screens, languages), reducing download size by 15-35%. Building is done via Android Studio: Build → Build Bundle(s) / APK(s) → Build Bundle(s). AAB is signed via Play App Signing — Google stores the signing key on its side.

Store Listing — the app's page on Google Play: title (50 characters), short description (80 characters), full description (4000 characters), screenshots (minimum 2, up to 8; for phone 5", 6.5", for tablet 7"+), icon (512x512), feature graphic (1024x500), promo video (YouTube). The short description is the most important for Google Play search — it gets indexed and shown in results. The full description is indexed but less significant for search.

Stage 3: Choosing a track and publishing

After uploading the AAB, the developer selects a track: Internal Testing (up to 100 testers, no review), Closed Testing (Alpha, up to 100 people, with review), Open Testing (Beta, unlimited, with review), or Production. It is recommended to start with Internal Testing — test on real devices, then Closed Testing for broader validation, and only then Production. For Open Testing and Production, at least 12 hours and 20 testers in Closed Testing over the last 14 days are required for new accounts (Google Play 2024 policy).

After publication, the app appears on Google Play within 1-24 hours. The first update may be thoroughly reviewed. Google Play automatically scans every app for malicious code via Google Play Protect. If a threat is detected, the app may be removed from publication and the developer account may be suspended.

Google Play requirements for targetSdkVersion

Google Play sets mandatory targetSdkVersion requirements for publishing and updating apps. Each year Google raises the minimum targetSdk to ensure apps use the latest security behavioural changes. Since August 2024, the minimum targetSdk is API 33; since August 2025 — API 34; since August 2026 — API 35 (Android 15).

Apps that do not meet the requirement are blocked — they cannot be published or updated. Already published apps with a low targetSdk continue to work in the store, but updating requires raising the targetSdk. Google Play Console warns 90 days before the threshold increase. Many developers delay the update until the last moment, which creates a risk of app suspension when an urgent bug fix is needed.

Raising targetSdkVersion requires checking all behavioural changes introduced between the old and new targetSdk. For example, when migrating from API 33 (Android 13) to API 35 (Android 15), you need to check: Foreground Service Types (API 34) — mandatory declaration of service type in the manifest; Privacy Sandbox (API 35) — restrictions on advertising identifiers; PhotoPicker (API 34+) — replacing direct gallery access with the system picker; new background service restrictions. Each behavioural change may require code changes.

Play Console API for compliance automation

Google Play Developer API (REST) allows you to automate targetSdk compliance checking for all apps in the account. The applications.get method returns targetSdkVersion information. It is recommended to set up monitoring via API 120 days before the deadline to get a list of apps that need updating. For apps with a large codebase, the estimated effort is from 2 days to 2 weeks for behavioural changes.

// Checking targetSdk compliance in app code
import android.os.Build

class TargetSdkCompliance {

    // Minimum targetSdk required by Google Play in 2026
    companion object {
        const val REQUIRED_TARGET_SDK = 35
    }

    // Check: do we need to handle behavioural change API 34?
    fun checkForegroundServiceTypes(targetSdk: Int): Boolean {
        // Foreground Service Types required for targetSdk >= 34
        return targetSdk >= 34
    }

    // Check: do we need to handle Privacy Sandbox (API 35)?
    fun checkPrivacySandbox(targetSdk: Int): Boolean {
        return targetSdk >= 35
    }

    // Compliance check before building
    fun validateCompliance(targetSdk: Int): List<String> {
        val warnings = mutableListOf<String>()

        if (targetSdk < REQUIRED_TARGET_SDK) {
            warnings.add("targetSdk $targetSdk is below the required $REQUIRED_TARGET_SDK")
        }

        if (targetSdk >= 34) {
            // Make sure all foreground services have a type declared in the manifest
            warnings.add("Check: all foreground services declare a type in AndroidManifest.xml")
        }

        if (targetSdk >= 35) {
            warnings.add("Check: Privacy Sandbox, Advertising ID restrictions")
        }

        return warnings
    }
}

The TargetSdkCompliance class checks targetSdk compliance before building. The validateCompliance method returns a list of warnings about required behavioural changes for a given targetSdk. Use such code in CI/CD to automatically check compliance before sending a build to Google Play Console. At IT Sectr, we implemented this check in CI after one of our projects was blocked due to a missed targetSdk.

Monetization in Google Play: In-App Billing, subscriptions, and AdMob

Monetization in Google Play includes several models: paid download, In-App Products (one-time purchases: consumable — game currency; non-consumable — ad removal), subscriptions (auto-renewable subscriptions via Google Play Billing), ads (AdMob, Google Ad Manager, third-party networks), and Google Play Pass (a subscription to a bundle of apps, revenue shared among developers based on usage time).

Google Play Billing Library (current version — 7.x as of 2026) is the mandatory tool for selling digital goods inside an app. Alternative payment systems are prohibited for digital goods (exceptions — South Korea, India, EU Digital Markets Act). Billing Library 7.x requires migration from SKU-based purchases to product-based models (ProductDetails instead of SkuDetails) and supports Kotlin Coroutines and Flow for asynchronous operations.

Google Play fee: 30% standard, 15% for the first $1 million in revenue per year (similar to Apple Small Business Program). After reaching the $1 million threshold, the fee returns to 30% for the remainder of the year. Subscriptions: 30% first year, 15% from the second year (similar to App Store). For Google Play Pass programs — revenue is distributed based on engagement (time users spend in the app as Pass subscribers), not a fixed fee.

Google's AdMob is the primary ad monetization tool. It supports banner, interstitial, native, and rewarded ads. Google Analytics for Firebase integrates with AdMob to track ad conversion to target actions. With Android 14+ (API 34), Google Play Services for Ads 22.0+ and the Handling Ad Responses API are required for Privacy Sandbox compliance. Ad monetization — 0% fee — a popular choice for free apps with a large audience.

Google Play moderation: checks and policies

Google Play moderation (Google Play Policy Review) differs from the App Store — Google relies on automated checks and selective manual moderation rather than 100% manual review of every app. The automated system scans AAB/APK for malicious code, policy violations (Spyware, Deceptive Behavior, SDK violations), and targetSdk requirement non-compliance. If a violation is detected, the app may be rejected or removed from publication.

Google Play publishes Developer Program Policies — a set of rules covering content, app behavior, monetization, and privacy. Main sections: Restricted Content (violence, hate, illegal activity), Deceptive Behavior (false claims, imitating other apps), Monetization and Ads (honest advertising, IAP policy compliance), Privacy and Security (data collection, encryption), Store Listing and Promotion (accurate description, proper categorization).

Google actively fights spyware and deceptive SDKs. In 2024-2025, Google removed over 1.5 million apps violating privacy policies. Special attention is given to SDKs that collect data without user knowledge (location tracking without consent, reading contacts and SMS). Before publishing, check the SDKs you use for Google Play Policy compliance — many popular SDKs (for example, some ad networks) have been blocked for policy violations.

The appeals process: if an app is rejected, the developer receives a notification in Play Console with the reason and recommendations. An appeal can be filed via Play Console → Policy → Appeals. Review time — up to 7 days. Repeated violations of the same policy lead to a warning (strike), a third violation leads to developer account suspension. Recovering a suspended account is an extremely difficult process requiring a written appeal and evidence that violations have been fixed.

To minimize risks: use Google Play Integrity API to verify request authenticity, implement the Data Safety Section (mandatory since 2023 — specify all collected data and collection purposes), check all SDKs for Developer Program Policies compliance, use Play Console Policy Insights to track potential violations before publication. When developing at IT Sectr, we test every app via internal testing on real devices before the Production release.