November 21, 2026

Android developer verification goes global in Jan 2027

Android developer verification goes global in January 2027. Register every package you ship outside Play and automate it in CI with Google's two APIs.

News

Tech

Android developer verification starts its global rollout in January 2027, then spreads to all installation sources on certified devices over several months. Register every package name and signing key you ship, inside or outside Play. Checking registration from CI is easy, a single call with a plain API key. Registering from CI is harder, because it needs a verified human's OAuth login.

Does the January 2027 rollout reach apps you ship outside Play?

Yes, eventually. Google's 19 November post says the January start covers seven distributors: Google Play, Galaxy Store, Honor, Oppo, Xiaomi, Transsion and Vivo. Protections will then expand to cover all installation sources on certified devices, which includes your own site, F-Droid-style registries and other stores. Certified means Android 8 (API level 26) or higher, according to the verification FAQ, updated 10 November 2026.

The four-country phase that began on 30 September is covered in our September 30 enforcement walkthrough. That page was written before Google gave the January 2027 start.

Google hasn't published the exact January day, the country order, or when direct APK installs from your own site get covered (checked 21 November 2026). Watch the developer verification page and the "last updated" stamps in the FAQ. We track changes like this in Platform and language release notes: what breaks and what to fix.

Which package names do you need to register?

All of them. Registration is per package name and per signing key, so an app with a release key and a store-specific key needs both keys registered.

Teams outside Play

Create an Android Developer Console account. That's where you verify your identity and register apps. The console click path, D-U-N-S wait and fees are in the September walkthrough, so we won't repeat them.

Teams on Play

Open the Play Console status page and register anything unregistered, including apps you distribute outside Play. If you use Play App Signing, your eligible apps are registered automatically. The catch is that automatic registration covers the Play-signed key, so check any other channel separately.

Apps re-signed by a store or open-source registry

If a registry like F-Droid re-signs your APK, the key users receive isn't yours. Download the store-signed APK, extract its SHA-256 fingerprint and add that key to your package too. If a new app gets 50 or more installs from the registry before you register, you'll be asked to prove ownership. Registries that integrate the Console API can register on your behalf, but you still need a verified account.

If another developer shares your package name or key, the Console ranks the claims. The key behind more than half of known installs wins. If no key has that, every key with 50 or more installs qualifies. Below 50 installs, it's first come, first served. Anyone else submits a justification.

Enterprise store on managed devices

Exempt, but Google recommends registering and claiming those apps anyway. A copy that reaches a personal device doesn't get the exemption.

How do you check registration in CI?

The Android Developer ID Status API answers one question: is this package registered, and with this key? It takes a plain API key, so it's the easy half of the pipeline. In Google Cloud, enable "Android Developer ID Status API" under APIs & Services > Library and create a key under Credentials. A 403 PERMISSION_DENIED usually means you skipped the enable step.

Always pass the signing key's SHA-256 fingerprint. Without it, REGISTERED only means some verified developer owns the package name, and only the fingerprint call can return REGISTERED_WITH_ANOTHER_CERTIFICATE_FINGERPRINT. A gate that skips the fingerprint passes builds it shouldn't. This version fails the build on a non-200 response or any state but REGISTERED:

Bash
SHA256=$(echo "$SHA256" | tr -d ':' | tr 'A-F' 'a-f')
curl -sS -f -H "X-Goog-Api-Key: $KEY" \
  "https://androiddeveloperidstatus.googleapis.com/v1/packages/$PKG/packageRegistrationStatus:check?certificateFingerprint=$SHA256" \
  | jq -e '.state == "REGISTERED"'

Here is what each state means for the build:

StateWhat your CI should do
REGISTERED (with fingerprint)Pass the build
NOT_REGISTEREDFail the build, open a registration task
REGISTERED_WITH_ANOTHER_CERTIFICATE_FINGERPRINTFail, check which key the store re-signs with

Here's a hypothetical workload. A team ships 40 package names outside Play with 3 signing keys each, and runs a nightly job. That's 120 checks a night against a default quota of 1,000 requests a day per project. Treat a 429 RESOURCE_EXHAUSTED as retry-after-delay and 500 or 503 as back off. The nightly schedule and the fail-the-build rule are our glue, not Google's prescription.

