diff --git a/app/src/main/assets/captcha.html b/app/src/main/assets/captcha.html
index 8c7dbcb252..5bb9ef0b95 100644
--- a/app/src/main/assets/captcha.html
+++ b/app/src/main/assets/captcha.html
@@ -18,48 +18,147 @@
     </style>
     #gt
     <script type="text/javascript">
+        var captchaLoadId = '#loadId';
 
         var postToken = function (response) {
-            window.MixinContext.postToken(response);
+            window.MixinContext.postToken(captchaLoadId, response);
         }
 
-        var postMessage = function (value) {
-            window.MixinContext.postMessage(value);
+        var errorDetail = function (error) {
+            if (error == null) return '';
+            if (typeof error === 'string') return error;
+            if (error.name || error.message) {
+                return [error.name, error.message].filter(Boolean).join(': ');
+            }
+            try {
+                return JSON.stringify(error);
+            } catch (_) {
+                return String(error);
+            }
         }
 
+        var postEvent = function (event, stage, detail) {
+            window.MixinContext.postEvent(captchaLoadId, event, stage, errorDetail(detail));
+        }
+
+        var fatalEventPosted = false;
+
+        var postError = function (stage, error) {
+            if (fatalEventPosted) return;
+            fatalEventPosted = true;
+            postEvent('error', stage, error);
+        }
+
+        var onCaptchaScriptError = function () {
+            postError('script_load', 'load_failed');
+        }
+
+        window.addEventListener('error', function (event) {
+            var target = event.target;
+            if (target && target.tagName === 'SCRIPT' && target.src && target.src.indexOf('/api.js') !== -1) {
+                onCaptchaScriptError();
+                return;
+            }
+            if (!target || target === window) {
+                var source = event.filename ? event.filename.split('?')[0].split('/').pop() : '';
+                postError('javascript_error', [event.message, source, event.lineno, event.colno].filter(Boolean).join(':'));
+            }
+        }, true);
+
+        window.addEventListener('unhandledrejection', function (event) {
+            postError('unhandled_rejection', event.reason);
+        });
+
         var renderCallback = {
             'sitekey': '#apiKey',
             'callback': postToken,
-            'expired-callback': postMessage,
-            'error-callback': postMessage,
+            'expired-callback': function () {
+                postError('response_expired', 'expired');
+            },
+            'error-callback': function (error) {
+                postError('provider_error', error);
+            },
+            'chalexpired-callback': function () {
+                postError('challenge_expired', 'expired');
+            },
+            'open-callback': function () {
+                postEvent('ready', 'challenge_ready', '');
+            },
+            'close-callback': function () {
+                postEvent('cancel', 'challenge_closed', '');
+            },
             'size': 'invisible'
         }
 
         var onGCaptchaLoad = function () {
-            grecaptcha.render('html_element', window.renderCallback);
-            grecaptcha.execute();
+            postEvent('progress', 'sdk_loaded', '');
+            var widgetID;
+            try {
+                widgetID = grecaptcha.render('html_element', window.renderCallback);
+                postEvent('progress', 'widget_rendered', widgetID);
+            } catch (error) {
+                postError('render', error);
+                return;
+            }
+            try {
+                grecaptcha.execute(widgetID);
+            } catch (error) {
+                postError('execute', error);
+            }
         }
 
         var onHCaptchaLoad = function () {
-            var widgetID = hcaptcha.render('html_element', window.renderCallback);
-            hcaptcha.execute(widgetID);
+            postEvent('progress', 'sdk_loaded', '');
+            var widgetID;
+            try {
+                widgetID = hcaptcha.render('html_element', window.renderCallback);
+                postEvent('progress', 'widget_rendered', widgetID);
+            } catch (error) {
+                postError('render', error);
+                return;
+            }
+            try {
+                hcaptcha.execute(widgetID);
+            } catch (error) {
+                postError('execute', error);
+            }
         }
 
+        var gtInitialized = false;
+
         var initGTCaptcha = function() {
-            initGeetest4({
-                captchaId: '#apiKey',
-                product: 'bind',
-                hideBar: ['close']
-            }, function(captcha) {
-                captcha.onReady(function(){
-                    captcha.showCaptcha();
-                }).onSuccess(function(){
-                    var result = captcha.getValidate();
-                    postToken(JSON.stringify(result));
-                }).onClose(function () {
-                    postMessage("gt_close");
+            if (gtInitialized) return;
+            gtInitialized = true;
+            postEvent('progress', 'sdk_loaded', '');
+            try {
+                initGeetest4({
+                    captchaId: '#apiKey',
+                    product: 'bind',
+                    hideBar: ['close'],
+                    onError: function (error) {
+                        postError('provider_error', error);
+                    }
+                }, function(captcha) {
+                    postEvent('progress', 'widget_rendered', '');
+                    captcha.onReady(function(){
+                        try {
+                            captcha.showCaptcha();
+                            postEvent('ready', 'challenge_ready', '');
+                        } catch (error) {
+                            postError('execute', error);
+                        }
+                    }).onSuccess(function(){
+                        var result = captcha.getValidate();
+                        postToken(JSON.stringify(result));
+                    }).onError(function (error) {
+                        postError('provider_error', error);
+                    }).onClose(function () {
+                        postError('challenge_closed', 'gt_close');
+                    });
                 });
-            });
+            } catch (error) {
+                postError('render', error);
+            }
         };
     </script>
 </head>
diff --git a/app/src/main/java/one/mixin/android/widget/CaptchaLoadDecision.kt b/app/src/main/java/one/mixin/android/widget/CaptchaLoadDecision.kt
new file mode 100644
index 0000000000..e9d2167757
--- /dev/null
+++ b/app/src/main/java/one/mixin/android/widget/CaptchaLoadDecision.kt
@@ -0,0 +1,42 @@
+package one.mixin.android.widget
+
+internal enum class CaptchaLoadEvent {
+    PageFinished,
+    SdkLoaded,
+    WidgetRendered,
+    ChallengeReady,
+    FatalError,
+}
+
+internal sealed interface CaptchaLoadAction {
+    data object KeepWatching : CaptchaLoadAction
+
+    data object RestartWatchdog : CaptchaLoadAction
+
+    data class SwitchTo(val captchaType: CaptchaView.CaptchaType) : CaptchaLoadAction
+
+    data object Stop : CaptchaLoadAction
+}
+
+internal fun decideCaptchaLoadAction(
+    event: CaptchaLoadEvent,
+    captchaType: CaptchaView.CaptchaType,
+    failureCount: Int,
+    maxFailureCount: Int,
+    fallbackEnabled: Boolean,
+): CaptchaLoadAction =
+    when (event) {
+        CaptchaLoadEvent.PageFinished -> CaptchaLoadAction.KeepWatching
+        CaptchaLoadEvent.SdkLoaded,
+        CaptchaLoadEvent.WidgetRendered,
+        -> CaptchaLoadAction.RestartWatchdog
+
+        CaptchaLoadEvent.ChallengeReady -> CaptchaLoadAction.RestartWatchdog
+        CaptchaLoadEvent.FatalError -> {
+            if (!fallbackEnabled || failureCount >= maxFailureCount) {
+                CaptchaLoadAction.Stop
+            } else {
+                CaptchaLoadAction.SwitchTo(captchaType.fallback())
+            }
+        }
+    }
diff --git a/app/src/main/java/one/mixin/android/widget/CaptchaView.kt b/app/src/main/java/one/mixin/android/widget/CaptchaView.kt
index 6c215830b6..aa65cc1d1f 100644
--- a/app/src/main/java/one/mixin/android/widget/CaptchaView.kt
+++ b/app/src/main/java/one/mixin/android/widget/CaptchaView.kt
@@ -6,7 +6,9 @@ import android.content.Context
 import android.graphics.Color
 import android.graphics.drawable.ColorDrawable
 import android.graphics.drawable.GradientDrawable
+import android.net.Uri
 import android.net.http.SslError
+import android.os.SystemClock
 import android.view.Gravity
 import android.view.ViewGroup
 import android.view.Window
@@ -62,6 +64,9 @@ internal fun captchaDialogBarStyle() =
 class CaptchaView(private val context: Context, private val callback: Callback) {
     companion object {
         private const val WEB_VIEW_TIME_OUT = 35000L
+        private const val MAX_CAPTCHA_CYCLES = 2
+        private const val CAPTCHA_TYPES_PER_CYCLE = 3
+        private const val MAX_CAPTCHA_FAILURES = MAX_CAPTCHA_CYCLES * CAPTCHA_TYPES_PER_CYCLE
 
         private const val DIALOG_HORIZONTAL_MARGIN_DP = 20
         private const val CAPTCHA_CONTENT_MAX_HEIGHT_DP = 560
@@ -69,6 +74,16 @@ class CaptchaView(private val context: Context, private val callback: Callback)
 
         private const val TAG = "CaptchaView"
 
+        private const val EVENT_PROGRESS = "progress"
+        private const val EVENT_READY = "ready"
+        private const val EVENT_ERROR = "error"
+        private const val EVENT_CANCEL = "cancel"
+        private const val STAGE_PAGE_LOADING = "page_loading"
+        private const val STAGE_PAGE_FINISHED = "page_finished"
+        private const val STAGE_SDK_LOADED = "sdk_loaded"
+        private const val STAGE_WIDGET_RENDERED = "widget_rendered"
+        private const val STAGE_CHALLENGE_READY = "challenge_ready"
+
         const val reCAPTCHA = "reCAPTCHA"
         const val hCAPTCHA = "hCaptcha"
         const val gtCAPTCHA = "GeeTest"
@@ -76,7 +91,22 @@ class CaptchaView(private val context: Context, private val callback: Callback)
 
     private var captchaDialog: Dialog? = null
     private var released = false
-    private val timedOutCaptchaTypes = mutableSetOf<CaptchaType>()
+    private val captchaFailureHistory = mutableListOf<String>()
+    private var nextCaptchaLoadId = 0L
+    private var activeCaptchaLoad: CaptchaLoadState? = null
+
+    private data class CaptchaLoadState(
+        val id: String,
+        val type: CaptchaType,
+        val fallbackEnabled: Boolean,
+        val startedAt: Long,
+        val documentUrl: String,
+        val scriptOnloadCallback: String,
+        var stage: String,
+        var settled: Boolean = false,
+        var timeoutRunnable: Runnable? = null,
+        var lastWebError: String? = null,
+    )
 
     private val captchaContentHeight by lazy {
         val barHeight = captchaDialogBarStyle().heightDp.dp
@@ -178,11 +208,6 @@ class CaptchaView(private val context: Context, private val callback: Callback)
 
     val webView: WebView by webViewLazy
 
-    private val stopWebViewRunnable = Runnable { handleCaptchaTimeout() }
-
-    private var captchaType = CaptchaType.GCaptcha
-    private var fallbackEnabled = true
-
     fun loadCaptcha(captchaType: CaptchaType) = loadCaptcha(captchaType, true, true)
 
     fun loadCaptchaWithoutFallback(captchaType: CaptchaType) = loadCaptcha(captchaType, true, false)
@@ -193,11 +218,10 @@ class CaptchaView(private val context: Context, private val callback: Callback)
         fallbackEnabled: Boolean,
     ) {
         if (released) return
-        this.captchaType = captchaType
-        this.fallbackEnabled = fallbackEnabled
         if (resetTimeoutFallbacks) {
-            timedOutCaptchaTypes.clear()
+            captchaFailureHistory.clear()
         }
+        val load = startCaptchaLoad(captchaType, fallbackEnabled)
         show()
         val isG = captchaType.isG()
         val isH = captchaType.isH()
@@ -211,6 +235,7 @@ class CaptchaView(private val context: Context, private val callback: Callback)
                         newProgress: Int,
                     ) {
                         super.onProgressChanged(view, newProgress)
+                        if (!isActiveCaptchaLoad(load.id)) return
                         updateProgress(newProgress)
                     }
                 }
@@ -221,8 +246,9 @@ class CaptchaView(private val context: Context, private val callback: Callback)
                         url: String?,
                     ) {
                         super.onPageFinished(view, url)
+                        if (!isActiveCaptchaLoad(load.id) || url != load.documentUrl) return
+                        handleCaptchaLoadEvent(load.id, CaptchaLoadEvent.PageFinished, STAGE_PAGE_FINISHED)
                         if (isGT) view?.evaluateJavascript("initGTCaptcha()") {}
-                        cancelRunOnUiThread(stopWebViewRunnable)
                         view?.translationY(0f)
                         updateProgress(100)
                     }
@@ -233,9 +259,17 @@ class CaptchaView(private val context: Context, private val callback: Callback)
                         errorResponse: WebResourceResponse?,
                     ) {
                         super.onReceivedHttpError(view, request, errorResponse)
-                        val message = "$TAG load $captchaType onReceivedHttpError ${errorResponse?.statusCode} ${errorResponse?.reasonPhrase}"
-                        Timber.e(message)
-                        reportException(CaptchaException(message))
+                        val state = activeCaptchaLoad(load.id) ?: return
+                        if (isStaleCaptchaRequest(state, request)) return
+                        val detail =
+                            "status=${errorResponse?.statusCode}" +
+                                " mainFrame=${request?.isForMainFrame}" +
+                                " resource=${captchaResource(request)}"
+                        if (isCriticalCaptchaRequest(state, request)) {
+                            failCaptchaLoad(load.id, "http_error", detail)
+                        } else {
+                            logCaptchaWebError(state, "http_error", detail)
+                        }
                     }
 
                     override fun onReceivedSslError(
@@ -243,10 +277,15 @@ class CaptchaView(private val context: Context, private val callback: Callback)
                         handler: SslErrorHandler?,
                         error: SslError?,
                     ) {
-                        super.onReceivedSslError(view, handler, error)
-                        val message = "$TAG load $captchaType onReceivedSslError ${error?.toString()}"
-                        Timber.e(message)
-                        reportException(CaptchaException(message))
+                        handler?.cancel()
+                        val state = activeCaptchaLoad(load.id) ?: return
+                        if (isStaleCaptchaApiUrl(state, error?.url)) return
+                        val detail = "code=${error?.primaryError} resource=${captchaResource(error?.url)}"
+                        if (isCriticalCaptchaUrl(state, error?.url)) {
+                            failCaptchaLoad(load.id, "ssl_error", detail)
+                        } else {
+                            logCaptchaWebError(state, "ssl_error", detail)
+                        }
                     }
 
                     override fun onReceivedError(
@@ -255,9 +294,18 @@ class CaptchaView(private val context: Context, private val callback: Callback)
                         error: WebResourceError?,
                     ) {
                         super.onReceivedError(view, request, error)
-                        val message = "$TAG load $captchaType onReceivedError ${error?.errorCode} ${error?.description}"
-                        Timber.e(message)
-                        reportException(CaptchaException(message))
+                        val state = activeCaptchaLoad(load.id) ?: return
+                        if (isStaleCaptchaRequest(state, request)) return
+                        val detail =
+                            "code=${error?.errorCode}" +
+                                " mainFrame=${request?.isForMainFrame}" +
+                                " resource=${captchaResource(request)}" +
+                                " description=${error?.description}"
+                        if (isCriticalCaptchaRequest(state, request)) {
+                            failCaptchaLoad(load.id, "resource_error", detail)
+                        } else {
+                            logCaptchaWebError(state, "resource_error", detail)
+                        }
                     }
 
                     override fun shouldInterceptRequest(
@@ -269,15 +317,19 @@ class CaptchaView(private val context: Context, private val callback: Callback)
                                 val inputStream = context.assets.open("gt4.js")
                                 return WebResourceResponse("application/javascript", "UTF-8", inputStream)
                             } catch (e: Exception) {
-                                Timber.e(e, "$TAG load $captchaType intercept local gt4.js failed")
-                                reportException(e)
+                                Timber.e(e, "$TAG load ${load.type} intercept local gt4.js failed")
+                                webView.post {
+                                    failCaptchaLoad(load.id, "script_load", "local_gt4")
+                                }
                             }
                         }
                         return super.shouldInterceptRequest(view, request)
                     }
                 }
