Originally published on AppRanker.
Your Google Play ANR rate can quietly push your app down in search long before a one-star review says "it froze". Play treats it as a core vital, judges it over 28 days, and checks it per phone model as well as overall. Here is how the metric is counted, how to read the clusters, which fixes move the number, and how to watch it from a script instead of the console.
Which ANRs Play actually counts
Play Console shows three numbers, and only one of them affects your visibility:
- ANR rate: every ANR, including background ones.
- Multiple ANR rate: users who hit more than one.
- User-perceived ANR rate: only "Input dispatching timed out" ANRs. This is the core vital.
An input dispatch ANR fires when the main thread doesn't respond to a touch or key press for about 5 seconds. The thresholds for the user-perceived rate:
| Scope | Bad-behavior threshold |
|---|---|
| All devices (overall) | 0.47% of daily active users |
| Any single phone model | 8% |
| Any single watch model | 5% |
Cross the overall line and discoverability can drop on every device. Cross it on one model and the drop hits that model, and its users may see a warning on your store listing. For comparison, the user-perceived crash rate threshold is 1.09% overall, so Play is stricter about freezes than about crashes.
Two timing details matter. Play uses a 28-day average, so a bad release lingers for weeks. And an emerging issue is flagged once it has affected devices for more than 7 days, which leaves you about 21 days before it counts in full.
Read the cluster before you touch code
In Play Console, go to Android vitals → Crashes and ANRs, filter to foreground issues, sort clusters by affected users, then check the per-device view for any model close to 8%. If the rate jumped, compare app versions to find the release that caused it.
The cluster type tells you which timeout fired and where to look:
| ANR type | Default timeout | Usual suspect |
|---|---|---|
| Input dispatching | 5 s | Disk, database or network work on the main thread; lock contention |
| No focused window | — | Slow startup |
| Broadcast receiver | 10 s foreground / 60 s background (10–20 s / 60–120 s on Android 14+) | Too much work in onReceive()
|
| Service | 20 s foreground / 200 s background | Service callbacks running too long |
About nativePollOnce: when the main thread's stack ends in nativePollOnce, the thread was usually idle when the dump was taken. The dump can lag the real freeze (around 100 ms on Pixels running Android 13, usually under 10 ms on Android 14). For input dispatch clusters with this signature, Google's guidance is to set them aside. For broadcast and service clusters, don't: check the other threads for a deadlock or a view being touched off the main thread.
Six fixes that move the number
- Get I/O off the main thread. Disk, database and network calls belong on a background dispatcher.
-
Never hold a lock the UI needs while doing I/O. Keep critical sections tiny; a coroutine
Mutexhelps. -
Keep broadcast receivers short. Hand long work to WorkManager, and if you use
goAsync(), every path must callfinish(). -
Speed up startup. Defer SDK init you don't need yet, avoid synchronous disk reads in
Application.onCreate(), and ship a Baseline Profile with R8 enabled. - Audit third-party SDKs. Update them and move their initialization off the startup path.
- Touch views only on the main thread.
The first and third fixes in Kotlin:
class ProfileRepository(private val dao: ProfileDao) {
// Callers on the main thread suspend instead of blocking
suspend fun load(id: String): Profile = withContext(Dispatchers.IO) {
dao.findById(id)
}
}
class SyncReceiver : BroadcastReceiver() {
override fun onReceive(context: Context, intent: Intent) {
val pending = goAsync()
try {
WorkManager.getInstance(context)
.enqueue(OneTimeWorkRequestBuilder<SyncWorker>().build())
} finally {
pending.finish() // skip this and the receiver times out
}
}
}
Catch ANRs before your users report them
In debug builds, turn on StrictMode so main-thread disk and network access fails loudly. In production, Android 11 (API 30) and later keep the system's ANR trace, which your app can read on its next launch:
// Application.onCreate()
if (BuildConfig.DEBUG) {
StrictMode.setThreadPolicy(
StrictMode.ThreadPolicy.Builder().detectDiskReads()
.detectDiskWrites().detectNetwork().penaltyLog().build()
)
}
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
val am = getSystemService(ActivityManager::class.java)
am.getHistoricalProcessExitReasons(packageName, 0, 5)
.filter { it.reason == ApplicationExitInfo.REASON_ANR }
.forEach { info ->
val trace = info.traceInputStream?.bufferedReader()?.readText()
// send info.timestamp + trace to your logging backend
}
}
Watch the 28-day rate from a script
The Play Developer Reporting API exposes the same number Play uses: userPerceivedAnrRate28dUserWeighted, from the anrRateMetricSet. You need a service account with the View app information permission in Play Console. A request sliced by device model looks like this (API reference):
POST https://playdeveloperreporting.googleapis.com/v1beta1/apps/com.example.app/anrRateMetricSet:query
{
"timelineSpec": {
"aggregationPeriod": "DAILY",
"startTime": { "year": 2026, "month": 11, "day": 1, "timeZone": { "id": "America/Los_Angeles" } },
"endTime": { "year": 2026, "month": 11, "day": 10, "timeZone": { "id": "America/Los_Angeles" } }
},
"dimensions": ["deviceModel"],
"metrics": ["userPerceivedAnrRate28dUserWeighted", "distinctUsers"]
}
Daily aggregation only accepts the America/Los_Angeles time zone. Rates come back as fractions, so multiply by 100 before comparing to 8%. Treat distinctUsers as a rounded sense of how much a model matters, not an exact count. Swap deviceModel for versionCode to compare releases. Run it as a daily job that exits non-zero when any model reaches 8%, and your CI or cron turns it into an alert.
After you ship a fix, use a staged rollout and watch the new version for a few days before going to 100%. The 28-day average falls slowly as old days drop out, though Play can remove a listing warning sooner once it sees improvement. Write down the date each fix shipped, or you won't know which one helped.
One more date to plan for: per the original guide, memory vitals start affecting store visibility from February 2027.
Key takeaways
- Only input dispatch ANRs count toward the core vital: under 0.47% overall, under 8% on every phone model.
- The 28-day window means a bad release hurts for weeks, so catch regressions early.
- Read the cluster type first, and set aside input clusters that end in
nativePollOnce. - Most fixes are main-thread hygiene: I/O, locks, receivers, startup, SDKs, view threading.
- Use StrictMode in debug,
ApplicationExitInfoin production and the Reporting API for daily per-device alerts.
The full guide to diagnosing and fixing ANRs on Google Play includes the complete checklist and a ready-to-run Node.js alert script. Once your vitals are healthy, AppRanker's app leaderboard is one way to turn that store visibility into more installs.
Which ANR cluster has been hardest to kill in your app, and what finally fixed it?
Top comments (0)