Search more than 300,000 open roles in one place
From more than 19,000 companies across the UK, the US and Spain. Free during the open beta, until the end of November.
Try Job Search

How do you register from CI?

Here's the catch that breaks a naive plan: the Console API requires OAuth 2.0 user credentials. Google's guide says service accounts, Workload Identity Federation and API keys can't be used. So your pipeline can't authenticate as a robot. It acts as a verified human's account.

The workable pattern is to authorize once with the scope https://www.googleapis.com/auth/androiddeveloperconsole and offline access, then keep the refresh_token in your secret manager, such as GitHub Actions Secrets. Google's OAuth docs set two limits. A consent screen in "Testing" status issues refresh tokens that expire in 7 days, and tokens unused for six months stop working. So publish the consent screen and run the job more often than every six months.

Call the methods in this order:

  1. CreateAndroidPackage to register the package name.
  2. GetAndroidPackageRegistrationPolicy to see what the package needs.
  3. CreateAndroidPackageKey to add a signing key's fingerprint. It returns IN_REVIEW for a new package or an already-verified key, and DRAFT when you must prove ownership first (step 4).
  4. VerifyAndroidPackageKeyOwnership for existing packages. Put a file named adi-registration.properties containing the verificationToken in the app's assets, sign an APK with the key and upload it. Once verified, the key moves to OWNERSHIP_VERIFIED. Google skips this if you already verified the key for another package in the same developer account.
  5. JustifyAndroidPackageKeyRegistration only if the key is contested. Approval can take up to 24 hours, so don't put it on a release's critical path.

Lose the signing key and you can't register the package. Store it like the production secret it is.

What about test devices and users who won't wait?

ADB installs for development are unaffected. Limited distribution, the free tier for hobbyists and students, now allows 50 authorized devices, up from 20, according to the 19 November post. The FAQ still says 20 (answer last updated 18 June 2026). The post is five months newer, so we go with 50. The user-side advanced flow is described in the September walkthrough.

What this means for your release process

Treat registration as a release gate with an owner, not a one-off task. Before January, decide three things.

First, who owns the signing keys and the Developer Console account. The Console API runs on a person's OAuth grant, so if that person leaves, your automation goes with them. Name a role, not an individual.

Second, which keys actually reach users. Inventory every package name and every key, including the ones a store or registry re-signs.

Third, whether the status check runs on every build. It costs one request per package and key, and it turns a January surprise into a failed build in November.

If you ship through Play as well, the related deadline is Google Play's target API 36 deadline. Do both checks in the same pass.

FAQ

Does January 2027 apply to APKs I distribute from my own site?

Eventually. Google says protections will expand to all installation sources on certified devices over several months, but it hasn't published a date for direct installs. Register now, since the check is cheap.

Do I need a D-U-N-S number?

Organizations verifying on a full distribution account do, and Google says it can take up to 28 days. Limited distribution needs neither. Start the D-U-N-S request early if you haven't, because it's the one step you can't speed up.

Can service accounts call the Console API?

No. The Console API requires OAuth 2.0, and Google's guide says service accounts, Workload Identity Federation and API keys can't be used. Store an offline refresh token from a verified developer's grant in your secret manager. The Status API is the opposite: it accepts a plain API key.

Do ADB installs break?

No. Google keeps ADB installs available for developing and testing apps, so your local builds and device-lab runs don't need a registered package. Real users installing from a store or a download are who the rollout targets.

What if another developer already uses my package name?

The Console ranks contested keys by install share. If you don't qualify under those rules, you submit a justification, and approval can take up to 24 hours.

Sources

Share this article

Author Image

HighCircl Editorial Team

The HighCircl editorial team writes about hiring software engineers, nearshore development, and engineering team building. Our articles draw on direct experience sourcing and placing senior developers across Poland, Hungary, Slovakia, Serbia, Slovenia, Romania, and Spain — and on candid conversations with the CTOs and engineering leads who hire them.

HighCircl is a nearshore engineering network that delivers matched candidate shortlists in 72 hours. Every piece of content we publish is informed by real engagement data: actual developer rates, real hiring timelines, and what separates engineering teams that scale cleanly from those that stall.