-            val input = context.assets.open("captcha.html")
-            var html = input.source().buffer().readByteString().string(Charset.forName("utf-8"))
+            var html =
+                context.assets.open("captcha.html").use { input ->
+                    input.source().buffer().readByteString().string(Charset.forName("utf-8"))
+                }
             val apiKey = when {
                 isG -> BuildConfig.RECAPTCHA_KEY
                 isH -> BuildConfig.HCAPTCHA_KEY
@@ -286,17 +338,32 @@ class CaptchaView(private val context: Context, private val callback: Callback)
             }
 
             html = html.replace("#apiKey", apiKey)
+            html = html.replace("#loadId", load.id)
             when {
-                isG -> html = html.replace("#src", "https://www.recaptcha.net/recaptcha/api.js?onload=onGCaptchaLoad&render=explicit")
-                isH -> html = html.replace("#src", "https://js.hcaptcha.com/1/api.js?onload=onHCaptchaLoad&render=explicit")
+                isG -> {
+                    html = html.replace("onGCaptchaLoad", load.scriptOnloadCallback)
+                    html = html.replace(
+                        "#src",
+                        "https://www.recaptcha.net/recaptcha/api.js?onload=${load.scriptOnloadCallback}&render=explicit",
+                    )
+                }
+
+                isH -> {
+                    html = html.replace("onHCaptchaLoad", load.scriptOnloadCallback)
+                    html = html.replace(
+                        "#src",
+                        "https://js.hcaptcha.com/1/api.js?onload=${load.scriptOnloadCallback}&render=explicit",
+                    )
+                }
+
                 else -> html = html.replace("#src", "")
             }
 
-
             if (isGT) {
-                val gt4Input = context.assets.open("gt4.js")
-                val gt4Content = gt4Input.source().buffer().readByteString().string(Charset.forName("utf-8"))
-                gt4Input.close()
+                val gt4Content =
+                    context.assets.open("gt4.js").use { input ->
+                        input.source().buffer().readByteString().string(Charset.forName("utf-8"))
+                    }
                 html = html.replace(
                     "#gt", """
                     <script type="text/javascript">
@@ -309,32 +376,230 @@ class CaptchaView(private val context: Context, private val callback: Callback)
             }
 
             webView.clearCache(true)
-            webView.loadDataWithBaseURL(Constants.API.DOMAIN, html, "text/html", "UTF-8", null)
-            runOnUiThread(stopWebViewRunnable, WEB_VIEW_TIME_OUT)
+            webView.loadDataWithBaseURL(load.documentUrl, html, "text/html", "UTF-8", null)
+        }
+    }
+
+    private fun startCaptchaLoad(
+        captchaType: CaptchaType,
+        fallbackEnabled: Boolean,
+    ): CaptchaLoadState {
+        invalidateActiveCaptchaLoad()
+        if (webViewLazy.isInitialized()) {
+            webView.stopLoading()
+        }
+        val loadId = (++nextCaptchaLoadId).toString()
+        val state =
+            CaptchaLoadState(
+                id = loadId,
+                type = captchaType,
+                fallbackEnabled = fallbackEnabled,
+                startedAt = SystemClock.elapsedRealtime(),
+                documentUrl = "${Constants.API.DOMAIN}/?captcha_load_id=$loadId",
+                scriptOnloadCallback = "onCaptchaLoad$loadId",
+                stage = STAGE_PAGE_LOADING,
+            )
+        activeCaptchaLoad = state
+        restartCaptchaTimeout(state)
+        return state
+    }
+
+    private fun handleCaptchaLoadEvent(
+        loadId: String,
+        event: CaptchaLoadEvent,
+        stage: String,
+    ) {
+        val state = activeCaptchaLoad(loadId) ?: return
+        if (event != CaptchaLoadEvent.PageFinished || state.stage == STAGE_PAGE_LOADING) {
+            state.stage = stage
+        }
+        when (
+            decideCaptchaLoadAction(
+                event = event,
+                captchaType = state.type,
+                failureCount = captchaFailureHistory.size,
+                maxFailureCount = MAX_CAPTCHA_FAILURES,
+                fallbackEnabled = state.fallbackEnabled,
+            )
+        ) {
+            CaptchaLoadAction.KeepWatching -> Unit
+            CaptchaLoadAction.RestartWatchdog -> restartCaptchaTimeout(state)
+            is CaptchaLoadAction.SwitchTo,
+            CaptchaLoadAction.Stop,
+            -> Unit
         }
     }
 
-    private fun handleCaptchaTimeout() {
+    private fun restartCaptchaTimeout(state: CaptchaLoadState) {
+        if (state.settled || activeCaptchaLoad?.id != state.id) return
+        cancelCaptchaTimeout(state)
+        val timeoutRunnable = Runnable { failCaptchaLoad(state.id, "timeout", "") }
+        state.timeoutRunnable = timeoutRunnable
+        runOnUiThread(timeoutRunnable, WEB_VIEW_TIME_OUT)
+    }
+
+    private fun cancelCaptchaTimeout(state: CaptchaLoadState) {
+        state.timeoutRunnable?.let(::cancelRunOnUiThread)
+        state.timeoutRunnable = null
+    }
+
+    private fun cancelCaptchaLoad(loadId: String) {
+        val state = activeCaptchaLoad(loadId) ?: return
+        state.settled = true
+        cancelCaptchaTimeout(state)
+        hide()
+        callback.onStop()
+    }
+
+    private fun failCaptchaLoad(
+        loadId: String,
+        reason: String,
+        detail: String,
+    ) {
         if (released) return
-        val message = "$TAG load $captchaType timeout"
+        val state = activeCaptchaLoad(loadId) ?: return
+        state.settled = true
+        cancelCaptchaTimeout(state)
+        val safeDetail =
+            detail
+                .ifBlank { state.lastWebError.orEmpty() }
+                .replace('\n', ' ')
+                .replace('\r', ' ')
+                .take(200)
+        val elapsed = SystemClock.elapsedRealtime() - state.startedAt
+        val message =
+            "$TAG load ${state.type} failed stage=${state.stage} reason=$reason" +
+                " elapsed=${elapsed}ms${if (safeDetail.isBlank()) "" else " detail=$safeDetail"}"
         Timber.e(message)
-        reportException(CaptchaException(message))
-        if (!fallbackEnabled) {
+        captchaFailureHistory.add(
+            "${state.type}:$reason@${state.stage}" +
+                if (safeDetail.isBlank()) "" else "($safeDetail)",
+        )
+        val action =
+            decideCaptchaLoadAction(
+                event = CaptchaLoadEvent.FatalError,
+                captchaType = state.type,
+                failureCount = captchaFailureHistory.size,
+                maxFailureCount = MAX_CAPTCHA_FAILURES,
+                fallbackEnabled = state.fallbackEnabled,
+            )
+        if (!state.fallbackEnabled) {
+            reportException(CaptchaException(message))
             updateProgress(100)
             callback.onStop()
             return
         }
-        timedOutCaptchaTypes.add(captchaType)
-        val fallbackCaptchaType = captchaType.fallback()
-        if (fallbackCaptchaType !in timedOutCaptchaTypes) {
-            loadCaptcha(fallbackCaptchaType, false, true)
-        } else {
-            hide()
-            toast(R.string.Recaptcha_timeout)
-            callback.onStop()
+        when (action) {
+            is CaptchaLoadAction.SwitchTo -> loadCaptcha(action.captchaType, false, true)
+            CaptchaLoadAction.Stop -> {
+                val exhaustedMessage =
+                    "$TAG exhausted captcha fallbacks cycles=$MAX_CAPTCHA_CYCLES" +
+                        " attempts=${captchaFailureHistory.size} lastStage=${state.stage}" +
+                        " failures=${captchaFailureHistory.joinToString()}"
+                Timber.e(exhaustedMessage)
+                reportException(CaptchaException(exhaustedMessage))
+                hide()
+                toast(R.string.Recaptcha_timeout)
+                callback.onStop()
+            }
+
+            CaptchaLoadAction.KeepWatching,
+            CaptchaLoadAction.RestartWatchdog,
+            -> Unit
+        }
+    }
+
+    private fun activeCaptchaLoad(loadId: String): CaptchaLoadState? =
+        activeCaptchaLoad?.takeIf { it.id == loadId && !it.settled }
+
+    private fun isActiveCaptchaLoad(loadId: String) = activeCaptchaLoad(loadId) != null
+
+    private fun invalidateActiveCaptchaLoad() {
+        activeCaptchaLoad?.let { state ->
+            state.settled = true
+            cancelCaptchaTimeout(state)
+        }
+        activeCaptchaLoad = null
+    }
+
+    private fun isStaleCaptchaRequest(
+        state: CaptchaLoadState,
+        request: WebResourceRequest?,
+    ): Boolean {
+        val resourceRequest = request ?: return false
+        if (resourceRequest.isForMainFrame) return resourceRequest.url.toString() != state.documentUrl
+        if (isCaptchaApiUri(state.type, resourceRequest.url)) {
+            return resourceRequest.url.getQueryParameter("onload") != state.scriptOnloadCallback
+        }
+        val referer =
+            resourceRequest.requestHeaders.entries
+                .firstOrNull { it.key.equals("Referer", ignoreCase = true) }
+                ?.value ?: return false
+        return referer.startsWith("${Constants.API.DOMAIN}/?captcha_load_id=") && referer != state.documentUrl
+    }
+
+    private fun isCriticalCaptchaRequest(
+        state: CaptchaLoadState,
+        request: WebResourceRequest?,
+    ): Boolean {
+        val resourceRequest = request ?: return false
+        if (resourceRequest.isForMainFrame) return resourceRequest.url.toString() == state.documentUrl
+        return isCriticalCaptchaUri(state, resourceRequest.url)
+    }
+
+    private fun isCriticalCaptchaUrl(
+        state: CaptchaLoadState,
+        url: String?,
+    ): Boolean {
+        if (url == state.documentUrl) return true
+        return isCriticalCaptchaUri(state, url?.let(Uri::parse))
+    }
+
+    private fun isCriticalCaptchaUri(
+        state: CaptchaLoadState,
+        uri: Uri?,
+    ) = isCaptchaApiUri(state.type, uri) && uri?.getQueryParameter("onload") == state.scriptOnloadCallback
+
+    private fun isStaleCaptchaApiUrl(
+        state: CaptchaLoadState,
+        url: String?,
+    ): Boolean {
+        val uri = url?.let(Uri::parse) ?: return false
+        return isCaptchaApiUri(state.type, uri) && !isCriticalCaptchaUri(state, uri)
+    }
+
+    private fun isCaptchaApiUri(
+        captchaType: CaptchaType,
+        uri: Uri?,
+    ): Boolean {
+        if (uri == null) return false
+        return when (captchaType) {
+            CaptchaType.GCaptcha -> uri.host == "www.recaptcha.net" && uri.path == "/recaptcha/api.js"
+            CaptchaType.HCaptcha -> uri.host == "js.hcaptcha.com" && uri.path == "/1/api.js"
+            CaptchaType.GTCaptcha -> false
         }
     }
 
+    private fun captchaResource(request: WebResourceRequest?): String {
+        val uri = request?.url ?: return "unknown"
+        return "${uri.host.orEmpty()}${uri.path.orEmpty()}"
+    }
+
+    private fun captchaResource(url: String?): String {
+        val uri = url?.let(Uri::parse) ?: return "unknown"
+        return "${uri.host.orEmpty()}${uri.path.orEmpty()}"
+    }
+
+    private fun logCaptchaWebError(
+        state: CaptchaLoadState,
+        reason: String,
+        detail: String,
+    ) {
+        val message = "$TAG load ${state.type} stage=${state.stage} reason=$reason $detail"
+        state.lastWebError = "$reason $detail".take(200)
+        Timber.e(message)
+    }
+
     private fun show() {
         val dialog = captchaDialog ?: createDialog().also {
             captchaDialog = it
@@ -344,7 +609,7 @@ class CaptchaView(private val context: Context, private val callback: Callback)
             try {
                 dialog.show()
             } catch (e: Exception) {
-                Timber.e(e, "$TAG show dialog failed captchaType=$captchaType")
+                Timber.e(e, "$TAG show dialog failed captchaType=${activeCaptchaLoad?.type}")
                 reportException(e)
             }
         }
@@ -411,47 +676,72 @@ class CaptchaView(private val context: Context, private val callback: Callback)
     fun release() {
         if (released) return
         released = true
-        cancelRunOnUiThread(stopWebViewRunnable)
+        invalidateActiveCaptchaLoad()
         val dialog = captchaDialog
         captchaDialog = null
         dialog?.dismiss()
         if (!webViewLazy.isInitialized()) return
         webView.webChromeClient = object : WebChromeClient() {}
-        webView.loadUrl("about:blank")
         webView.webViewClient = object : WebViewClient() {}
+        webView.loadUrl("about:blank")
         (webView.parent as? ViewGroup)?.removeView(webView)
         webView.destroy()
     }
 
     private fun stopCaptcha() {
-        cancelRunOnUiThread(stopWebViewRunnable)
+        invalidateActiveCaptchaLoad()
         updateProgress(100)
         if (!webViewLazy.isInitialized()) return
         webView.translationY(context.screenHeight().toFloat())
         webView.webChromeClient = object : WebChromeClient() {}
-        webView.loadUrl("about:blank")
         webView.webViewClient = object : WebViewClient() {}
+        webView.loadUrl("about:blank")
     }
 
     @Suppress("unused")
     @JavascriptInterface
-    fun postMessage(
-        @Suppress("UNUSED_PARAMETER") value: String,
+    fun postEvent(
+        loadId: String,
+        event: String,
+        stage: String,
+        detail: String,
     ) {
         if (released) return
-        if (value.isBlank()) return
-        Timber.e("$TAG postMessage captchaType=$captchaType value=$value")
-        cancelRunOnUiThread(stopWebViewRunnable)
-        runOnUiThread(stopWebViewRunnable)
+        webView.post {
+            if (released) return@post
+            when (event) {
+                EVENT_PROGRESS -> {
+                    val loadEvent =
+                        when (stage) {
+                            STAGE_SDK_LOADED -> CaptchaLoadEvent.SdkLoaded
+                            STAGE_WIDGET_RENDERED -> CaptchaLoadEvent.WidgetRendered
+                            else -> null
+                        }
+                    if (loadEvent != null) {
+                        handleCaptchaLoadEvent(loadId, loadEvent, stage)
+                    }
+                }
+
+                EVENT_READY -> handleCaptchaLoadEvent(loadId, CaptchaLoadEvent.ChallengeReady, STAGE_CHALLENGE_READY)
+                EVENT_ERROR -> failCaptchaLoad(loadId, stage.ifBlank { "provider_error" }, detail)
+                EVENT_CANCEL -> cancelCaptchaLoad(loadId)
+            }
+        }
     }
 
     @Suppress("unused")
     @JavascriptInterface
-    fun postToken(value: String) {
+    fun postToken(
+        loadId: String,
+        value: String,
+    ) {
         if (released) return
-        cancelRunOnUiThread(stopWebViewRunnable)
         webView.post {
             if (released) return@post
+            val state = activeCaptchaLoad(loadId) ?: return@post
+            state.settled = true
+            cancelCaptchaTimeout(state)
+            val captchaType = state.type
             hide()
             callback.onPostToken(Pair(captchaType, value))
         }
diff --git a/app/src/test/java/one/mixin/android/widget/CaptchaLoadDecisionTest.kt b/app/src/test/java/one/mixin/android/widget/CaptchaLoadDecisionTest.kt
new file mode 100644
index 0000000000..9bf0f9980f
--- /dev/null
+++ b/app/src/test/java/one/mixin/android/widget/CaptchaLoadDecisionTest.kt
@@ -0,0 +1,76 @@
+package one.mixin.android.widget
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class CaptchaLoadDecisionTest {
+    @Test
+    fun pageFinishedKeepsWatchingForCaptchaReadiness() {
+        assertEquals(
+            CaptchaLoadAction.KeepWatching,
+            decideCaptchaLoadAction(
+                event = CaptchaLoadEvent.PageFinished,
+                captchaType = CaptchaView.CaptchaType.HCaptcha,
+                failureCount = 0,
+                maxFailureCount = 6,
+                fallbackEnabled = true,
+            ),
+        )
+    }
+
+    @Test
+    fun challengeReadyKeepsWatchingForTerminalEvent() {
+        assertEquals(
+            CaptchaLoadAction.RestartWatchdog,
+            decideCaptchaLoadAction(
+                event = CaptchaLoadEvent.ChallengeReady,
+                captchaType = CaptchaView.CaptchaType.HCaptcha,
+                failureCount = 0,
+                maxFailureCount = 6,
+                fallbackEnabled = true,
+            ),
+        )
+    }
+
+    @Test
+    fun hCaptchaFatalErrorSwitchesToGeeTest() {
+        assertEquals(
+            CaptchaLoadAction.SwitchTo(CaptchaView.CaptchaType.GTCaptcha),
+            decideCaptchaLoadAction(
+                event = CaptchaLoadEvent.FatalError,
+                captchaType = CaptchaView.CaptchaType.HCaptcha,
+                failureCount = 2,
+                maxFailureCount = 6,
+                fallbackEnabled = true,
+            ),
+        )
+    }
+
+    @Test
+    fun firstFailedCycleContinuesWithNextCaptcha() {
+        assertEquals(
+            CaptchaLoadAction.SwitchTo(CaptchaView.CaptchaType.GCaptcha),
+            decideCaptchaLoadAction(
+                event = CaptchaLoadEvent.FatalError,
+                captchaType = CaptchaView.CaptchaType.GTCaptcha,
+                failureCount = 3,
+                maxFailureCount = 6,
+                fallbackEnabled = true,
+            ),
+        )
+    }
+
+    @Test
+    fun secondFailedCycleStopsFallback() {
+        assertEquals(
+            CaptchaLoadAction.Stop,
+            decideCaptchaLoadAction(
+                event = CaptchaLoadEvent.FatalError,
+                captchaType = CaptchaView.CaptchaType.GTCaptcha,
+                failureCount = 6,
+                maxFailureCount = 6,
+                fallbackEnabled = true,
+            ),
+        )
+    }
+}