diff --git a/.changeset/bright-cards-handle-3ds.md b/.changeset/bright-cards-handle-3ds.md
new file mode 100644
index 00000000..628b005c
--- /dev/null
+++ b/.changeset/bright-cards-handle-3ds.md
@@ -0,0 +1,8 @@
+---
+'@godaddy/react': patch
+'@godaddy/localizations': patch
+---
+
+Add Stripe 3DS verification support for card and express checkout, with localized payment errors and compatibility with existing checkout error handling.
+
+Improve payment retry handling, prevent duplicate submissions, and recognize already-paid orders. Update express payment tracking to reflect the payment method used and successful checkout completion.
diff --git a/packages/localizations/src/deDe.ts b/packages/localizations/src/deDe.ts
index 33dfc622..693ad835 100644
--- a/packages/localizations/src/deDe.ts
+++ b/packages/localizations/src/deDe.ts
@@ -291,6 +291,8 @@ export const deDe = {
     DRAFT_ORDER_RETRIEVAL_FAILED: 'Abrufen der Bestellung fehlgeschlagen',
     DATA_SOURCES_NOT_FOUND: 'Datenquellen nicht gefunden',
     TRANSACTION_API_NOT_FOUND: 'Transaktions-API-Datenquelle nicht gefunden',
+    PAYMENT_ACTION_REQUIRED:
+      'Deine Zahlung erfordert eine zusätzliche Bestätigung. Versuche es erneut oder wähle eine andere Zahlungsmethode.',
     TRANSACTION_PROCESSING_FAILED:
       'Verarbeitung der Transaktion fehlgeschlagen',
     TRANSACTION_CREATION_FAILED:
diff --git a/packages/localizations/src/enAu.ts b/packages/localizations/src/enAu.ts
index 59815771..489c8bf0 100644
--- a/packages/localizations/src/enAu.ts
+++ b/packages/localizations/src/enAu.ts
@@ -278,6 +278,8 @@ export const enAu = {
     DRAFT_ORDER_RETRIEVAL_FAILED: 'Failed to retrieve order',
     DATA_SOURCES_NOT_FOUND: 'Data sources not found',
     TRANSACTION_API_NOT_FOUND: 'Transaction API data source not found',
+    PAYMENT_ACTION_REQUIRED:
+      'Your payment needs additional verification. Please try again or choose another payment method.',
     TRANSACTION_PROCESSING_FAILED: 'Failed to process transaction',
     TRANSACTION_CREATION_FAILED: 'Failed to find or create transaction',
     ORDER_OPENING_FAILED: 'Failed to open order',
diff --git a/packages/localizations/src/enIe.ts b/packages/localizations/src/enIe.ts
index 89470301..223fd71e 100644
--- a/packages/localizations/src/enIe.ts
+++ b/packages/localizations/src/enIe.ts
@@ -278,6 +278,8 @@ export const enIe = {
     DRAFT_ORDER_RETRIEVAL_FAILED: 'Failed to retrieve order',
     DATA_SOURCES_NOT_FOUND: 'Data sources not found',
     TRANSACTION_API_NOT_FOUND: 'Transaction API data source not found',
+    PAYMENT_ACTION_REQUIRED:
+      'Your payment needs additional verification. Please try again or choose another payment method.',
     TRANSACTION_PROCESSING_FAILED: 'Failed to process transaction',
     TRANSACTION_CREATION_FAILED: 'Failed to find or create transaction',
     ORDER_OPENING_FAILED: 'Failed to open order',
diff --git a/packages/localizations/src/enUs.ts b/packages/localizations/src/enUs.ts
index 95a556da..46afd1ed 100644
--- a/packages/localizations/src/enUs.ts
+++ b/packages/localizations/src/enUs.ts
@@ -278,6 +278,8 @@ export const enUs = {
     DRAFT_ORDER_RETRIEVAL_FAILED: 'Failed to retrieve order',
     DATA_SOURCES_NOT_FOUND: 'Data sources not found',
     TRANSACTION_API_NOT_FOUND: 'Transaction API data source not found',
+    PAYMENT_ACTION_REQUIRED:
+      'Your payment needs additional verification. Please try again or choose another payment method.',
     TRANSACTION_PROCESSING_FAILED: 'Failed to process transaction',
     TRANSACTION_CREATION_FAILED: 'Failed to find or create transaction',
     ORDER_OPENING_FAILED: 'Failed to open order',
diff --git a/packages/localizations/src/esAr.ts b/packages/localizations/src/esAr.ts
index 8128fee0..dc11d7b6 100644
--- a/packages/localizations/src/esAr.ts
+++ b/packages/localizations/src/esAr.ts
@@ -284,6 +284,8 @@ export const esAr = {
     DATA_SOURCES_NOT_FOUND: 'Fuentes de datos no encontradas',
     TRANSACTION_API_NOT_FOUND:
       'Fuente de datos de API de transacciones no encontrada',
+    PAYMENT_ACTION_REQUIRED:
+      'Tu pago requiere una verificación adicional. Inténtalo de nuevo o elige otro método de pago.',
     TRANSACTION_PROCESSING_FAILED: 'Error al procesar transacción',
     TRANSACTION_CREATION_FAILED: 'Error al encontrar o crear transacción',
     ORDER_OPENING_FAILED: 'Error al abrir pedido',
diff --git a/packages/localizations/src/esCl.ts b/packages/localizations/src/esCl.ts
index ccb43c9a..f46b1c60 100644
--- a/packages/localizations/src/esCl.ts
+++ b/packages/localizations/src/esCl.ts
@@ -286,6 +286,8 @@ export const esCl = {
     DATA_SOURCES_NOT_FOUND: 'Fuentes de datos no encontradas',
     TRANSACTION_API_NOT_FOUND:
       'Fuente de datos de API de transacción no encontrada',
+    PAYMENT_ACTION_REQUIRED:
+      'Tu pago requiere una verificación adicional. Inténtalo de nuevo o elige otro método de pago.',
     TRANSACTION_PROCESSING_FAILED: 'Error al procesar transacción',
     TRANSACTION_CREATION_FAILED: 'Error al encontrar o crear transacción',
     ORDER_OPENING_FAILED: 'Error al abrir pedido',
diff --git a/packages/localizations/src/esCo.ts b/packages/localizations/src/esCo.ts
index b80b2f9c..acdc1229 100644
--- a/packages/localizations/src/esCo.ts
+++ b/packages/localizations/src/esCo.ts
@@ -284,6 +284,8 @@ export const esCo = {
     DATA_SOURCES_NOT_FOUND: 'Fuentes de datos no encontradas',
     TRANSACTION_API_NOT_FOUND:
       'Fuente de datos de API de transacciones no encontrada',
+    PAYMENT_ACTION_REQUIRED:
+      'Tu pago requiere una verificación adicional. Inténtalo de nuevo o elige otro método de pago.',
     TRANSACTION_PROCESSING_FAILED: 'Error al procesar transacción',
     TRANSACTION_CREATION_FAILED: 'Error al encontrar o crear transacción',
     ORDER_OPENING_FAILED: 'Error al abrir pedido',
diff --git a/packages/localizations/src/esEs.ts b/packages/localizations/src/esEs.ts
index 013cf3a6..440d8b7a 100644
--- a/packages/localizations/src/esEs.ts
+++ b/packages/localizations/src/esEs.ts
@@ -287,6 +287,8 @@ export const esEs = {
     DATA_SOURCES_NOT_FOUND: 'Fuentes de datos no encontradas',
     TRANSACTION_API_NOT_FOUND:
       'Fuente de datos de la API de transacciones no encontrada',
+    PAYMENT_ACTION_REQUIRED:
+      'Tu pago requiere una verificación adicional. Inténtalo de nuevo o elige otro método de pago.',
     TRANSACTION_PROCESSING_FAILED: 'No se pudo procesar la transacción',
     TRANSACTION_CREATION_FAILED: 'No se pudo encontrar o crear la transacción',
     ORDER_OPENING_FAILED: 'No se pudo abrir el pedido',
diff --git a/packages/localizations/src/esMx.ts b/packages/localizations/src/esMx.ts
index 171dc3c8..7626582a 100644
--- a/packages/localizations/src/esMx.ts
+++ b/packages/localizations/src/esMx.ts
@@ -284,6 +284,8 @@ export const esMx = {
     DATA_SOURCES_NOT_FOUND: 'Fuentes de datos no encontradas',
     TRANSACTION_API_NOT_FOUND:
       'Fuente de datos de API de transacciones no encontrada',
+    PAYMENT_ACTION_REQUIRED:
+      'Tu pago requiere una verificación adicional. Inténtalo de nuevo o elige otro método de pago.',
     TRANSACTION_PROCESSING_FAILED: 'Error al procesar transacción',
     TRANSACTION_CREATION_FAILED: 'Error al encontrar o crear transacción',
     ORDER_OPENING_FAILED: 'Error al abrir pedido',
diff --git a/packages/localizations/src/esPe.ts b/packages/localizations/src/esPe.ts
index 3d1f4f36..ce5b55a8 100644
--- a/packages/localizations/src/esPe.ts
+++ b/packages/localizations/src/esPe.ts
@@ -284,6 +284,8 @@ export const esPe = {
     DATA_SOURCES_NOT_FOUND: 'Fuentes de datos no encontradas',
     TRANSACTION_API_NOT_FOUND:
       'Fuente de datos de API de transacciones no encontrada',
+    PAYMENT_ACTION_REQUIRED:
+      'Tu pago requiere una verificación adicional. Inténtalo de nuevo o elige otro método de pago.',
     TRANSACTION_PROCESSING_FAILED: 'Error al procesar transacción',
     TRANSACTION_CREATION_FAILED: 'Error al encontrar o crear transacción',
     ORDER_OPENING_FAILED: 'Error al abrir pedido',
diff --git a/packages/localizations/src/esUs.ts b/packages/localizations/src/esUs.ts
index fc77429b..ad3e6bfd 100644
--- a/packages/localizations/src/esUs.ts
+++ b/packages/localizations/src/esUs.ts
@@ -284,6 +284,8 @@ export const esUs = {
     DATA_SOURCES_NOT_FOUND: 'Fuentes de datos no encontradas',
     TRANSACTION_API_NOT_FOUND:
       'Fuente de datos de Transaction API no encontrada',
+    PAYMENT_ACTION_REQUIRED:
+      'Tu pago requiere una verificación adicional. Inténtalo de nuevo o elige otro método de pago.',
     TRANSACTION_PROCESSING_FAILED: 'Error al procesar transacción',
     TRANSACTION_CREATION_FAILED: 'Error al encontrar o crear transacción',
     ORDER_OPENING_FAILED: 'Error al abrir pedido',
diff --git a/packages/localizations/src/frCa.ts b/packages/localizations/src/frCa.ts
index 4f4eed86..dc675271 100644
--- a/packages/localizations/src/frCa.ts
+++ b/packages/localizations/src/frCa.ts
@@ -293,6 +293,8 @@ export const frCa = {
     DATA_SOURCES_NOT_FOUND: 'Sources de données introuvables',
     TRANSACTION_API_NOT_FOUND:
       'Source de données API de transaction introuvable',
+    PAYMENT_ACTION_REQUIRED:
+      'Votre paiement nécessite une vérification supplémentaire. Réessayez ou choisissez un autre moyen de paiement.',
     TRANSACTION_PROCESSING_FAILED: 'Échec du traitement de la transaction',
     TRANSACTION_CREATION_FAILED:
       'Échec de la recherche ou création de transaction',
diff --git a/packages/localizations/src/frFr.ts b/packages/localizations/src/frFr.ts
index 09d4c91a..8fa34c4f 100644
--- a/packages/localizations/src/frFr.ts
+++ b/packages/localizations/src/frFr.ts
@@ -293,6 +293,8 @@ export const frFr = {
     DATA_SOURCES_NOT_FOUND: 'Sources de données non trouvées',
     TRANSACTION_API_NOT_FOUND:
       "Source de données de l'API de transaction non trouvée",
+    PAYMENT_ACTION_REQUIRED:
+      'Votre paiement nécessite une vérification supplémentaire. Réessayez ou choisissez un autre moyen de paiement.',
     TRANSACTION_PROCESSING_FAILED: 'Échec du traitement de la transaction',
     TRANSACTION_CREATION_FAILED:
       'Échec de la recherche ou de la création de la transaction',
diff --git a/packages/localizations/src/idId.ts b/packages/localizations/src/idId.ts
index 4bdc412e..c067c1be 100644
--- a/packages/localizations/src/idId.ts
+++ b/packages/localizations/src/idId.ts
@@ -278,6 +278,8 @@ export const idId = {
     DRAFT_ORDER_RETRIEVAL_FAILED: 'Gagal mengambil pesanan',
     DATA_SOURCES_NOT_FOUND: 'Sumber data tidak ditemukan',
     TRANSACTION_API_NOT_FOUND: 'Sumber data API transaksi tidak ditemukan',
+    PAYMENT_ACTION_REQUIRED:
+      'Pembayaran Anda memerlukan verifikasi tambahan. Coba lagi atau pilih metode pembayaran lain.',
     TRANSACTION_PROCESSING_FAILED: 'Gagal memproses transaksi',
     TRANSACTION_CREATION_FAILED: 'Gagal menemukan atau membuat transaksi',
     ORDER_OPENING_FAILED: 'Gagal membuka pesanan',
diff --git a/packages/localizations/src/itIt.ts b/packages/localizations/src/itIt.ts
index de2515f5..afe1aa51 100644
--- a/packages/localizations/src/itIt.ts
+++ b/packages/localizations/src/itIt.ts
@@ -292,6 +292,8 @@ export const itIt = {
     DRAFT_ORDER_RETRIEVAL_FAILED: "Errore nel recupero dell'ordine",
     DATA_SOURCES_NOT_FOUND: 'Fonti dati non trovate',
     TRANSACTION_API_NOT_FOUND: 'Fonte dati API transazioni non trovata',
+    PAYMENT_ACTION_REQUIRED:
+      'Il pagamento richiede una verifica aggiuntiva. Riprova o scegli un altro metodo di pagamento.',
     TRANSACTION_PROCESSING_FAILED: "Errore nell'elaborazione della transazione",
     TRANSACTION_CREATION_FAILED:
       'Errore nella ricerca o creazione della transazione',
diff --git a/packages/localizations/src/ptBr.ts b/packages/localizations/src/ptBr.ts
index d47a9bba..c59ae720 100644
--- a/packages/localizations/src/ptBr.ts
+++ b/packages/localizations/src/ptBr.ts
@@ -282,6 +282,8 @@ export const ptBr = {
     DATA_SOURCES_NOT_FOUND: 'Fontes de dados não encontradas',
     TRANSACTION_API_NOT_FOUND:
       'Fonte de dados da API de transação não encontrada',
+    PAYMENT_ACTION_REQUIRED:
+      'Seu pagamento precisa de uma verificação adicional. Tente novamente ou escolha outra forma de pagamento.',
     TRANSACTION_PROCESSING_FAILED: 'Falha ao processar transação',
     TRANSACTION_CREATION_FAILED: 'Falha ao encontrar ou criar transação',
     ORDER_OPENING_FAILED: 'Falha ao abrir pedido',
diff --git a/packages/localizations/src/qaPs.ts b/packages/localizations/src/qaPs.ts
index 208d5935..961e5c78 100644
--- a/packages/localizations/src/qaPs.ts
+++ b/packages/localizations/src/qaPs.ts
@@ -286,6 +286,8 @@ export const qaPs = {
     DRAFT_ORDER_RETRIEVAL_FAILED: '[Fâîlëd ţö rëţrîëvë ördër]',
     DATA_SOURCES_NOT_FOUND: '[Dâţâ šöürçëš ñöţ föüñd îñ šÿšţëm]',
     TRANSACTION_API_NOT_FOUND: '[Ţrâñšâçţîöñ ÂÞÎ dâţâ šöürçë ñöţ föüñd]',
+    PAYMENT_ACTION_REQUIRED:
+      '[Your payment needs additional verification. Please try again or choose another payment method.]',
     TRANSACTION_PROCESSING_FAILED: '[Fâîlëd ţö þröçëšš ţrâñšâçţîöñ]',
     TRANSACTION_CREATION_FAILED: '[Fâîlëd ţö fîñd ör çrëâţë ţrâñšâçţîöñ]',
     ORDER_OPENING_FAILED: '[Fâîlëd ţö öþëñ ördër fôr þröçëššîñg]',
diff --git a/packages/localizations/src/trTr.ts b/packages/localizations/src/trTr.ts
index daa63b5e..1244116c 100644
--- a/packages/localizations/src/trTr.ts
+++ b/packages/localizations/src/trTr.ts
@@ -280,6 +280,8 @@ export const trTr = {
     DRAFT_ORDER_RETRIEVAL_FAILED: 'Sipariş alınamadı',
     DATA_SOURCES_NOT_FOUND: 'Veri kaynakları bulunamadı',
     TRANSACTION_API_NOT_FOUND: 'İşlem API veri kaynağı bulunamadı',
+    PAYMENT_ACTION_REQUIRED:
+      'Ödemeniz için ek doğrulama gerekiyor. Lütfen tekrar deneyin veya başka bir ödeme yöntemi seçin.',
     TRANSACTION_PROCESSING_FAILED: 'İşlem işlenemedi',
     TRANSACTION_CREATION_FAILED: 'İşlem bulunamadı veya oluşturulamadı',
     ORDER_OPENING_FAILED: 'Sipariş açılamadı',
diff --git a/packages/localizations/src/viVn.ts b/packages/localizations/src/viVn.ts
index 37ff3b91..04ed1f20 100644
--- a/packages/localizations/src/viVn.ts
+++ b/packages/localizations/src/viVn.ts
@@ -278,6 +278,8 @@ export const viVn = {
     DRAFT_ORDER_RETRIEVAL_FAILED: 'Không thể truy xuất đơn hàng',
     DATA_SOURCES_NOT_FOUND: 'Không tìm thấy nguồn dữ liệu',
     TRANSACTION_API_NOT_FOUND: 'Không tìm thấy nguồn dữ liệu API giao dịch',
+    PAYMENT_ACTION_REQUIRED:
+      'Thanh toán của bạn cần được xác minh thêm. Vui lòng thử lại hoặc chọn phương thức thanh toán khác.',
     TRANSACTION_PROCESSING_FAILED: 'Không thể xử lý giao dịch',
     TRANSACTION_CREATION_FAILED: 'Không thể tìm hoặc tạo giao dịch',
     ORDER_OPENING_FAILED: 'Không thể mở đơn hàng',
diff --git a/packages/localizations/src/zhCn.ts b/packages/localizations/src/zhCn.ts
index 19eb5bf9..866be391 100644
--- a/packages/localizations/src/zhCn.ts
+++ b/packages/localizations/src/zhCn.ts
@@ -270,6 +270,7 @@ export const zhCn = {
     DRAFT_ORDER_RETRIEVAL_FAILED: '获取订单失败',
     DATA_SOURCES_NOT_FOUND: '数据源未找到',
     TRANSACTION_API_NOT_FOUND: '交易 API 数据源未找到',
+    PAYMENT_ACTION_REQUIRED: '您的付款需要额外验证。请重试或选择其他付款方式。',
     TRANSACTION_PROCESSING_FAILED: '处理交易失败',
     TRANSACTION_CREATION_FAILED: '查找或创建交易失败',
     ORDER_OPENING_FAILED: '打开订单失败',
diff --git a/packages/localizations/src/zhSg.ts b/packages/localizations/src/zhSg.ts
index 52f1938b..4345466b 100644
--- a/packages/localizations/src/zhSg.ts
+++ b/packages/localizations/src/zhSg.ts
@@ -270,6 +270,7 @@ export const zhSg = {
     DRAFT_ORDER_RETRIEVAL_FAILED: '检索订单失败',
     DATA_SOURCES_NOT_FOUND: '数据源未找到',
     TRANSACTION_API_NOT_FOUND: '交易API数据源未找到',
+    PAYMENT_ACTION_REQUIRED: '您的付款需要额外验证。请重试或选择其他付款方式。',
     TRANSACTION_PROCESSING_FAILED: '处理交易失败',
     TRANSACTION_CREATION_FAILED: '查找或创建交易失败',
     ORDER_OPENING_FAILED: '打开订单失败',
diff --git a/packages/react/src/components/checkout/__tests__/checkout-confirm-errors.test.tsx b/packages/react/src/components/checkout/__tests__/checkout-confirm-errors.test.tsx
index 1724ab89..868da75a 100644
--- a/packages/react/src/components/checkout/__tests__/checkout-confirm-errors.test.tsx
+++ b/packages/react/src/components/checkout/__tests__/checkout-confirm-errors.test.tsx
@@ -1,7 +1,7 @@
-import { fireEvent, screen, waitFor } from '@testing-library/react';
+import { act, fireEvent, screen, waitFor } from '@testing-library/react';
 import { useState } from 'react';
 import { useFormContext } from 'react-hook-form';
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 import { useCheckoutContext } from '@/components/checkout/checkout';
 import { DeliveryMethods } from '@/components/checkout/delivery/delivery-methods';
 import {
@@ -9,6 +9,7 @@ import {
   PaymentProvider,
   useConfirmCheckout,
 } from '@/components/checkout/payment/utils/use-confirm-checkout';
+import { confirmCheckout } from '@/lib/godaddy/godaddy';
 import { GraphQLErrorWithCodes } from '@/lib/graphql-with-errors';
 import {
   buildCheckoutSession,
@@ -19,9 +20,11 @@ import {
   clearOperations,
   getOperations,
   mockGodaddyApi,
+  mockWindowLocation,
   type RenderCheckoutOptions,
   renderCheckout,
   setApiError,
+  setCurrentDraftOrder,
   waitForCheckoutReady,
   waitForOperation,
 } from './checkout-test-env';
@@ -98,7 +101,7 @@ function ConfirmSeamButton({
   paymentType = isExpress ? 'apple_pay' : 'offline',
   paymentProvider = isExpress ? PaymentProvider.POYNT : PaymentProvider.OFFLINE,
 }: ConfirmSeamProps) {
-  const confirmCheckout = useConfirmCheckout();
+  const confirmation = useConfirmCheckout();
   const form = useFormContext();
   const { setCheckoutErrors } = useCheckoutContext();
 
@@ -112,7 +115,7 @@ function ConfirmSeamButton({
             form.setValue(key, value);
           }
         }
-        void confirmCheckout
+        void confirmation
           .mutateAsync({
             paymentToken: isExpress ? 'express-nonce' : '',
             paymentType,
@@ -140,7 +143,7 @@ function ConfirmSeamButton({
 }
 
 function DuplicateConfirmSeamButton() {
-  const confirmCheckout = useConfirmCheckout();
+  const confirmation = useConfirmCheckout();
   const form = useFormContext();
   const [secondResult, setSecondResult] = useState('idle');
 
@@ -156,8 +159,8 @@ function DuplicateConfirmSeamButton() {
             paymentProvider: PaymentProvider.OFFLINE,
           };
 
-          void confirmCheckout.mutateAsync(input).catch(() => undefined);
-          void confirmCheckout
+          void confirmation.mutateAsync(input).catch(() => undefined);
+          void confirmation
             .mutateAsync(input)
             .then(() => setSecondResult('resolved'))
             .catch(err => {
@@ -346,6 +349,45 @@ describe('Checkout confirm errors', () => {
     expect(window.location.href).not.toContain('should-not-go-here');
   });
 
+  it('refreshes after a lost confirmation response and redirects the paid order', async () => {
+    mockWindowLocation();
+    const successUrl = 'https://merchant.example/success';
+    const { user } = renderCheckoutWithConfirmSeam(
+      {
+        sessionOverrides: { ...offlineSessionOverrides(), successUrl },
+      },
+      {
+        isExpress: true,
+        paymentType: 'offline',
+        paymentProvider: PaymentProvider.OFFLINE,
+      }
+    );
+    await waitForCheckoutReady();
+    vi.mocked(confirmCheckout).mockImplementationOnce(async () => {
+      // The payment landed even though its response was lost.
+      setCurrentDraftOrder(
+        buildDraftOrder({
+          statuses: { status: 'OPEN', paymentStatus: 'PAID' },
+        })
+      );
+      throw new Error('Confirmation response lost');
+    });
+    await user.click(
+      await screen.findByRole('button', { name: /confirm seam/i })
+    );
+    expect(await screen.findByRole('status')).toHaveTextContent(
+      'Payment successful'
+    );
+    expect(
+      screen.queryByRole('button', { name: /confirm seam/i })
+    ).not.toBeInTheDocument();
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(1100);
+    });
+    expect(window.location.href).toBe(successUrl);
+    expect(confirmCheckout).toHaveBeenCalledTimes(1);
+  });
+
   it('surfaces DRAFT_ORDER_UPDATE_FAILED when the in-confirm draft-order fetch fails', async () => {
     const draftOrder = buildDraftOrder();
     const session = buildCheckoutSession({
diff --git a/packages/react/src/components/checkout/__tests__/checkout-error-list.test.tsx b/packages/react/src/components/checkout/__tests__/checkout-error-list.test.tsx
index 41564091..e03ed9ef 100644
--- a/packages/react/src/components/checkout/__tests__/checkout-error-list.test.tsx
+++ b/packages/react/src/components/checkout/__tests__/checkout-error-list.test.tsx
@@ -71,6 +71,16 @@ describe('CheckoutErrorList', () => {
     expect(screen.getByText('CUSTOM_RAW_CODE')).toBeInTheDocument();
   });
 
+  it('renders a localized action-required message', () => {
+    renderErrorList({ checkoutErrors: ['PAYMENT_ACTION_REQUIRED'] });
+    expect(
+      screen.getByText(enUs.apiErrors.PAYMENT_ACTION_REQUIRED)
+    ).toBeInTheDocument();
+    expect(
+      screen.queryByText('PAYMENT_ACTION_REQUIRED')
+    ).not.toBeInTheDocument();
+  });
+
   it('renders checkout disabled copy with checkout errors', () => {
     renderErrorList({
       checkoutErrors: ['TRANSACTION_PROCESSING_FAILED'],
diff --git a/packages/react/src/components/checkout/__tests__/checkout-paid-order.test.tsx b/packages/react/src/components/checkout/__tests__/checkout-paid-order.test.tsx
new file mode 100644
index 00000000..e24e8494
--- /dev/null
+++ b/packages/react/src/components/checkout/__tests__/checkout-paid-order.test.tsx
@@ -0,0 +1,193 @@
+import { act, screen, waitFor } from '@testing-library/react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { checkoutQueryKeys } from '@/components/checkout/utils/query-keys';
+import {
+  getOperations,
+  mockWindowLocation,
+  renderCheckout,
+  waitForCheckoutReady,
+} from './checkout-test-env';
+
+describe('Checkout paid-order recovery', () => {
+  beforeEach(() => {
+    mockWindowLocation();
+  });
+
+  it('redirects a paid order to the session success URL without showing payment controls', async () => {
+    const successUrl = 'https://merchant.example/success';
+    renderCheckout({
+      sessionOverrides: { successUrl },
+      draftOrderOverrides: {
+        statuses: { status: 'OPEN', paymentStatus: 'PAID' },
+      },
+    });
+
+    expect(await screen.findByRole('status')).toHaveTextContent(
+      'Payment successful'
+    );
+    expect(
+      screen.queryByRole('button', { name: /pay now/i })
+    ).not.toBeInTheDocument();
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(1100);
+    });
+    expect(window.location.href).toBe(successUrl);
+    expect(getOperations('ConfirmCheckoutSession')).toHaveLength(0);
+  });
+
+  it('keeps payment controls hidden when a paid order has no success URL', async () => {
+    const initialUrl = window.location.href;
+    renderCheckout({
+      draftOrderOverrides: {
+        statuses: { status: 'OPEN', paymentStatus: 'PAID' },
+      },
+    });
+
+    expect(await screen.findByRole('status')).toHaveTextContent(
+      'Payment successful'
+    );
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(1100);
+    });
+    expect(window.location.href).toBe(initialUrl);
+    expect(
+      screen.queryByRole('button', { name: /pay now/i })
+    ).not.toBeInTheDocument();
+  });
+
+  it('only looks up order status when the draft order is unavailable', async () => {
+    renderCheckout({
+      draftOrderOverrides: { statuses: { paymentStatus: 'UNPAID' } },
+    });
+    await waitForCheckoutReady();
+    act(() => {
+      window.dispatchEvent(new Event('focus'));
+    });
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(1100);
+    });
+    expect(getOperations('CheckoutOrderStatus')).toHaveLength(0);
+  });
+
+  it('looks up order status once for a paid order', async () => {
+    renderCheckout({
+      draftOrderOverrides: {
+        statuses: { status: 'OPEN', paymentStatus: 'PAID' },
+      },
+    });
+    expect(await screen.findByRole('status')).toHaveTextContent(
+      'Payment successful'
+    );
+    expect(getOperations('CheckoutOrderStatus')).toHaveLength(1);
+  });
+
+  it('sends a paid order to the success URL rather than the return URL', async () => {
+    const successUrl = 'https://merchant.example/success';
+    renderCheckout({
+      sessionOverrides: {
+        successUrl,
+        returnUrl: 'https://merchant.example/cart',
+      },
+      draftOrderOverrides: {
+        statuses: { status: 'OPEN', paymentStatus: 'PAID' },
+      },
+    });
+
+    expect(await screen.findByRole('status')).toHaveTextContent(
+      'Payment successful'
+    );
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(1100);
+    });
+    expect(window.location.href).toBe(successUrl);
+  });
+
+  it.each([
+    {
+      name: 'the API cannot report order status',
+      statuses: { status: 'OPEN', paymentStatus: 'PAID' },
+      errors: { getCheckoutOrderStatus: new Error('Cannot query field') },
+    },
+    {
+      name: 'the order was canceled',
+      statuses: { status: 'CANCELED', paymentStatus: 'PAID' },
+      errors: {},
+    },
+  ])(
+    'falls back to the return URL without a draft order when $name',
+    async ({ statuses, errors }) => {
+      const returnUrl = 'https://merchant.example/cart';
+      renderCheckout({
+        sessionOverrides: {
+          successUrl: 'https://merchant.example/success',
+          returnUrl,
+        },
+        draftOrderOverrides: { statuses },
+        apiOverrides: { errors },
+      });
+
+      await waitFor(() => expect(window.location.href).toBe(returnUrl));
+      expect(screen.queryByText('Payment successful')).not.toBeInTheDocument();
+    }
+  );
+
+  it('redirects an offline order whose payment is PENDING', async () => {
+    const successUrl = 'https://merchant.example/success';
+    renderCheckout({
+      sessionOverrides: { successUrl },
+      draftOrderOverrides: {
+        statuses: { status: 'OPEN', paymentStatus: 'PENDING' },
+      },
+    });
+
+    expect(await screen.findByRole('status')).toHaveTextContent(
+      'Payment successful'
+    );
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(1100);
+    });
+    expect(window.location.href).toBe(successUrl);
+    expect(getOperations('ConfirmCheckoutSession')).toHaveLength(0);
+  });
+
+  it.each(['UNPAID', 'PARTIALLY_PAID'])(
+    'does not redirect an order whose payment status is %s',
+    async paymentStatus => {
+      const initialUrl = window.location.href;
+      renderCheckout({
+        sessionOverrides: { successUrl: 'https://merchant.example/success' },
+        draftOrderOverrides: { statuses: { paymentStatus } },
+      });
+      await waitForCheckoutReady();
+      await act(async () => {
+        await vi.advanceTimersByTimeAsync(1100);
+      });
+      expect(window.location.href).toBe(initialUrl);
+      expect(screen.queryByText('Payment successful')).not.toBeInTheDocument();
+    }
+  );
+
+  it('redirects when a refreshed order status becomes paid', async () => {
+    const successUrl = 'https://merchant.example/success';
+    const { queryClient, session } = renderCheckout({
+      sessionOverrides: { successUrl },
+      draftOrderOverrides: { statuses: { paymentStatus: 'UNPAID' } },
+    });
+    await waitForCheckoutReady();
+    act(() => {
+      queryClient.setQueryData(checkoutQueryKeys.orderStatus(session.id), {
+        checkoutSession: {
+          id: session.id,
+          orderStatus: { status: 'OPEN', paymentStatus: 'PAID' },
+        },
+      });
+    });
+    expect(await screen.findByRole('status')).toHaveTextContent(
+      'Payment successful'
+    );
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(1100);
+    });
+    expect(window.location.href).toBe(successUrl);
+  });
+});
diff --git a/packages/react/src/components/checkout/__tests__/checkout-stripe-recovery.test.tsx b/packages/react/src/components/checkout/__tests__/checkout-stripe-recovery.test.tsx
new file mode 100644
index 00000000..aaf96186
--- /dev/null
+++ b/packages/react/src/components/checkout/__tests__/checkout-stripe-recovery.test.tsx
@@ -0,0 +1,173 @@
+import { act, screen, waitFor } from '@testing-library/react';
+import type React from 'react';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import * as godaddyApi from '@/lib/godaddy/godaddy';
+import { GraphQLErrorWithCodes } from '@/lib/graphql-with-errors';
+import {
+  buildCheckoutSession,
+  buildDraftOrder,
+  renderCheckout,
+  restoreWindowLocation,
+  setupCheckoutTestGlobals,
+  waitForCheckoutReady,
+} from './checkout-test-utils';
+
+const stripe = vi.hoisted(() => ({
+  createPaymentMethod: vi.fn(),
+  handleNextAction: vi.fn(),
+}));
+const elements = vi.hoisted(() => ({
+  getElement: vi.fn(() => ({})),
+  update: vi.fn(),
+}));
+
+// Keep the real Checkout, PaymentForm, StripeProvider, button, and confirm hook.
+vi.mock('@stripe/react-stripe-js', () => ({
+  Elements: ({ children }: { children: React.ReactNode }) => children,
+  CardElement: () => <div>Stripe card field</div>,
+  useStripe: () => stripe,
+  useElements: () => elements,
+}));
+vi.mock(
+  '@/components/checkout/payment/utils/use-stripe-payment-intent',
+  () => ({
+    useStripePaymentIntent: () => ({
+      stripePromise: stripe,
+      currency: 'usd',
+      clientSecret: null,
+      isLoading: false,
+      amount: 1000,
+    }),
+  })
+);
+
+beforeEach(() => {
+  vi.useFakeTimers({ shouldAdvanceTime: true });
+  setupCheckoutTestGlobals();
+  stripe.createPaymentMethod
+    .mockReset()
+    .mockResolvedValue({ paymentMethod: { id: 'pm_original' } });
+  stripe.handleNextAction.mockReset();
+});
+
+afterEach(() => {
+  act(() => {
+    vi.runOnlyPendingTimers();
+  });
+  vi.useRealTimers();
+  vi.restoreAllMocks();
+  restoreWindowLocation();
+});
+
+describe('Stripe recovery through the payment spinner', () => {
+  it.each([
+    ['finalization', false],
+    ['SDK transport', false],
+    ['finalization', true],
+    ['SDK transport', true],
+  ] as const)(
+    'reuses the intent after %s failure and button remount (tips enabled: %s)',
+    async (failure, enableTips) => {
+      const draftOrder = buildDraftOrder({
+        totals: {
+          subTotal: { value: 2500, currencyCode: 'USD' },
+          discountTotal: { value: 0, currencyCode: 'USD' },
+          total: { value: 2500, currencyCode: 'USD' },
+        },
+      });
+      const session = buildCheckoutSession({
+        draftOrder,
+        enableTips,
+        enableShipping: false,
+        enableLocalPickup: false,
+        enableBillingAddressCollection: false,
+        enableTaxCollection: false,
+        paymentMethods: {
+          card: { processor: 'stripe', checkoutTypes: ['standard'] },
+        },
+      });
+      const { user } = renderCheckout({
+        session,
+        draftOrder,
+        checkoutProps: { stripeConfig: { publishableKey: 'pk_test' } },
+      });
+      await waitForCheckoutReady();
+      if (enableTips) {
+        await user.click(await screen.findByRole('radio', { name: /20%/ }));
+      }
+
+      const confirm = vi.mocked(godaddyApi.confirmCheckout);
+      confirm.mockRejectedValueOnce(
+        new GraphQLErrorWithCodes([
+          {
+            code: 'PAYMENT_ACTION_REQUIRED',
+            extensions: {
+              paymentResult: {
+                status: 'ACTION_REQUIRED',
+                provider: 'STRIPE',
+                paymentReference: 'pi_original',
+                nextStep: {
+                  type: 'SDK_ACTION',
+                  sdk: 'STRIPE_JS',
+                  action: 'HANDLE_NEXT_ACTION',
+                  clientSecret: 'pi_original_secret',
+                },
+              },
+            },
+          },
+        ])
+      );
+      if (failure === 'finalization')
+        confirm.mockRejectedValueOnce(new Error('Connection lost'));
+
+      let finishAction!: (value: unknown) => void;
+      let failAction!: (reason: Error) => void;
+      const action = new Promise((resolve, reject) => {
+        finishAction = resolve;
+        failAction = reject;
+      });
+      stripe.handleNextAction.mockReturnValueOnce(action);
+      const originalButton = await screen.findByRole('button', {
+        name: /pay now/i,
+      });
+      await user.click(originalButton);
+      await waitFor(() =>
+        expect(stripe.handleNextAction).toHaveBeenCalledOnce()
+      );
+      expect(originalButton).not.toBeInTheDocument();
+      expect(
+        screen.getByRole('button', { name: /processing/i })
+      ).toBeDisabled();
+
+      await act(async () => {
+        if (failure === 'SDK transport')
+          failAction(new Error('Connection lost'));
+        else
+          finishAction({
+            paymentIntent: { id: 'pi_original', status: 'succeeded' },
+          });
+      });
+      const retryButton = await screen.findByRole('button', {
+        name: /pay now/i,
+      });
+      expect(retryButton).not.toBe(originalButton);
+      await waitFor(() => expect(retryButton).toBeEnabled());
+      await user.click(retryButton);
+      const expectedTokens =
+        failure === 'finalization'
+          ? ['pm_original', 'pi_original', 'pi_original']
+          : ['pm_original', 'pi_original'];
+      await waitFor(() =>
+        expect(confirm.mock.calls.map(([input]) => input.paymentToken)).toEqual(
+          expectedTokens
+        )
+      );
+      for (const [input] of confirm.mock.calls) {
+        if (enableTips) expect(input.tipAmount).toBe(500);
+        else expect(input).not.toHaveProperty('tipAmount');
+      }
+      expect(stripe.createPaymentMethod).toHaveBeenCalledOnce();
+      expect(stripe.handleNextAction).toHaveBeenCalledOnce();
+    }
+  );
+});
diff --git a/packages/react/src/components/checkout/__tests__/checkout-test-utils.tsx b/packages/react/src/components/checkout/__tests__/checkout-test-utils.tsx
index dc86dd3f..9a9e0c08 100644
--- a/packages/react/src/components/checkout/__tests__/checkout-test-utils.tsx
+++ b/packages/react/src/components/checkout/__tests__/checkout-test-utils.tsx
@@ -29,6 +29,7 @@ import { CheckoutType, PaymentMethodType, PaymentProvider } from '@/types';
 export type OperationName =
   | 'CheckoutSession'
   | 'DraftOrder'
+  | 'CheckoutOrderStatus'
   | 'DraftOrderSkus'
   | 'DraftOrderShippingRates'
   | 'UpdateCheckoutSessionDraftOrder'
@@ -64,6 +65,7 @@ export type MockGodaddyApiErrorKey =
   | 'refreshCheckoutToken'
   | 'getAddressMatches'
   | 'getDraftOrder'
+  | 'getCheckoutOrderStatus'
   | 'updateDraftOrder'
   | 'updateDraftOrderTaxes'
   | 'applyShippingMethod'
@@ -564,12 +566,37 @@ function mergeDraftOrderPatch(input: Record<string, unknown>) {
   state.session = { ...state.session, draftOrder: state.draftOrder };
 }
 
+// Mirrors checkout-api's assertMutable: draftOrder is null once the order is
+// completed, canceled, paid, or awaiting an offline (PENDING) payment.
+function isMutableOrder(draftOrder: DraftOrder) {
+  const status = draftOrder.statuses?.status?.toUpperCase();
+  const paymentStatus = draftOrder.statuses?.paymentStatus?.toUpperCase();
+  return (
+    status !== 'COMPLETED' &&
+    status !== 'CANCELED' &&
+    paymentStatus !== 'PAID' &&
+    paymentStatus !== 'PENDING'
+  );
+}
+
 function makeDraftOrderResponse() {
   if (!state) throw new Error('mockGodaddyApi must be called first');
   return {
     checkoutSession: {
       ...state.session,
-      draftOrder: state.draftOrder,
+      draftOrder: isMutableOrder(state.draftOrder) ? state.draftOrder : null,
+    },
+  };
+}
+
+function makeOrderStatusResponse() {
+  if (!state) throw new Error('mockGodaddyApi must be called first');
+  const { status = null, paymentStatus = null } =
+    state.draftOrder.statuses ?? {};
+  return {
+    checkoutSession: {
+      id: state.session.id,
+      orderStatus: { status, paymentStatus },
     },
   };
 }
@@ -761,6 +788,13 @@ export function mockGodaddyApi(options: MockGodaddyApiOptions) {
     return makeDraftOrderResponse();
   });
 
+  mockedGodaddyApi.getCheckoutOrderStatus.mockImplementation(async () => {
+    record('CheckoutOrderStatus');
+    await maybeDelay();
+    maybeThrow('getCheckoutOrderStatus');
+    return makeOrderStatusResponse();
+  });
+
   mockedGodaddyApi.getProductsFromOrderSkus.mockImplementation(async () => {
     record('DraftOrderSkus');
     await maybeDelay();
diff --git a/packages/react/src/components/checkout/__tests__/express-checkout-paid-order.test.tsx b/packages/react/src/components/checkout/__tests__/express-checkout-paid-order.test.tsx
new file mode 100644
index 00000000..d4e07872
--- /dev/null
+++ b/packages/react/src/components/checkout/__tests__/express-checkout-paid-order.test.tsx
@@ -0,0 +1,106 @@
+import { act, fireEvent, render, screen } from '@testing-library/react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { DraftOrderExpressCheckout } from '@/components/checkout/express-checkout/express-checkout';
+import { PaymentProvider } from '@/components/checkout/payment/utils/use-confirm-checkout';
+import { useConfirmExpressCheckout } from '@/components/checkout/payment/utils/use-confirm-express-checkout';
+import { GoDaddyProvider } from '@/godaddy-provider';
+import { confirmCheckout } from '@/lib/godaddy/godaddy';
+import {
+  buildCheckoutSession,
+  buildDraftOrder,
+  createTestQueryClient,
+  mockGodaddyApi,
+  mockWindowLocation,
+  setCurrentDraftOrder,
+} from './checkout-test-env';
+
+vi.mock('@/components/checkout/payment/payment-method-renderer', () => ({
+  PaymentMethodRenderer: () => {
+    const confirmation = useConfirmExpressCheckout();
+    return (
+      <button
+        onClick={() => {
+          void confirmation
+            .mutateAsync({
+              paymentToken: 'wallet-token',
+              paymentType: 'apple_pay',
+              paymentProvider: PaymentProvider.POYNT,
+            })
+            .catch(() => undefined);
+        }}
+      >
+        Express pay
+      </button>
+    );
+  },
+}));
+
+function renderExpress(paymentStatus: string) {
+  const draftOrder = buildDraftOrder({
+    statuses: {
+      status: paymentStatus === 'PAID' ? 'OPEN' : 'DRAFT',
+      paymentStatus,
+    },
+  });
+  const session = buildCheckoutSession({
+    successUrl: 'https://merchant.example/success',
+    paymentMethods: {
+      card: null as never,
+      applePay: { processor: 'godaddy', checkoutTypes: ['express'] },
+    },
+  });
+  mockGodaddyApi({ session, draftOrder });
+  render(
+    <GoDaddyProvider queryClient={createTestQueryClient()}>
+      <DraftOrderExpressCheckout session={session} />
+    </GoDaddyProvider>
+  );
+  return session;
+}
+
+describe('Standalone express paid-order recovery', () => {
+  beforeEach(() => mockWindowLocation());
+
+  it.each(['load', 'confirmation failure'])(
+    'redirects paid orders on %s',
+    async scenario => {
+      const session = renderExpress(scenario === 'load' ? 'PAID' : 'UNPAID');
+      if (scenario === 'confirmation failure') {
+        const button = await screen.findByRole('button', {
+          name: 'Express pay',
+        });
+        vi.mocked(confirmCheckout).mockImplementationOnce(async () => {
+          // The payment landed even though its response was lost.
+          setCurrentDraftOrder(
+            buildDraftOrder({
+              statuses: { status: 'OPEN', paymentStatus: 'PAID' },
+            })
+          );
+          throw new Error('Confirmation response lost');
+        });
+        fireEvent.click(button);
+      }
+      expect(await screen.findByRole('status')).toHaveTextContent(
+        'Payment successful'
+      );
+      expect(
+        screen.queryByRole('button', { name: 'Express pay' })
+      ).not.toBeInTheDocument();
+      await act(async () => {
+        await vi.advanceTimersByTimeAsync(1100);
+      });
+      expect(window.location.href).toBe(session.successUrl);
+      expect(confirmCheckout).toHaveBeenCalledTimes(
+        scenario === 'load' ? 0 : 1
+      );
+    }
+  );
+
+  it('keeps express payment available for an unpaid order', async () => {
+    renderExpress('UNPAID');
+    expect(
+      await screen.findByRole('button', { name: 'Express pay' })
+    ).toBeInTheDocument();
+    expect(window.location.href).not.toContain('/success');
+  });
+});
diff --git a/packages/react/src/components/checkout/express-checkout/express-checkout.tsx b/packages/react/src/components/checkout/express-checkout/express-checkout.tsx
index 52f4c483..80c2a638 100644
--- a/packages/react/src/components/checkout/express-checkout/express-checkout.tsx
+++ b/packages/react/src/components/checkout/express-checkout/express-checkout.tsx
@@ -8,10 +8,12 @@ import {
   useCheckoutContext,
 } from '@/components/checkout/checkout';
 import { CheckoutSection } from '@/components/checkout/checkout-section';
+import { useDraftOrder } from '@/components/checkout/order/use-draft-order';
+import { usePaidOrderRedirect } from '@/components/checkout/order/use-paid-order-redirect';
 import { PaymentMethodRenderer } from '@/components/checkout/payment/payment-method-renderer';
 import { ConditionalExpressProviders } from '@/components/checkout/payment/utils/conditional-providers';
 import { Target } from '@/components/checkout/target/target';
-import type { GoDaddyVariables } from '@/godaddy-provider';
+import { type GoDaddyVariables, useGoDaddyContext } from '@/godaddy-provider';
 import { type Theme, useTheme } from '@/hooks/use-theme';
 import { useVariables } from '@/hooks/use-variables';
 import { TrackingProvider } from '@/tracking/tracking-provider';
@@ -84,6 +86,25 @@ function DraftOrderExpressCheckoutButtons() {
   );
 }
 
+function ExpressCheckoutContent() {
+  const { t } = useGoDaddyContext();
+  const { data: order, isLoading } = useDraftOrder();
+  const { showPaidOrder, isLoadingOrderStatus } = usePaidOrderRedirect({
+    order,
+    isDraftOrderLoading: isLoading,
+  });
+
+  if (showPaidOrder)
+    return <div role='status'>{t.errors.paymentSuccessful}</div>;
+  if (isLoading || (!order && isLoadingOrderStatus)) return null;
+
+  return (
+    <ConditionalExpressProviders>
+      <DraftOrderExpressCheckoutButtons />
+    </ConditionalExpressProviders>
+  );
+}
+
 export function DraftOrderExpressCheckout(props: ExpressCheckoutProps) {
   const {
     session,
@@ -140,9 +161,7 @@ export function DraftOrderExpressCheckout(props: ExpressCheckoutProps) {
     >
       <checkoutContext.Provider value={contextValue}>
         <CheckoutSection>
-          <ConditionalExpressProviders>
-            <DraftOrderExpressCheckoutButtons />
-          </ConditionalExpressProviders>
+          <ExpressCheckoutContent />
         </CheckoutSection>
       </checkoutContext.Provider>
     </TrackingProvider>
diff --git a/packages/react/src/components/checkout/form/checkout-form-container.tsx b/packages/react/src/components/checkout/form/checkout-form-container.tsx
index 2176dd76..51280845 100644
--- a/packages/react/src/components/checkout/form/checkout-form-container.tsx
+++ b/packages/react/src/components/checkout/form/checkout-form-container.tsx
@@ -14,11 +14,13 @@ import {
   useDraftOrderProductsMap,
   useRefreshProductsWhenLineItemsChange,
 } from '@/components/checkout/order/use-draft-order-products';
+import { usePaidOrderRedirect } from '@/components/checkout/order/use-paid-order-redirect';
 import {
   mapOrderToFormValues,
   mapSkusToItemsDisplay,
 } from '@/components/checkout/utils/checkout-transformers';
 import { getFulfillmentSummary } from '@/components/checkout/utils/fulfillment';
+import { useGoDaddyContext } from '@/godaddy-provider';
 
 interface CheckoutFormContainerProps extends Omit<CheckoutProps, 'session'> {
   validationAdapter: CheckoutValidationAdapter;
@@ -31,12 +33,18 @@ export function CheckoutFormContainer({
   ...props
 }: CheckoutFormContainerProps) {
   const { session, isConfirmingCheckout } = useCheckoutContext();
+  const { t } = useGoDaddyContext();
 
   const draftOrderQuery = useDraftOrder();
   const draftOrderLineItemsQuery = useDraftOrderLineItems();
   const skusMap = useDraftOrderProductsMap();
 
   const { data: order } = draftOrderQuery;
+  const { showPaidOrder, isLoadingOrderStatus } = usePaidOrderRedirect({
+    order,
+    isDraftOrderLoading: draftOrderQuery.isLoading,
+  });
+
   const { data: lineItems } = draftOrderLineItemsQuery;
   useRefreshProductsWhenLineItemsChange(lineItems);
 
@@ -68,7 +76,18 @@ export function CheckoutFormContainer({
     ]
   );
 
-  if (!isConfirmingCheckout && !draftOrderQuery.isLoading && !order) {
+  // A paid or pending order has no draftOrder, so check completion before
+  // treating a missing order as abandoned and returning to the merchant.
+  if (showPaidOrder) {
+    return <div role='status'>{t.errors.paymentSuccessful}</div>;
+  }
+
+  if (
+    !isConfirmingCheckout &&
+    !draftOrderQuery.isLoading &&
+    !order &&
+    !isLoadingOrderStatus
+  ) {
     const returnUrl = session?.returnUrl;
     if (returnUrl) {
       window.location.href = returnUrl;
@@ -76,7 +95,12 @@ export function CheckoutFormContainer({
     }
   }
 
-  if (props.isLoading || draftOrderQuery.isLoading || isLoadingJWT) {
+  if (
+    props.isLoading ||
+    draftOrderQuery.isLoading ||
+    isLoadingJWT ||
+    (!order && isLoadingOrderStatus)
+  ) {
     return (
       props.loadingFallback ?? <CheckoutSkeleton direction={props.direction} />
     );
diff --git a/packages/react/src/components/checkout/order/use-checkout-order-status.ts b/packages/react/src/components/checkout/order/use-checkout-order-status.ts
new file mode 100644
index 00000000..817d7ef9
--- /dev/null
+++ b/packages/react/src/components/checkout/order/use-checkout-order-status.ts
@@ -0,0 +1,45 @@
+import { useQuery } from '@tanstack/react-query';
+import { useCheckoutContext } from '@/components/checkout/checkout';
+import { checkoutQueryKeys } from '@/components/checkout/utils/query-keys';
+import { useGoDaddyContext } from '@/godaddy-provider';
+import { getCheckoutOrderStatus } from '@/lib/godaddy/godaddy';
+
+type OrderStatus = {
+  status?: string | null;
+  paymentStatus?: string | null;
+} | null;
+
+// PAID is a captured payment; PENDING is an offline checkout awaiting collection.
+// Either way the shopper has nothing left to pay, matching confirmCheckoutSession.
+export function isCheckoutComplete(orderStatus: OrderStatus | undefined) {
+  const status = orderStatus?.status?.trim().toUpperCase();
+  const paymentStatus = orderStatus?.paymentStatus?.trim().toUpperCase();
+  return (
+    (paymentStatus === 'PAID' || paymentStatus === 'PENDING') &&
+    status !== 'CANCELED'
+  );
+}
+
+export function useCheckoutOrderStatus({ enabled }: { enabled: boolean }) {
+  const { session, jwt } = useCheckoutContext();
+  const { apiHost } = useGoDaddyContext();
+
+  return useQuery({
+    queryKey: checkoutQueryKeys.orderStatus(session?.id),
+    queryFn: () =>
+      jwt
+        ? getCheckoutOrderStatus({ accessToken: jwt }, apiHost)
+        : getCheckoutOrderStatus(session, apiHost),
+    // Callers enable this only when it can matter; confirmation recovery fills
+    // the same cache entry directly with fetchQuery.
+    enabled: enabled && !!session?.id,
+    staleTime: 5_000,
+    select: data => data.checkoutSession?.orderStatus ?? null,
+    // An API without orderStatus fails validation; retrying cannot help, and a
+    // failed lookup only means checkout is not known to be complete.
+    retry: false,
+    // A focus refetch would count as in-flight work and block an express
+    // confirmation started right after a wallet sheet closes.
+    refetchOnWindowFocus: false,
+  });
+}
diff --git a/packages/react/src/components/checkout/order/use-paid-order-redirect.ts b/packages/react/src/components/checkout/order/use-paid-order-redirect.ts
new file mode 100644
index 00000000..b7c5e588
--- /dev/null
+++ b/packages/react/src/components/checkout/order/use-paid-order-redirect.ts
@@ -0,0 +1,38 @@
+import { useEffect } from 'react';
+import {
+  redirectToSuccessUrl,
+  useCheckoutContext,
+} from '@/components/checkout/checkout';
+import type { DraftOrder } from '@/types';
+import {
+  isCheckoutComplete,
+  useCheckoutOrderStatus,
+} from './use-checkout-order-status';
+
+// draftOrder is null once an order is paid or awaiting offline payment, so a
+// missing draft order is the only time completion needs to be looked up.
+export function usePaidOrderRedirect({
+  order,
+  isDraftOrderLoading,
+}: {
+  order: DraftOrder | null | undefined;
+  isDraftOrderLoading: boolean;
+}) {
+  const { session, isConfirmingCheckout } = useCheckoutContext();
+  const needsOrderStatus = !isDraftOrderLoading && !order;
+  const orderStatusQuery = useCheckoutOrderStatus({
+    enabled: needsOrderStatus,
+  });
+  const showPaidOrder =
+    isCheckoutComplete(orderStatusQuery.data) && !isConfirmingCheckout;
+
+  useEffect(() => {
+    if (showPaidOrder) redirectToSuccessUrl(session?.successUrl);
+  }, [showPaidOrder, session?.successUrl]);
+
+  return {
+    showPaidOrder,
+    // Pending until the lookup settles, including the render that enables it.
+    isLoadingOrderStatus: needsOrderStatus && orderStatusQuery.isPending,
+  };
+}
diff --git a/packages/react/src/components/checkout/payment/checkout-buttons/credit-card/stripe.tsx b/packages/react/src/components/checkout/payment/checkout-buttons/credit-card/stripe.tsx
index 18269a77..9ce5bc71 100644
--- a/packages/react/src/components/checkout/payment/checkout-buttons/credit-card/stripe.tsx
+++ b/packages/react/src/components/checkout/payment/checkout-buttons/credit-card/stripe.tsx
@@ -1,7 +1,9 @@
 'use client';
 
+import { useRef, useState } from 'react';
 import { useFormContext } from 'react-hook-form';
 import { useCheckoutContext } from '@/components/checkout/checkout';
+import { isCheckoutConfirmationBlockedError } from '@/components/checkout/payment/utils/use-confirm-checkout';
 import { useFlushCheckoutSync } from '@/components/checkout/payment/utils/use-flush-checkout-sync';
 import { useIsPaymentDisabled } from '@/components/checkout/payment/utils/use-is-payment-disabled';
 import { useStripeCheckout } from '@/components/checkout/payment/utils/use-stripe-checkout';
@@ -14,21 +16,35 @@ export function StripeCreditCardCheckoutButton() {
   const { isConfirmingCheckout } = useCheckoutContext();
   const isPaymentDisabled = useIsPaymentDisabled();
   const flushCheckoutSync = useFlushCheckoutSync();
-  const { handleSubmit } = useStripeCheckout({ mode: 'card' });
+  const isSubmittingRef = useRef(false);
+  const [isSubmitting, setIsSubmitting] = useState(false);
+  const { handleSubmit, isProcessingPayment } = useStripeCheckout({
+    mode: 'card',
+  });
 
   const handleStripeCheckout = async () => {
-    const valid = await form.trigger();
+    if (isSubmittingRef.current) return;
+    isSubmittingRef.current = true;
+    setIsSubmitting(true);
+    try {
+      const valid = await form.trigger();
 
-    if (!valid) {
-      const firstError = Object.keys(form.formState.errors)[0];
-      if (firstError) {
-        form.setFocus(firstError);
+      if (!valid) {
+        const firstError = Object.keys(form.formState.errors)[0];
+        if (firstError) {
+          form.setFocus(firstError);
+        }
+      } else {
+        const { latestOrder } = await flushCheckoutSync({
+          includeCurrentFormDiff: true,
+        });
+        await handleSubmit(undefined, latestOrder);
       }
-    } else {
-      const { latestOrder } = await flushCheckoutSync({
-        includeCurrentFormDiff: true,
-      });
-      await handleSubmit(undefined, latestOrder);
+    } catch (error) {
+      if (!isCheckoutConfirmationBlockedError(error)) throw error;
+    } finally {
+      isSubmittingRef.current = false;
+      setIsSubmitting(false);
     }
   };
 
@@ -36,7 +52,12 @@ export function StripeCreditCardCheckoutButton() {
     <Button
       className='w-full'
       size='lg'
-      disabled={isConfirmingCheckout || isPaymentDisabled}
+      disabled={
+        isSubmitting ||
+        isProcessingPayment ||
+        isConfirmingCheckout ||
+        isPaymentDisabled
+      }
       onClick={handleStripeCheckout}
     >
       {t.payment.payNow}
diff --git a/packages/react/src/components/checkout/payment/checkout-buttons/express/stripe-confirm.test.tsx b/packages/react/src/components/checkout/payment/checkout-buttons/express/stripe-confirm.test.tsx
new file mode 100644
index 00000000..6ac8f345
--- /dev/null
+++ b/packages/react/src/components/checkout/payment/checkout-buttons/express/stripe-confirm.test.tsx
@@ -0,0 +1,121 @@
+import type { StripeExpressCheckoutElementConfirmEvent } from '@stripe/stripe-js';
+import { render } from '@testing-library/react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { CheckoutConfirmationBlockedError } from '@/components/checkout/payment/utils/use-confirm-checkout';
+import { StripeExpressCheckoutForm } from './stripe';
+
+const mocks = vi.hoisted(() => ({
+  handleSubmit: vi.fn(),
+  track: vi.fn(),
+  onConfirm: undefined as
+    | ((event: StripeExpressCheckoutElementConfirmEvent) => Promise<void>)
+    | undefined,
+}));
+
+vi.mock('@stripe/react-stripe-js', () => ({
+  ExpressCheckoutElement: (props: { onConfirm: typeof mocks.onConfirm }) => {
+    mocks.onConfirm = props.onConfirm;
+    return null;
+  },
+  useElements: () => null,
+}));
+vi.mock('@/components/checkout/checkout', () => ({
+  useCheckoutContext: () => ({
+    session: { id: 'session-1' },
+    setCheckoutErrors: vi.fn(),
+    isConfirmingCheckout: false,
+  }),
+}));
+vi.mock('@/godaddy-provider', () => ({
+  useGoDaddyContext: () => ({
+    t: {
+      errors: { errorProcessingPayment: 'Error processing payment' },
+      totals: {
+        discount: 'Discount',
+        estimatedTaxes: 'Estimated taxes',
+        shipping: 'Shipping',
+        subtotal: 'Subtotal',
+      },
+    },
+  }),
+}));
+vi.mock('@/components/checkout/payment/utils/use-stripe-checkout', () => ({
+  useStripeCheckout: () => ({ handleSubmit: mocks.handleSubmit }),
+}));
+vi.mock('@/components/checkout/order/use-draft-order', () => ({
+  useDraftOrder: () => ({ data: undefined }),
+  useDraftOrderTotals: () => ({ data: undefined }),
+}));
+vi.mock('@/components/checkout/payment/utils/use-is-payment-disabled', () => ({
+  useIsPaymentDisabled: () => false,
+}));
+vi.mock(
+  '@/components/checkout/shipping/utils/use-get-shipping-methods',
+  () => ({ useGetShippingMethodByAddress: () => vi.fn() })
+);
+vi.mock('@/components/checkout/taxes/utils/use-get-taxes', () => ({
+  useGetTaxes: () => vi.fn(),
+}));
+vi.mock(
+  '@/components/checkout/discount/utils/use-get-price-adjustments',
+  () => ({ useGetPriceAdjustments: () => vi.fn() })
+);
+vi.mock('@/tracking/track', () => ({
+  track: mocks.track,
+  TrackingEventType: { EVENT: 'event' },
+}));
+
+function confirmEvent() {
+  return {
+    expressPaymentType: 'google_pay',
+    paymentFailed: vi.fn(),
+  } as unknown as StripeExpressCheckoutElementConfirmEvent & {
+    paymentFailed: ReturnType<typeof vi.fn>;
+  };
+}
+
+describe('StripeExpressCheckoutForm confirm', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mocks.onConfirm = undefined;
+    render(<StripeExpressCheckoutForm />);
+  });
+
+  it('closes the wallet sheet when confirmation is blocked, without reporting a payment error', async () => {
+    mocks.handleSubmit.mockRejectedValueOnce(
+      new CheckoutConfirmationBlockedError('Checkout is currently busy')
+    );
+    const event = confirmEvent();
+
+    await mocks.onConfirm?.(event);
+
+    expect(event.paymentFailed).toHaveBeenCalledWith({
+      reason: 'fail',
+      message: 'Error processing payment',
+    });
+    expect(mocks.track).not.toHaveBeenCalled();
+  });
+
+  it('closes the wallet sheet and tracks the error when payment fails', async () => {
+    mocks.handleSubmit.mockRejectedValueOnce(new Error('declined'));
+    const event = confirmEvent();
+
+    await mocks.onConfirm?.(event);
+
+    expect(event.paymentFailed).toHaveBeenCalledTimes(1);
+    expect(mocks.track).toHaveBeenCalledWith(
+      expect.objectContaining({
+        properties: expect.objectContaining({ errorType: 'declined' }),
+      })
+    );
+  });
+
+  it('leaves the wallet sheet to the payment flow on success', async () => {
+    mocks.handleSubmit.mockResolvedValueOnce(undefined);
+    const event = confirmEvent();
+
+    await mocks.onConfirm?.(event);
+
+    expect(event.paymentFailed).not.toHaveBeenCalled();
+  });
+});
diff --git a/packages/react/src/components/checkout/payment/checkout-buttons/express/stripe.tsx b/packages/react/src/components/checkout/payment/checkout-buttons/express/stripe.tsx
index 42107715..5b05b522 100644
--- a/packages/react/src/components/checkout/payment/checkout-buttons/express/stripe.tsx
+++ b/packages/react/src/components/checkout/payment/checkout-buttons/express/stripe.tsx
@@ -15,6 +15,7 @@ import {
   useDraftOrder,
   useDraftOrderTotals,
 } from '@/components/checkout/order/use-draft-order';
+import { isCheckoutConfirmationBlockedError } from '@/components/checkout/payment/utils/use-confirm-checkout';
 import { useIsPaymentDisabled } from '@/components/checkout/payment/utils/use-is-payment-disabled';
 import { useStripeCheckout } from '@/components/checkout/payment/utils/use-stripe-checkout';
 import { useStripePaymentIntent } from '@/components/checkout/payment/utils/use-stripe-payment-intent';
@@ -585,17 +586,16 @@ export function StripeExpressCheckoutForm() {
             : null,
           selectedShippingMethod: selectedShippingMethod || null,
         });
-
-        // Track successful payment
-        track({
-          eventId: eventIds.expressApplePayCompleted,
-          type: TrackingEventType.EVENT,
-          properties: {
-            paymentType: event.expressPaymentType,
-            provider: 'stripe',
-          },
-        });
       } catch (error) {
+        // A blocked confirmation is not a payment error, but the wallet sheet
+        // still waits for an outcome, so it must be told the payment failed.
+        if (isCheckoutConfirmationBlockedError(error)) {
+          event.paymentFailed({
+            reason: 'fail',
+            message: t.errors.errorProcessingPayment,
+          });
+          return;
+        }
         // Track error
         track({
           eventId: eventIds.expressCheckoutError,
diff --git a/packages/react/src/components/checkout/payment/checkout-buttons/payment-request-resolution.test.tsx b/packages/react/src/components/checkout/payment/checkout-buttons/payment-request-resolution.test.tsx
index 80afeac0..532ae902 100644
--- a/packages/react/src/components/checkout/payment/checkout-buttons/payment-request-resolution.test.tsx
+++ b/packages/react/src/components/checkout/payment/checkout-buttons/payment-request-resolution.test.tsx
@@ -1,5 +1,11 @@
 import { QueryClient } from '@tanstack/react-query';
-import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import {
+  act,
+  fireEvent,
+  render,
+  screen,
+  waitFor,
+} from '@testing-library/react';
 import React from 'react';
 import { FormProvider, useForm } from 'react-hook-form';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
@@ -11,6 +17,7 @@ import { GoDaddyProvider } from '@/godaddy-provider';
 import type { DraftOrder } from '@/types';
 import { CreditCardCheckoutButton } from './credit-card/godaddy';
 import { SquareCreditCardCheckoutButton } from './credit-card/square';
+import { StripeCreditCardCheckoutButton } from './credit-card/stripe';
 
 const mocks = vi.hoisted(() => ({
   latestOrder: { id: 'latest-order' } as DraftOrder,
@@ -19,6 +26,14 @@ const mocks = vi.hoisted(() => ({
   getNonce: vi.fn(),
   tokenize: vi.fn(),
   confirm: vi.fn(),
+  stripeSubmit: vi.fn(),
+}));
+
+vi.mock('@/components/checkout/payment/utils/use-stripe-checkout', () => ({
+  useStripeCheckout: () => ({
+    handleSubmit: mocks.stripeSubmit,
+    isProcessingPayment: false,
+  }),
 }));
 
 vi.mock('@/components/checkout/payment/utils/use-flush-checkout-sync', () => ({
@@ -151,4 +166,31 @@ describe('payment request resolution from the flushed order', () => {
       mocks.tokenize.mock.invocationCallOrder[0]
     );
   });
+
+  it('locks the Stripe button before validation and the initial order flush finish', async () => {
+    let finishFlush!: (value: { latestOrder: DraftOrder }) => void;
+    mocks.flush.mockReturnValueOnce(
+      new Promise(resolve => {
+        finishFlush = resolve;
+      })
+    );
+    render(<StripeCreditCardCheckoutButton />, { wrapper: Wrapper });
+    const button = screen.getByRole('button', { name: /pay now/i });
+
+    fireEvent.click(button);
+    fireEvent.click(button);
+    expect((button as HTMLButtonElement).disabled).toBe(true);
+    await waitFor(() => expect(mocks.flush).toHaveBeenCalledTimes(1));
+    expect(mocks.stripeSubmit).not.toHaveBeenCalled();
+
+    await act(async () => {
+      finishFlush({ latestOrder: mocks.latestOrder });
+    });
+    expect(mocks.stripeSubmit).toHaveBeenCalledTimes(1);
+    expect(mocks.stripeSubmit).toHaveBeenCalledWith(
+      undefined,
+      mocks.latestOrder
+    );
+    expect((button as HTMLButtonElement).disabled).toBe(false);
+  });
 });
diff --git a/packages/react/src/components/checkout/payment/utils/stripe-next-action.ts b/packages/react/src/components/checkout/payment/utils/stripe-next-action.ts
new file mode 100644
index 00000000..bdadd496
--- /dev/null
+++ b/packages/react/src/components/checkout/payment/utils/stripe-next-action.ts
@@ -0,0 +1,35 @@
+import { getPaymentActionRequiredResult } from '@/lib/graphql-with-errors';
+
+export function getStripeNextAction(
+  error: unknown
+): { clientSecret: string; paymentReference: string } | undefined {
+  const result = getPaymentActionRequiredResult(error);
+  const step = result?.nextStep;
+  if (
+    result?.provider !== 'STRIPE' ||
+    typeof result.paymentReference !== 'string' ||
+    !result.paymentReference.trim() ||
+    step?.type !== 'SDK_ACTION' ||
+    step.sdk !== 'STRIPE_JS' ||
+    step.action !== 'HANDLE_NEXT_ACTION' ||
+    typeof step.clientSecret !== 'string' ||
+    !step.clientSecret.trim()
+  )
+    return undefined;
+  return {
+    clientSecret: step.clientSecret,
+    paymentReference: result.paymentReference,
+  };
+}
+
+// Stripe SDK error codes are not customer-facing localization keys.
+export function stripeCheckoutErrorCode(code?: string): string {
+  switch (code) {
+    case 'payment_intent_authentication_failure':
+    case 'payment_intent_payment_attempt_failed':
+    case 'setup_intent_authentication_failure':
+      return 'AUTHORIZATION_FAILED';
+    default:
+      return 'TRANSACTION_PROCESSING_FAILED';
+  }
+}
diff --git a/packages/react/src/components/checkout/payment/utils/stripe-provider.tsx b/packages/react/src/components/checkout/payment/utils/stripe-provider.tsx
index d29d3eda..668fe563 100644
--- a/packages/react/src/components/checkout/payment/utils/stripe-provider.tsx
+++ b/packages/react/src/components/checkout/payment/utils/stripe-provider.tsx
@@ -1,8 +1,28 @@
 import { Elements, useElements } from '@stripe/react-stripe-js';
-import { useEffect } from 'react';
+import {
+  createContext,
+  type RefObject,
+  useContext,
+  useEffect,
+  useRef,
+} from 'react';
 import { useCheckoutContext } from '@/components/checkout/checkout';
 import { useStripePaymentIntent } from '@/components/checkout/payment/utils/use-stripe-payment-intent';
 
+type PendingStripeIntent = {
+  sessionId: string | undefined;
+  id: string;
+  paymentType?: string;
+};
+const StripePaymentContext =
+  createContext<RefObject<PendingStripeIntent | null> | null>(null);
+
+export function usePendingStripeIntent() {
+  const pendingIntent = useContext(StripePaymentContext);
+  if (!pendingIntent) throw new Error('StripeProvider is required');
+  return pendingIntent;
+}
+
 function StripeElementsUpdater({ amount = 0 }: { amount?: number }) {
   const elements = useElements();
 
@@ -25,14 +45,32 @@ export function StripeProvider({
   isExpress?: boolean;
 }) {
   const { stripeConfig } = useCheckoutContext();
+  // The provider survives the checkout button being replaced with a spinner.
+  // Card and express providers each own their continuation reference.
+  const pendingIntent = useRef<PendingStripeIntent | null>(null);
+  return (
+    <StripePaymentContext.Provider value={pendingIntent}>
+      {stripeConfig?.publishableKey?.trim() ? (
+        <StripeElementsProvider isExpress={isExpress}>
+          {children}
+        </StripeElementsProvider>
+      ) : (
+        children
+      )}
+    </StripePaymentContext.Provider>
+  );
+}
 
+function StripeElementsProvider({
+  children,
+  isExpress,
+}: {
+  children: React.ReactNode;
+  isExpress: boolean;
+}) {
   const { stripePromise, currency, clientSecret, isLoading, amount } =
     useStripePaymentIntent({ isExpress });
 
-  if (!stripeConfig?.publishableKey?.trim()) {
-    return <>{children}</>;
-  }
-
   if (isLoading || !stripePromise || amount <= 0) {
     return null;
   }
diff --git a/packages/react/src/components/checkout/payment/utils/use-confirm-checkout-recovery.ts b/packages/react/src/components/checkout/payment/utils/use-confirm-checkout-recovery.ts
new file mode 100644
index 00000000..b1b33f6c
--- /dev/null
+++ b/packages/react/src/components/checkout/payment/utils/use-confirm-checkout-recovery.ts
@@ -0,0 +1,43 @@
+import { useQueryClient } from '@tanstack/react-query';
+import { useCheckoutContext } from '@/components/checkout/checkout';
+import { checkoutQueryKeys } from '@/components/checkout/utils/query-keys';
+import { useGoDaddyContext } from '@/godaddy-provider';
+import { getCheckoutOrderStatus } from '@/lib/godaddy/godaddy';
+import { getPaymentActionRequiredResult } from '@/lib/graphql-with-errors';
+
+// A failed confirmation response does not prove that payment failed. Refresh
+// the authoritative order status before callers unlock checkout and offer another
+// try; a completed order then redirects through usePaidOrderRedirect.
+export function useConfirmCheckoutRecovery() {
+  const queryClient = useQueryClient();
+  const { session, jwt } = useCheckoutContext();
+  const { apiHost } = useGoDaddyContext();
+
+  return async function confirmWithRecovery<T>(
+    confirm: () => Promise<T>
+  ): Promise<T> {
+    try {
+      return await confirm();
+    } catch (error) {
+      if (session?.id && !getPaymentActionRequiredResult(error)) {
+        try {
+          const queryKey = checkoutQueryKeys.orderStatus(session.id);
+          // Discard reads started before confirmation; they may still say unpaid.
+          await queryClient.cancelQueries({ queryKey, exact: true });
+          await queryClient.fetchQuery({
+            queryKey,
+            queryFn: () =>
+              jwt
+                ? getCheckoutOrderStatus({ accessToken: jwt }, apiHost)
+                : getCheckoutOrderStatus(session, apiHost),
+            staleTime: 0,
+            retry: false,
+          });
+        } catch {
+          // Keep the original payment error if the status lookup also fails.
+        }
+      }
+      throw error;
+    }
+  };
+}
diff --git a/packages/react/src/components/checkout/payment/utils/use-confirm-checkout.ts b/packages/react/src/components/checkout/payment/utils/use-confirm-checkout.ts
index a4f48010..38320ef1 100644
--- a/packages/react/src/components/checkout/payment/utils/use-confirm-checkout.ts
+++ b/packages/react/src/components/checkout/payment/utils/use-confirm-checkout.ts
@@ -25,6 +25,8 @@ import {
   track,
 } from '@/tracking/track';
 import type { ConfirmCheckoutMutationInput } from '@/types';
+import { getStripeNextAction } from './stripe-next-action';
+import { useConfirmCheckoutRecovery } from './use-confirm-checkout-recovery';
 
 export class CheckoutConfirmationBlockedError extends Error {
   constructor(message: string) {
@@ -101,6 +103,7 @@ export function useConfirmCheckout() {
   const { data: order } = useDraftOrder();
   const flushCheckoutSync = useFlushCheckoutSync();
   const isPendingRef = useRef(false);
+  const confirmWithRecovery = useConfirmCheckoutRecovery();
 
   return useMutation({
     mutationFn: async (
@@ -218,17 +221,20 @@ export function useConfirmCheckout() {
           },
         });
 
-        const data = jwt
-          ? await confirmCheckout(
-              payload,
-              { accessToken: jwt, sessionId: session?.id || '' },
-              apiHost
-            )
-          : await confirmCheckout(payload, session, apiHost);
+        const data = await confirmWithRecovery(async () => {
+          const result = jwt
+            ? await confirmCheckout(
+                payload,
+                { accessToken: jwt, sessionId: session?.id || '' },
+                apiHost
+              )
+            : await confirmCheckout(payload, session, apiHost);
 
-        if (!data) {
-          throw new Error('Checkout confirmation failed');
-        }
+          if (!result) {
+            throw new Error('Checkout confirmation failed');
+          }
+          return result;
+        });
 
         return data;
       } finally {
@@ -283,6 +289,13 @@ export function useConfirmCheckout() {
     onError: (error: unknown, data) => {
       if (isCheckoutConfirmationBlockedError(error)) return;
 
+      if (
+        data?.paymentProvider === PaymentProvider.STRIPE &&
+        getStripeNextAction(error)
+      ) {
+        return;
+      }
+
       const translate = (code: string) =>
         t.apiErrors?.[code as keyof typeof t.apiErrors];
 
diff --git a/packages/react/src/components/checkout/payment/utils/use-confirm-express-checkout.test.tsx b/packages/react/src/components/checkout/payment/utils/use-confirm-express-checkout.test.tsx
index 3bb8fec8..756fd6a9 100644
--- a/packages/react/src/components/checkout/payment/utils/use-confirm-express-checkout.test.tsx
+++ b/packages/react/src/components/checkout/payment/utils/use-confirm-express-checkout.test.tsx
@@ -1,12 +1,42 @@
-import { renderHook, waitFor } from '@testing-library/react';
+import type { StripeExpressCheckoutElementConfirmEvent } from '@stripe/stripe-js';
+import { useQueryClient } from '@tanstack/react-query';
+import { act, renderHook, waitFor } from '@testing-library/react';
 import React from 'react';
 import { FormProvider, useForm } from 'react-hook-form';
-import { describe, expect, it } from 'vitest';
-import { checkoutContext } from '@/components/checkout/checkout';
+import { describe, expect, it, vi } from 'vitest';
+import {
+  checkoutContext,
+  useCheckoutContext,
+} from '@/components/checkout/checkout';
 import { PaymentProvider } from '@/components/checkout/payment/utils/use-confirm-checkout';
 import { useConfirmExpressCheckout } from '@/components/checkout/payment/utils/use-confirm-express-checkout';
 import { GoDaddyProvider } from '@/godaddy-provider';
+import { confirmCheckout, getCheckoutOrderStatus } from '@/lib/godaddy/godaddy';
+import { GraphQLErrorWithCodes } from '@/lib/graphql-with-errors';
 import { PaymentMethodType } from '@/types';
+import { StripeProvider } from './stripe-provider';
+import { useStripeCheckout } from './use-stripe-checkout';
+
+const stripe = vi.hoisted(() => ({
+  createPaymentMethod: vi.fn(),
+  handleNextAction: vi.fn(),
+}));
+vi.mock('@stripe/react-stripe-js', () => ({
+  CardElement: () => null,
+  useStripe: () => stripe,
+  useElements: () => ({}),
+}));
+vi.mock('./use-build-payment-request', () => ({
+  useBuildPaymentRequest: () => ({}),
+}));
+vi.mock('./use-flush-checkout-sync', () => ({
+  useFlushCheckoutSync: () => vi.fn(),
+}));
+vi.mock('./use-confirm-checkout', async importOriginal => ({
+  ...(await importOriginal<typeof import('./use-confirm-checkout')>()),
+  useConfirmCheckout: () => ({ mutateAsync: vi.fn() }),
+}));
+
 import {
   buildCheckoutSession,
   buildDraftOrder,
@@ -44,7 +74,9 @@ function wrapper(
             setCheckoutErrors,
           }}
         >
-          {formValues ? <MaybeForm>{children}</MaybeForm> : children}
+          <StripeProvider>
+            {formValues ? <MaybeForm>{children}</MaybeForm> : children}
+          </StripeProvider>
         </checkoutContext.Provider>
       </GoDaddyProvider>
     );
@@ -161,4 +193,185 @@ describe('useConfirmExpressCheckout', () => {
 
     expect(getOperations('ConfirmCheckoutSession')).toHaveLength(0);
   });
+  it('keeps checkout locked while checking the order and preserves the original error if that check fails', async () => {
+    const session = buildCheckoutSession();
+    mockGodaddyApi({ session, draftOrder: buildDraftOrder() });
+    const error = new Error('Confirmation response lost');
+    vi.mocked(confirmCheckout).mockRejectedValueOnce(error);
+    let rejectLookup!: (reason: Error) => void;
+    vi.mocked(getCheckoutOrderStatus).mockImplementationOnce(
+      () =>
+        new Promise((_resolve, reject) => {
+          rejectLookup = reject;
+        })
+    );
+    const { result } = renderHook(
+      () => ({
+        confirmation: useConfirmExpressCheckout(),
+        context: useCheckoutContext(),
+      }),
+      { wrapper: wrapper(session) }
+    );
+    const outcome = result.current.confirmation
+      .mutateAsync({
+        paymentToken: 'wallet-nonce',
+        paymentType: 'apple_pay',
+        paymentProvider: PaymentProvider.POYNT,
+      })
+      .catch(caught => caught);
+    await waitFor(() =>
+      expect(getCheckoutOrderStatus).toHaveBeenCalledTimes(1)
+    );
+    expect(result.current.context.isConfirmingCheckout).toBe(true);
+    rejectLookup(new Error('Status lookup failed'));
+    expect(await outcome).toBe(error);
+    await waitFor(() =>
+      expect(result.current.context.isConfirmingCheckout).toBe(false)
+    );
+    expect(confirmCheckout).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not refetch or replace a verification-required response', async () => {
+    const session = buildCheckoutSession();
+    mockGodaddyApi({ session, draftOrder: buildDraftOrder() });
+    const error = new GraphQLErrorWithCodes([
+      {
+        code: 'PAYMENT_ACTION_REQUIRED',
+        extensions: {
+          paymentResult: {
+            status: 'ACTION_REQUIRED',
+            provider: 'STRIPE',
+            nextStep: { type: 'SDK_ACTION' },
+          },
+        },
+      },
+    ]);
+    vi.mocked(confirmCheckout).mockRejectedValueOnce(error);
+    const { result } = renderHook(() => useConfirmExpressCheckout(), {
+      wrapper: wrapper(session),
+    });
+    await expect(
+      result.current.mutateAsync({
+        paymentToken: 'wallet-nonce',
+        paymentType: 'apple_pay',
+        paymentProvider: PaymentProvider.STRIPE,
+      })
+    ).rejects.toBe(error);
+    expect(getCheckoutOrderStatus).not.toHaveBeenCalled();
+  });
 });
+
+it('keeps express checkout locked during 3DS and allows only the matching intent to resume', async () => {
+  const session = buildCheckoutSession();
+  mockGodaddyApi({ session, draftOrder: buildDraftOrder() });
+  vi.mocked(confirmCheckout).mockRejectedValueOnce(
+    new GraphQLErrorWithCodes([
+      {
+        code: 'PAYMENT_ACTION_REQUIRED',
+        extensions: {
+          paymentResult: {
+            status: 'ACTION_REQUIRED',
+            provider: 'STRIPE',
+            paymentReference: 'pi_wallet',
+            nextStep: {
+              type: 'SDK_ACTION',
+              sdk: 'STRIPE_JS',
+              action: 'HANDLE_NEXT_ACTION',
+              clientSecret: 'pi_wallet_secret',
+            },
+          },
+        },
+      },
+    ])
+  );
+  stripe.createPaymentMethod.mockResolvedValue({
+    paymentMethod: { id: 'pm_wallet' },
+  });
+  let finishChallenge!: (value: unknown) => void;
+  stripe.handleNextAction.mockReturnValueOnce(
+    new Promise(resolve => {
+      finishChallenge = resolve;
+    })
+  );
+  const { result } = renderHook(
+    () => ({
+      payment: useStripeCheckout({ mode: 'express' }),
+      otherConfirmation: useConfirmExpressCheckout(),
+      context: useCheckoutContext(),
+    }),
+    { wrapper: wrapper(session) }
+  );
+  let submission!: ReturnType<typeof result.current.payment.handleSubmit>;
+  await act(async () => {
+    submission = result.current.payment.handleSubmit({
+      event: {
+        expressPaymentType: 'google_pay',
+      } as StripeExpressCheckoutElementConfirmEvent,
+    });
+  });
+  await waitFor(() => expect(stripe.handleNextAction).toHaveBeenCalledTimes(1));
+  expect(result.current.context.isConfirmingCheckout).toBe(true);
+  expect(result.current.context.checkoutErrors).toBeUndefined();
+  expect(getCheckoutOrderStatus).not.toHaveBeenCalled();
+  expect(confirmCheckout).toHaveBeenCalledTimes(1);
+  await act(async () => {
+    await expect(
+      result.current.otherConfirmation.mutateAsync({
+        paymentToken: 'pm_other',
+        paymentType: 'google_pay',
+        paymentProvider: PaymentProvider.STRIPE,
+      })
+    ).rejects.toThrow('Checkout confirmation is already in progress');
+  });
+  expect(result.current.context.isConfirmingCheckout).toBe(true);
+  await act(async () => {
+    finishChallenge({
+      paymentIntent: { id: 'pi_wallet', status: 'succeeded' },
+    });
+    await submission;
+  });
+  expect(confirmCheckout).toHaveBeenCalledTimes(2);
+  expect(
+    vi.mocked(confirmCheckout).mock.calls.map(([input]) => input.paymentToken)
+  ).toEqual(['pm_wallet', 'pi_wallet']);
+  expect(stripe.createPaymentMethod).toHaveBeenCalledTimes(1);
+});
+
+it.each(['query', 'mutation'])(
+  'blocks a fresh express payment during another %s',
+  async kind => {
+    const session = buildCheckoutSession();
+    mockGodaddyApi({ session, draftOrder: buildDraftOrder() });
+    const { result } = renderHook(
+      () => ({
+        confirmation: useConfirmExpressCheckout(),
+        client: useQueryClient(),
+      }),
+      { wrapper: wrapper(session) }
+    );
+    let finish!: () => void;
+    const pending = new Promise<void>(resolve => {
+      finish = resolve;
+    });
+    const work =
+      kind === 'query'
+        ? result.current.client.fetchQuery({
+            queryKey: ['other-work'],
+            queryFn: () => pending.then(() => null),
+          })
+        : result.current.client
+            .getMutationCache()
+            .build(result.current.client, { mutationFn: () => pending })
+            .execute(undefined);
+    await expect(
+      result.current.confirmation.mutateAsync({
+        paymentToken: 'pm_wallet',
+        paymentType: 'google_pay',
+        paymentProvider: PaymentProvider.STRIPE,
+      })
+    ).rejects.toThrow('Checkout is currently busy');
+    expect(confirmCheckout).not.toHaveBeenCalled();
+    finish();
+    await work;
+  }
+);
diff --git a/packages/react/src/components/checkout/payment/utils/use-confirm-express-checkout.ts b/packages/react/src/components/checkout/payment/utils/use-confirm-express-checkout.ts
index 1b7bd2a3..2d0176de 100644
--- a/packages/react/src/components/checkout/payment/utils/use-confirm-express-checkout.ts
+++ b/packages/react/src/components/checkout/payment/utils/use-confirm-express-checkout.ts
@@ -1,4 +1,4 @@
-import { useMutation } from '@tanstack/react-query';
+import { useMutation, useQueryClient } from '@tanstack/react-query';
 import { useRef } from 'react';
 import {
   redirectToSuccessUrl,
@@ -9,7 +9,6 @@ import {
   isCheckoutConfirmationBlockedError,
   PaymentProvider,
 } from '@/components/checkout/payment/utils/use-confirm-checkout';
-import { useIsPaymentDisabled } from '@/components/checkout/payment/utils/use-is-payment-disabled';
 import { useGoDaddyContext } from '@/godaddy-provider';
 import { confirmCheckout } from '@/lib/godaddy/godaddy';
 import { eventIds } from '@/tracking/events';
@@ -19,6 +18,8 @@ import {
   track,
 } from '@/tracking/track';
 import type { ConfirmCheckoutMutationInput } from '@/types';
+import { getStripeNextAction } from './stripe-next-action';
+import { useConfirmCheckoutRecovery } from './use-confirm-checkout-recovery';
 
 export function useConfirmExpressCheckout() {
   const {
@@ -29,8 +30,13 @@ export function useConfirmExpressCheckout() {
     setCheckoutErrors,
   } = useCheckoutContext();
   const { apiHost } = useGoDaddyContext();
-  const isPaymentDisabled = useIsPaymentDisabled();
+  const queryClient = useQueryClient();
   const isPendingRef = useRef(false);
+  const pendingActionRef = useRef<{
+    sessionId: string;
+    paymentReference: string;
+  } | null>(null);
+  const confirmWithRecovery = useConfirmCheckoutRecovery();
 
   return useMutation({
     mutationFn: async (
@@ -45,12 +51,20 @@ export function useConfirmExpressCheckout() {
       if (!input?.paymentType) {
         throw new Error('Express checkout payment type is unavailable');
       }
-      if (isConfirmingCheckout) {
+      const isContinuation =
+        input.paymentProvider === PaymentProvider.STRIPE &&
+        pendingActionRef.current?.sessionId === session.id &&
+        pendingActionRef.current.paymentReference === input.paymentToken;
+      if (isConfirmingCheckout && !isContinuation) {
         throw new CheckoutConfirmationBlockedError(
           'Checkout confirmation is already in progress'
         );
       }
-      if (isPaymentDisabled) {
+      // This mutation already contributes one to the live pending count.
+      // A render-time busy flag can count confirmation itself and block resumption.
+      const isOtherWorkPending =
+        queryClient.isMutating() > 1 || queryClient.isFetching() > 0;
+      if (isOtherWorkPending && !isContinuation) {
         throw new CheckoutConfirmationBlockedError(
           'Checkout is currently busy'
         );
@@ -79,17 +93,20 @@ export function useConfirmExpressCheckout() {
           },
         });
 
-        const data = jwt
-          ? await confirmCheckout(
-              confirmCheckoutInput,
-              { accessToken: jwt, sessionId: session?.id || '' },
-              apiHost
-            )
-          : await confirmCheckout(confirmCheckoutInput, session, apiHost);
+        const data = await confirmWithRecovery(async () => {
+          const result = jwt
+            ? await confirmCheckout(
+                confirmCheckoutInput,
+                { accessToken: jwt, sessionId: session?.id || '' },
+                apiHost
+              )
+            : await confirmCheckout(confirmCheckoutInput, session, apiHost);
 
-        if (!data) {
-          throw new Error('Express checkout confirmation failed');
-        }
+          if (!result) {
+            throw new Error('Express checkout confirmation failed');
+          }
+          return result;
+        });
 
         return data;
       } finally {
@@ -98,6 +115,7 @@ export function useConfirmExpressCheckout() {
     },
     onSuccess: (data, input) => {
       if (!data) return;
+      pendingActionRef.current = null;
       let completedEventId: TrackingEventId | null = null;
       switch (input.paymentType) {
         case 'apple_pay':
@@ -143,6 +161,20 @@ export function useConfirmExpressCheckout() {
     onError: (error: unknown, data) => {
       if (isCheckoutConfirmationBlockedError(error)) return;
 
+      const nextAction = getStripeNextAction(error);
+      if (
+        data?.paymentProvider === PaymentProvider.STRIPE &&
+        nextAction &&
+        session?.id
+      ) {
+        pendingActionRef.current = {
+          sessionId: session.id,
+          paymentReference: nextAction.paymentReference,
+        };
+        return;
+      }
+      pendingActionRef.current = null;
+
       track({
         eventId: eventIds.checkoutError,
         type: TrackingEventType.EVENT,
diff --git a/packages/react/src/components/checkout/payment/utils/use-stripe-checkout.integration.test.tsx b/packages/react/src/components/checkout/payment/utils/use-stripe-checkout.integration.test.tsx
index 488de166..b9f4b73f 100644
--- a/packages/react/src/components/checkout/payment/utils/use-stripe-checkout.integration.test.tsx
+++ b/packages/react/src/components/checkout/payment/utils/use-stripe-checkout.integration.test.tsx
@@ -1,25 +1,43 @@
-import { act, renderHook } from '@testing-library/react';
+import type { StripeExpressCheckoutElementConfirmEvent } from '@stripe/stripe-js';
+import { act, render, renderHook } from '@testing-library/react';
 import React from 'react';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { checkoutContext } from '@/components/checkout/checkout';
+import { GraphQLErrorWithCodes } from '@/lib/graphql-with-errors';
+import { eventIds } from '@/tracking/events';
 import type { DraftOrder } from '@/types';
+import { StripeProvider } from './stripe-provider';
+import { CheckoutConfirmationBlockedError } from './use-confirm-checkout';
 import { useStripeCheckout } from './use-stripe-checkout';
 
 const mocks = vi.hoisted(() => ({
+  sessionId: 'session-1',
   latestOrder: { id: 'latest-order' } as DraftOrder,
   flush: vi.fn(),
   buildFromOrder: vi.fn(),
   createPaymentMethod: vi.fn(),
+  handleNextAction: vi.fn(),
   confirm: vi.fn(),
   confirmExpress: vi.fn(),
+  setCheckoutErrors: vi.fn(),
+  setIsConfirmingCheckout: vi.fn(),
+  track: vi.fn(),
   cardElement: {},
 }));
 
+vi.mock('@/tracking/track', () => ({
+  track: mocks.track,
+  TrackingEventType: { EVENT: 'event' },
+}));
+
 vi.mock('@stripe/react-stripe-js', () => ({
   CardElement: function CardElement() {
     return null;
   },
-  useStripe: () => ({ createPaymentMethod: mocks.createPaymentMethod }),
+  useStripe: () => ({
+    createPaymentMethod: mocks.createPaymentMethod,
+    handleNextAction: mocks.handleNextAction,
+  }),
   useElements: () => ({
     getElement: () => mocks.cardElement,
   }),
@@ -65,20 +83,193 @@ function Wrapper({ children }: { children: React.ReactNode }) {
   return (
     <checkoutContext.Provider
       value={{
-        session: { id: 'session-1' } as never,
+        session: { id: mocks.sessionId } as never,
         isConfirmingCheckout: false,
-        setIsConfirmingCheckout: vi.fn(),
-        setCheckoutErrors: vi.fn(),
+        setIsConfirmingCheckout: mocks.setIsConfirmingCheckout,
+        setCheckoutErrors: mocks.setCheckoutErrors,
       }}
     >
-      {children}
+      <StripeProvider>{children}</StripeProvider>
     </checkoutContext.Provider>
   );
 }
 
+function actionRequiredError() {
+  return new GraphQLErrorWithCodes([
+    {
+      code: 'PAYMENT_ACTION_REQUIRED',
+      extensions: {
+        paymentResult: {
+          status: 'ACTION_REQUIRED',
+          provider: 'STRIPE',
+          paymentReference: 'pi-confirmed',
+          nextStep: {
+            type: 'SDK_ACTION',
+            sdk: 'STRIPE_JS',
+            action: 'HANDLE_NEXT_ACTION',
+            clientSecret: 'pi-secret',
+          },
+        },
+      },
+    },
+  ]);
+}
+
+describe.each(['card', 'express'] as const)(
+  '%s transaction status recovery',
+  mode => {
+    const confirm = mode === 'card' ? mocks.confirm : mocks.confirmExpress;
+
+    beforeEach(() => {
+      vi.resetAllMocks();
+      mocks.sessionId = 'session-1';
+      mocks.flush.mockResolvedValue({ latestOrder: mocks.latestOrder });
+      mocks.buildFromOrder.mockReturnValue({ stripePaymentMethodParams: {} });
+      mocks.createPaymentMethod
+        .mockResolvedValueOnce({ paymentMethod: { id: 'pm_original' } })
+        .mockResolvedValue({ paymentMethod: { id: 'pm_replacement' } });
+      mocks.handleNextAction.mockResolvedValue({
+        paymentIntent: { id: 'pi-confirmed', status: 'requires_confirmation' },
+      });
+      confirm.mockResolvedValue(undefined);
+    });
+
+    async function submitFailure(
+      submit: () => Promise<unknown>,
+      error: unknown
+    ) {
+      await act(async () => {
+        if (mode === 'express') await expect(submit()).rejects.toBe(error);
+        else await submit();
+      });
+    }
+
+    it.each(['final confirmation', 'later retry'])(
+      'allows a replacement payment after FAILED during %s',
+      async stage => {
+        const failure = new GraphQLErrorWithCodes([
+          {
+            code: 'TRANSACTION_PROCESSING_FAILED',
+            extensions: { transactionStatus: 'FAILED' },
+          },
+        ]);
+        const networkError = new Error('Connection lost');
+        confirm.mockRejectedValueOnce(actionRequiredError());
+        if (stage === 'later retry')
+          confirm.mockRejectedValueOnce(networkError);
+        confirm.mockRejectedValueOnce(failure);
+        const { result } = renderHook(() => useStripeCheckout({ mode }), {
+          wrapper: Wrapper,
+        });
+
+        if (stage === 'later retry') {
+          await submitFailure(
+            () => result.current.handleSubmit(),
+            networkError
+          );
+        }
+        await submitFailure(() => result.current.handleSubmit(), failure);
+        expect(mocks.setCheckoutErrors).toHaveBeenLastCalledWith([
+          'TRANSACTION_PROCESSING_FAILED',
+        ]);
+        await act(async () => {
+          await result.current.handleSubmit();
+        });
+
+        expect(confirm.mock.calls.map(([input]) => input.paymentToken)).toEqual(
+          [
+            'pm_original',
+            'pi-confirmed',
+            ...(stage === 'later retry' ? ['pi-confirmed'] : []),
+            'pm_replacement',
+          ]
+        );
+        expect(mocks.createPaymentMethod).toHaveBeenCalledTimes(2);
+        expect(mocks.handleNextAction).toHaveBeenCalledTimes(1);
+      }
+    );
+
+    it.each([
+      ['missing status', undefined],
+      ['pending', 'PENDING'],
+      ['initiated', 'INITIATED'],
+      ['completed', 'COMPLETED'],
+      ['voided', 'VOIDED'],
+      ['unknown status', 'UNKNOWN'],
+      ['malformed status', { status: 'FAILED' }],
+    ])('retains the intent for %s', async (_, transactionStatus) => {
+      const error = new GraphQLErrorWithCodes([
+        {
+          code: 'TRANSACTION_PROCESSING_FAILED',
+          extensions: { transactionStatus },
+        },
+      ]);
+      confirm
+        .mockRejectedValueOnce(actionRequiredError())
+        .mockRejectedValueOnce(error);
+      const { result } = renderHook(() => useStripeCheckout({ mode }), {
+        wrapper: Wrapper,
+      });
+
+      await submitFailure(() => result.current.handleSubmit(), error);
+      await act(async () => {
+        await result.current.handleSubmit();
+      });
+
+      expect(confirm.mock.calls.map(([input]) => input.paymentToken)).toEqual([
+        'pm_original',
+        'pi-confirmed',
+        'pi-confirmed',
+      ]);
+      expect(mocks.createPaymentMethod).toHaveBeenCalledTimes(1);
+    });
+
+    it.each([
+      [
+        {
+          code: 'ORDER_OPENING_FAILED',
+          extensions: { transactionStatus: 'FAILED' },
+        },
+      ],
+      [
+        {
+          code: 'TRANSACTION_PROCESSING_FAILED',
+          extensions: { transactionStatus: 'FAILED' },
+        },
+        {
+          code: 'TRANSACTION_PROCESSING_FAILED',
+          extensions: { transactionStatus: 'PENDING' },
+        },
+      ],
+    ])(
+      'retains the intent for unrelated or conflicting failure metadata (%#)',
+      async (...errors) => {
+        const error = new GraphQLErrorWithCodes(errors);
+        confirm
+          .mockRejectedValueOnce(actionRequiredError())
+          .mockRejectedValueOnce(error);
+        const { result } = renderHook(() => useStripeCheckout({ mode }), {
+          wrapper: Wrapper,
+        });
+
+        await submitFailure(() => result.current.handleSubmit(), error);
+        await act(async () => {
+          await result.current.handleSubmit();
+        });
+
+        expect(confirm).toHaveBeenLastCalledWith(
+          expect.objectContaining({ paymentToken: 'pi-confirmed' })
+        );
+        expect(mocks.createPaymentMethod).toHaveBeenCalledTimes(1);
+      }
+    );
+  }
+);
+
 describe('useStripeCheckout payment request resolution', () => {
   beforeEach(() => {
     vi.clearAllMocks();
+    mocks.sessionId = 'session-1';
     mocks.flush.mockResolvedValue({ latestOrder: mocks.latestOrder });
     mocks.buildFromOrder.mockReturnValue({
       stripePaymentMethodParams: {
@@ -88,6 +279,9 @@ describe('useStripeCheckout payment request resolution', () => {
     mocks.createPaymentMethod.mockResolvedValue({
       paymentMethod: { id: 'stripe-payment-method' },
     });
+    mocks.handleNextAction.mockResolvedValue({
+      paymentIntent: { id: 'pi-confirmed', status: 'succeeded' },
+    });
     mocks.confirm.mockResolvedValue(undefined);
     mocks.confirmExpress.mockResolvedValue(undefined);
   });
@@ -120,6 +314,237 @@ describe('useStripeCheckout payment request resolution', () => {
     );
   });
 
+  it.each([
+    ['card', undefined],
+    ['express', 'apple_pay'],
+    ['express', 'google_pay'],
+    ['express', 'link'],
+  ] as const)(
+    'ignores a duplicate %s %s submission without affecting the active payment',
+    async (mode, expressPaymentType) => {
+      let finish!: () => void;
+      const active = new Promise<void>(resolve => {
+        finish = resolve;
+      });
+      const confirm = mode === 'card' ? mocks.confirm : mocks.confirmExpress;
+      confirm.mockReturnValueOnce(active);
+      const { result } = renderHook(() => useStripeCheckout({ mode }), {
+        wrapper: Wrapper,
+      });
+      const expressData =
+        mode === 'express'
+          ? {
+              event: {
+                expressPaymentType,
+              } as StripeExpressCheckoutElementConfirmEvent,
+            }
+          : undefined;
+      let first!: ReturnType<typeof result.current.handleSubmit>;
+      await act(async () => {
+        first = result.current.handleSubmit(expressData);
+      });
+      expect(confirm).toHaveBeenCalledTimes(1);
+
+      await act(async () => {
+        await expect(
+          result.current.handleSubmit(expressData)
+        ).resolves.toBeUndefined();
+      });
+      expect(mocks.createPaymentMethod).toHaveBeenCalledTimes(1);
+      expect(confirm).toHaveBeenCalledTimes(1);
+      expect(result.current.isProcessingPayment).toBe(true);
+      expect(mocks.setCheckoutErrors).not.toHaveBeenCalled();
+      expect(mocks.setIsConfirmingCheckout).not.toHaveBeenCalled();
+      expect(mocks.track).not.toHaveBeenCalled();
+
+      await act(async () => {
+        finish();
+        await first;
+      });
+      expect(result.current.isProcessingPayment).toBe(false);
+      if (mode === 'express') {
+        expect(mocks.track).toHaveBeenCalledTimes(1);
+        expect(mocks.track).toHaveBeenCalledWith(
+          expect.objectContaining({
+            eventId: eventIds.expressCheckoutCompleted,
+            properties: { paymentType: expressPaymentType, provider: 'stripe' },
+          })
+        );
+      }
+    }
+  );
+
+  it.each(['card', 'express'] as const)(
+    'does not unlock checkout when a %s confirmation belongs to another submission',
+    async mode => {
+      const blocked = new CheckoutConfirmationBlockedError(
+        'Checkout confirmation is already in progress'
+      );
+      const confirm = mode === 'card' ? mocks.confirm : mocks.confirmExpress;
+      confirm.mockRejectedValueOnce(blocked);
+      const { result } = renderHook(() => useStripeCheckout({ mode }), {
+        wrapper: Wrapper,
+      });
+      await act(async () => {
+        if (mode === 'express') {
+          await expect(result.current.handleSubmit()).rejects.toBe(blocked);
+        } else {
+          await result.current.handleSubmit();
+        }
+      });
+      expect(mocks.setCheckoutErrors).not.toHaveBeenCalled();
+      expect(mocks.setIsConfirmingCheckout).not.toHaveBeenCalled();
+      expect(result.current.isProcessingPayment).toBe(false);
+    }
+  );
+
+  it('handles a valid Stripe next step and retries confirmation with the PaymentIntent', async () => {
+    mocks.confirm
+      .mockRejectedValueOnce(
+        new GraphQLErrorWithCodes([
+          {
+            message: 'Payment requires additional customer action',
+            code: 'PAYMENT_ACTION_REQUIRED',
+            extensions: {
+              paymentResult: {
+                status: 'ACTION_REQUIRED',
+                provider: 'STRIPE',
+                paymentReference: 'pi-confirmed',
+                nextStep: {
+                  type: 'SDK_ACTION',
+                  sdk: 'STRIPE_JS',
+                  action: 'HANDLE_NEXT_ACTION',
+                  actionId: 'pi-confirmed',
+                  clientSecret: 'pi-confirmed-secret',
+                },
+              },
+            },
+          },
+        ])
+      )
+      .mockResolvedValueOnce(undefined);
+
+    const { result } = renderHook(() => useStripeCheckout({ mode: 'card' }), {
+      wrapper: Wrapper,
+    });
+
+    await act(async () => {
+      await result.current.handleSubmit();
+    });
+
+    expect(mocks.handleNextAction).toHaveBeenCalledWith({
+      clientSecret: 'pi-confirmed-secret',
+    });
+    expect(mocks.confirm).toHaveBeenNthCalledWith(1, {
+      paymentToken: 'stripe-payment-method',
+      paymentType: 'card',
+      paymentProvider: 'STRIPE',
+    });
+    expect(mocks.confirm).toHaveBeenNthCalledWith(2, {
+      paymentToken: 'pi-confirmed',
+      paymentType: 'card',
+      paymentProvider: 'STRIPE',
+    });
+    expect(mocks.setIsConfirmingCheckout).not.toHaveBeenCalledWith(false);
+  });
+
+  it('does not run Stripe next actions for legacy GraphQL errors without the 3DS extension', async () => {
+    mocks.confirm.mockRejectedValueOnce(
+      new GraphQLErrorWithCodes([
+        {
+          message: 'Failed to process transaction',
+          code: 'TRANSACTION_PROCESSING_FAILED',
+        },
+      ])
+    );
+
+    const { result } = renderHook(() => useStripeCheckout({ mode: 'card' }), {
+      wrapper: Wrapper,
+    });
+
+    await act(async () => {
+      await result.current.handleSubmit();
+    });
+
+    expect(mocks.handleNextAction).not.toHaveBeenCalled();
+    expect(mocks.setCheckoutErrors).toHaveBeenCalledWith([
+      'TRANSACTION_PROCESSING_FAILED',
+    ]);
+    expect(mocks.setIsConfirmingCheckout).toHaveBeenCalledWith(false);
+  });
+
+  it('does not run Stripe for malformed action-required extensions', async () => {
+    mocks.confirm.mockRejectedValueOnce(
+      new GraphQLErrorWithCodes([
+        {
+          code: 'PAYMENT_ACTION_REQUIRED',
+          extensions: {
+            paymentResult: {
+              status: 'ACTION_REQUIRED',
+              provider: 'STRIPE',
+              nextStep: {
+                type: 'SDK_ACTION',
+                sdk: 'STRIPE_JS',
+                action: 'HANDLE_NEXT_ACTION',
+              },
+            },
+          },
+        },
+      ])
+    );
+
+    const { result } = renderHook(() => useStripeCheckout({ mode: 'card' }), {
+      wrapper: Wrapper,
+    });
+
+    await act(async () => {
+      await result.current.handleSubmit();
+    });
+
+    expect(mocks.handleNextAction).not.toHaveBeenCalled();
+    expect(mocks.setIsConfirmingCheckout).toHaveBeenCalledWith(false);
+  });
+
+  it('unlocks checkout when Stripe cannot complete the next action', async () => {
+    mocks.confirm.mockRejectedValueOnce(
+      new GraphQLErrorWithCodes([
+        {
+          code: 'PAYMENT_ACTION_REQUIRED',
+          extensions: {
+            paymentResult: {
+              status: 'ACTION_REQUIRED',
+              provider: 'STRIPE',
+              paymentReference: 'pi-confirmed',
+              nextStep: {
+                type: 'SDK_ACTION',
+                sdk: 'STRIPE_JS',
+                action: 'HANDLE_NEXT_ACTION',
+                clientSecret: 'pi-secret',
+              },
+            },
+          },
+        },
+      ])
+    );
+    mocks.handleNextAction.mockResolvedValueOnce({
+      error: { code: 'payment_intent_authentication_failure' },
+    });
+
+    const { result } = renderHook(() => useStripeCheckout({ mode: 'card' }), {
+      wrapper: Wrapper,
+    });
+
+    await act(async () => {
+      await result.current.handleSubmit();
+    });
+
+    expect(mocks.confirm).toHaveBeenCalledTimes(1);
+    expect(mocks.setCheckoutErrors).toHaveBeenCalledWith([
+      'AUTHORIZATION_FAILED',
+    ]);
+    expect(mocks.setIsConfirmingCheckout).toHaveBeenCalledWith(false);
+  });
+
   it('tokenizes express billing from the wallet event without flushing form data', async () => {
     const { result } = renderHook(
       () => useStripeCheckout({ mode: 'express' }),
@@ -174,4 +599,509 @@ describe('useStripeCheckout payment request resolution', () => {
       })
     );
   });
+  it.each([
+    'requires_payment_method',
+    'requires_action',
+    'canceled',
+    undefined,
+  ])('does not retry confirmation for intent status %s', async status => {
+    mocks.confirm.mockRejectedValueOnce(actionRequiredError());
+    mocks.handleNextAction.mockResolvedValueOnce({
+      paymentIntent: { id: 'pi-confirmed', status },
+    });
+    const { result } = renderHook(() => useStripeCheckout({ mode: 'card' }), {
+      wrapper: Wrapper,
+    });
+    await act(async () => {
+      await result.current.handleSubmit();
+    });
+    expect(mocks.confirm).toHaveBeenCalledTimes(1);
+    expect(mocks.setCheckoutErrors).toHaveBeenCalledWith([
+      'AUTHORIZATION_FAILED',
+    ]);
+    expect(mocks.setIsConfirmingCheckout).toHaveBeenCalledWith(false);
+  });
+
+  it.each([
+    'succeeded',
+    'processing',
+    'requires_capture',
+    'requires_confirmation',
+  ])(
+    'lets the server decide payment completion after SDK status %s',
+    async status => {
+      mocks.confirm.mockRejectedValueOnce(actionRequiredError());
+      mocks.handleNextAction.mockResolvedValueOnce({
+        paymentIntent: { id: 'pi-confirmed', status },
+      });
+      const { result } = renderHook(() => useStripeCheckout({ mode: 'card' }), {
+        wrapper: Wrapper,
+      });
+      await act(async () => {
+        await result.current.handleSubmit();
+      });
+      expect(mocks.confirm).toHaveBeenCalledTimes(2);
+      expect(mocks.confirm).toHaveBeenLastCalledWith(
+        expect.objectContaining({ paymentToken: 'pi-confirmed' })
+      );
+      expect(mocks.setCheckoutErrors).not.toHaveBeenCalled();
+    }
+  );
+
+  it.each([
+    ['network failure', new Error('Failed to fetch')],
+    [
+      'backend failure',
+      new GraphQLErrorWithCodes([{ code: 'TRANSACTION_PROCESSING_FAILED' }]),
+    ],
+  ])(
+    'reuses the authenticated intent across retries after %s',
+    async (_, error) => {
+      mocks.confirm
+        .mockRejectedValueOnce(actionRequiredError())
+        .mockRejectedValueOnce(error)
+        .mockRejectedValueOnce(error)
+        .mockResolvedValueOnce(undefined);
+      const { result, rerender } = renderHook(
+        () => useStripeCheckout({ mode: 'card' }),
+        {
+          wrapper: Wrapper,
+        }
+      );
+
+      await act(async () => {
+        await result.current.handleSubmit();
+      });
+      expect(mocks.setIsConfirmingCheckout).toHaveBeenCalledWith(false);
+      expect(result.current.isProcessingPayment).toBe(false);
+      rerender();
+      await act(async () => {
+        await result.current.handleSubmit();
+      });
+      await act(async () => {
+        await result.current.handleSubmit();
+      });
+
+      expect(
+        mocks.confirm.mock.calls.map(([input]) => input.paymentToken)
+      ).toEqual([
+        'stripe-payment-method',
+        'pi-confirmed',
+        'pi-confirmed',
+        'pi-confirmed',
+      ]);
+      expect(mocks.createPaymentMethod).toHaveBeenCalledTimes(1);
+      expect(mocks.handleNextAction).toHaveBeenCalledTimes(1);
+      expect(result.current.isProcessingPayment).toBe(false);
+    }
+  );
+
+  it('does not reuse an authenticated intent in another checkout session', async () => {
+    mocks.confirm
+      .mockRejectedValueOnce(actionRequiredError())
+      .mockRejectedValueOnce(new Error('Failed to fetch'));
+    const { result, rerender } = renderHook(
+      () => useStripeCheckout({ mode: 'card' }),
+      {
+        wrapper: Wrapper,
+      }
+    );
+    await act(async () => {
+      await result.current.handleSubmit();
+    });
+    mocks.sessionId = 'session-2';
+    rerender();
+    await act(async () => {
+      await result.current.handleSubmit();
+    });
+    expect(mocks.confirm).toHaveBeenLastCalledWith(
+      expect.objectContaining({ paymentToken: 'stripe-payment-method' })
+    );
+    expect(mocks.createPaymentMethod).toHaveBeenCalledTimes(2);
+  });
+
+  it.each(['rejected promise', 'SDK error result'])(
+    'reconciles the original intent after an SDK transport failure: %s',
+    async failure => {
+      mocks.confirm.mockRejectedValueOnce(actionRequiredError());
+      if (failure === 'rejected promise') {
+        mocks.handleNextAction.mockRejectedValueOnce(
+          new Error('Connection lost')
+        );
+      } else {
+        mocks.handleNextAction.mockResolvedValueOnce({
+          error: { type: 'api_connection_error' },
+        });
+      }
+      const { result } = renderHook(() => useStripeCheckout({ mode: 'card' }), {
+        wrapper: Wrapper,
+      });
+      await act(async () => {
+        await result.current.handleSubmit();
+      });
+      expect(mocks.setIsConfirmingCheckout).toHaveBeenCalledWith(false);
+      await act(async () => {
+        await result.current.handleSubmit();
+      });
+      expect(
+        mocks.confirm.mock.calls.map(([input]) => input.paymentToken)
+      ).toEqual(['stripe-payment-method', 'pi-confirmed']);
+      expect(mocks.createPaymentMethod).toHaveBeenCalledTimes(1);
+    }
+  );
+
+  it.each(['requires_payment_method', 'canceled'])(
+    'allows a replacement only after Stripe reports the saved intent as %s',
+    async status => {
+      mocks.confirm.mockRejectedValueOnce(actionRequiredError());
+      mocks.handleNextAction.mockResolvedValueOnce({
+        error: {
+          code: 'payment_intent_authentication_failure',
+          payment_intent: { id: 'pi-confirmed', status },
+        },
+      });
+      const { result } = renderHook(() => useStripeCheckout({ mode: 'card' }), {
+        wrapper: Wrapper,
+      });
+      await act(async () => {
+        await result.current.handleSubmit();
+      });
+      await act(async () => {
+        await result.current.handleSubmit();
+      });
+      expect(mocks.createPaymentMethod).toHaveBeenCalledTimes(2);
+      expect(mocks.confirm).toHaveBeenLastCalledWith(
+        expect.objectContaining({ paymentToken: 'stripe-payment-method' })
+      );
+    }
+  );
+});
+
+describe('Stripe express verification', () => {
+  const expressData = {
+    event: {
+      expressPaymentType: 'google_pay',
+      billingDetails: { name: 'Wallet Buyer', email: 'buyer@example.com' },
+      shippingAddress: {
+        name: 'Wallet Buyer',
+        address: {
+          line1: '123 Main St',
+          city: 'Austin',
+          state: 'TX',
+          postal_code: '78701',
+          country: 'US',
+        },
+      },
+    } as StripeExpressCheckoutElementConfirmEvent,
+    shippingTotal: { currencyCode: 'USD', value: 500 },
+    selectedShippingMethod: {
+      displayName: 'Standard',
+      carrierCode: 'carrier',
+      serviceCode: 'standard',
+      cost: null,
+      description: null,
+      features: null,
+      maxDeliveryDate: null,
+      minDeliveryDate: null,
+    },
+  };
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+    mocks.sessionId = 'session-1';
+    mocks.createPaymentMethod.mockResolvedValue({
+      paymentMethod: {
+        id: 'pm_wallet',
+        card: { wallet: { type: 'google_pay' } },
+      },
+    });
+    mocks.handleNextAction.mockResolvedValue({
+      paymentIntent: { id: 'pi-confirmed', status: 'succeeded' },
+    });
+    mocks.confirmExpress.mockResolvedValue(undefined);
+  });
+
+  it.each([
+    'succeeded',
+    'processing',
+    'requires_capture',
+    'requires_confirmation',
+  ])(
+    'resumes the express intent after %s and preserves the wallet payload',
+    async status => {
+      mocks.confirmExpress.mockRejectedValueOnce(actionRequiredError());
+      mocks.handleNextAction.mockResolvedValueOnce({
+        paymentIntent: { id: 'pi-confirmed', status },
+      });
+      const { result } = renderHook(
+        () => useStripeCheckout({ mode: 'express' }),
+        { wrapper: Wrapper }
+      );
+      await act(async () => {
+        await result.current.handleSubmit(expressData);
+      });
+      expect(mocks.handleNextAction).toHaveBeenCalledWith({
+        clientSecret: 'pi-secret',
+      });
+      expect(mocks.confirmExpress).toHaveBeenCalledTimes(2);
+      const initialInput = mocks.confirmExpress.mock.calls[0][0];
+      expect(initialInput).toMatchObject({
+        paymentToken: 'pm_wallet',
+        paymentType: 'google_pay',
+        paymentProvider: 'STRIPE',
+        isExpress: true,
+        billing: { email: 'buyer@example.com' },
+        shipping: { address: { addressLine1: '123 Main St' } },
+        shippingTotal: { currencyCode: 'USD', value: 500 },
+        shippingLines: [{ name: 'Standard' }],
+      });
+      expect(mocks.confirmExpress.mock.calls[1][0]).toEqual({
+        ...initialInput,
+        paymentToken: 'pi-confirmed',
+      });
+      expect(mocks.createPaymentMethod).toHaveBeenCalledTimes(1);
+      expect(mocks.setCheckoutErrors).not.toHaveBeenCalled();
+      expect(mocks.track).toHaveBeenCalledWith(
+        expect.objectContaining({
+          eventId: eventIds.expressCheckoutCompleted,
+          properties: { paymentType: 'google_pay', provider: 'stripe' },
+        })
+      );
+    }
+  );
+
+  it('ignores secondary submissions throughout the challenge and final confirmation', async () => {
+    mocks.confirmExpress.mockRejectedValueOnce(actionRequiredError());
+    let completeChallenge!: (value: unknown) => void;
+    mocks.handleNextAction.mockReturnValueOnce(
+      new Promise(resolve => {
+        completeChallenge = resolve;
+      })
+    );
+    let completeConfirmation!: () => void;
+    mocks.confirmExpress.mockReturnValueOnce(
+      new Promise<void>(resolve => {
+        completeConfirmation = resolve;
+      })
+    );
+    const { result } = renderHook(
+      () => useStripeCheckout({ mode: 'express' }),
+      { wrapper: Wrapper }
+    );
+    let submission!: ReturnType<typeof result.current.handleSubmit>;
+    await act(async () => {
+      submission = result.current.handleSubmit(expressData);
+    });
+    await act(async () => {
+      await result.current.handleSubmit(expressData);
+    });
+    expect(mocks.confirmExpress).toHaveBeenCalledTimes(1);
+    expect(result.current.isProcessingPayment).toBe(true);
+    await act(async () => {
+      completeChallenge({
+        paymentIntent: { id: 'pi-confirmed', status: 'succeeded' },
+      });
+    });
+    await act(async () => {
+      await result.current.handleSubmit(expressData);
+    });
+    expect(mocks.confirmExpress).toHaveBeenCalledTimes(2);
+    expect(mocks.createPaymentMethod).toHaveBeenCalledTimes(1);
+    expect(mocks.track).not.toHaveBeenCalledWith(
+      expect.objectContaining({ eventId: eventIds.expressCheckoutCompleted })
+    );
+    await act(async () => {
+      completeConfirmation();
+      await submission;
+    });
+    expect(result.current.isProcessingPayment).toBe(false);
+  });
+
+  it.each(['canceled', 'requires_payment_method'])(
+    'reports authentication failure and permits a new wallet attempt after %s',
+    async status => {
+      mocks.confirmExpress.mockRejectedValueOnce(actionRequiredError());
+      mocks.handleNextAction.mockResolvedValueOnce({
+        error: {
+          code: 'payment_intent_authentication_failure',
+          payment_intent: { id: 'pi-confirmed', status },
+        },
+      });
+      const { result } = renderHook(
+        () => useStripeCheckout({ mode: 'express' }),
+        { wrapper: Wrapper }
+      );
+      await act(async () => {
+        await expect(
+          result.current.handleSubmit(expressData)
+        ).rejects.toBeInstanceOf(GraphQLErrorWithCodes);
+      });
+      expect(mocks.confirmExpress).toHaveBeenCalledTimes(1);
+      expect(mocks.setCheckoutErrors).toHaveBeenCalledWith([
+        'AUTHORIZATION_FAILED',
+      ]);
+      expect(mocks.setIsConfirmingCheckout).toHaveBeenCalledWith(false);
+      expect(mocks.track).not.toHaveBeenCalledWith(
+        expect.objectContaining({ eventId: eventIds.expressCheckoutCompleted })
+      );
+      await act(async () => {
+        await result.current.handleSubmit(expressData);
+      });
+      expect(mocks.createPaymentMethod).toHaveBeenCalledTimes(2);
+    }
+  );
+
+  it.each(['SDK transport', 'final confirmation'])(
+    'reuses the intent after an uncertain %s failure and hook remount',
+    async stage => {
+      const failure = new Error('Connection lost');
+      mocks.confirmExpress.mockRejectedValueOnce(actionRequiredError());
+      if (stage === 'SDK transport')
+        mocks.handleNextAction.mockRejectedValueOnce(failure);
+      else mocks.confirmExpress.mockRejectedValueOnce(failure);
+      let current!: ReturnType<typeof useStripeCheckout>;
+      function Payment() {
+        current = useStripeCheckout({ mode: 'express' });
+        return null;
+      }
+      const { rerender } = render(
+        <Wrapper>
+          <Payment />
+        </Wrapper>
+      );
+      await act(async () => {
+        await expect(current.handleSubmit(expressData)).rejects.toBe(failure);
+      });
+      rerender(<Wrapper>{null}</Wrapper>);
+      rerender(
+        <Wrapper>
+          <Payment />
+        </Wrapper>
+      );
+      await act(async () => {
+        await current.handleSubmit(expressData);
+      });
+      expect(mocks.createPaymentMethod).toHaveBeenCalledTimes(1);
+      expect(mocks.confirmExpress).toHaveBeenLastCalledWith(
+        expect.objectContaining({
+          paymentToken: 'pi-confirmed',
+          paymentType: 'google_pay',
+        })
+      );
+    }
+  );
+
+  it.each([
+    [
+      'legacy failure',
+      new GraphQLErrorWithCodes([{ code: 'TRANSACTION_PROCESSING_FAILED' }]),
+    ],
+    [
+      'unsupported next action',
+      new GraphQLErrorWithCodes([
+        {
+          code: 'PAYMENT_ACTION_REQUIRED',
+          extensions: {
+            paymentResult: {
+              status: 'ACTION_REQUIRED',
+              provider: 'STRIPE',
+              paymentReference: 'pi-confirmed',
+              nextStep: { type: 'REDIRECT', url: 'https://example.com/verify' },
+            },
+          },
+        },
+      ]),
+    ],
+  ])('fails safely for %s without invoking the SDK', async (_, error) => {
+    mocks.confirmExpress.mockRejectedValueOnce(error);
+    const { result } = renderHook(
+      () => useStripeCheckout({ mode: 'express' }),
+      { wrapper: Wrapper }
+    );
+    await act(async () => {
+      await expect(result.current.handleSubmit(expressData)).rejects.toBe(
+        error
+      );
+    });
+    expect(mocks.handleNextAction).not.toHaveBeenCalled();
+    expect(mocks.setCheckoutErrors).toHaveBeenCalledWith([
+      'TRANSACTION_PROCESSING_FAILED',
+    ]);
+    expect(mocks.setIsConfirmingCheckout).toHaveBeenCalledWith(false);
+  });
+
+  it('does not loop when final confirmation still requires action', async () => {
+    mocks.confirmExpress
+      .mockRejectedValueOnce(actionRequiredError())
+      .mockRejectedValueOnce(actionRequiredError());
+    const { result } = renderHook(
+      () => useStripeCheckout({ mode: 'express' }),
+      { wrapper: Wrapper }
+    );
+    await act(async () => {
+      await expect(
+        result.current.handleSubmit(expressData)
+      ).rejects.toBeInstanceOf(GraphQLErrorWithCodes);
+    });
+    expect(mocks.handleNextAction).toHaveBeenCalledTimes(1);
+    expect(mocks.confirmExpress).toHaveBeenCalledTimes(2);
+    expect(mocks.setCheckoutErrors).toHaveBeenCalledWith([
+      'TRANSACTION_PROCESSING_FAILED',
+    ]);
+    await act(async () => {
+      await result.current.handleSubmit(expressData);
+    });
+    expect(mocks.createPaymentMethod).toHaveBeenCalledTimes(1);
+    expect(mocks.confirmExpress).toHaveBeenLastCalledWith(
+      expect.objectContaining({ paymentToken: 'pi-confirmed' })
+    );
+  });
+
+  it('does not submit an SDK result belonging to another intent', async () => {
+    mocks.confirmExpress.mockRejectedValueOnce(actionRequiredError());
+    mocks.handleNextAction.mockResolvedValueOnce({
+      paymentIntent: { id: 'pi_other', status: 'succeeded' },
+    });
+    const { result } = renderHook(
+      () => useStripeCheckout({ mode: 'express' }),
+      { wrapper: Wrapper }
+    );
+    await act(async () => {
+      await expect(
+        result.current.handleSubmit(expressData)
+      ).rejects.toBeInstanceOf(GraphQLErrorWithCodes);
+    });
+    expect(mocks.confirmExpress).toHaveBeenCalledTimes(1);
+    await act(async () => {
+      await result.current.handleSubmit(expressData);
+    });
+    expect(mocks.confirmExpress).toHaveBeenLastCalledWith(
+      expect.objectContaining({ paymentToken: 'pi-confirmed' })
+    );
+    expect(mocks.createPaymentMethod).toHaveBeenCalledTimes(1);
+  });
+
+  it('discards the pending express intent when the checkout session changes', async () => {
+    mocks.confirmExpress
+      .mockRejectedValueOnce(actionRequiredError())
+      .mockRejectedValueOnce(new Error('Connection lost'));
+    const { result, rerender } = renderHook(
+      () => useStripeCheckout({ mode: 'express' }),
+      { wrapper: Wrapper }
+    );
+    await act(async () => {
+      await expect(result.current.handleSubmit(expressData)).rejects.toThrow(
+        'Connection lost'
+      );
+    });
+    mocks.sessionId = 'session-2';
+    rerender();
+    await act(async () => {
+      await result.current.handleSubmit(expressData);
+    });
+    expect(mocks.createPaymentMethod).toHaveBeenCalledTimes(2);
+    expect(mocks.confirmExpress).toHaveBeenLastCalledWith(
+      expect.objectContaining({ paymentToken: 'pm_wallet' })
+    );
+  });
 });
diff --git a/packages/react/src/components/checkout/payment/utils/use-stripe-checkout.ts b/packages/react/src/components/checkout/payment/utils/use-stripe-checkout.ts
index c9708a1e..bd044272 100644
--- a/packages/react/src/components/checkout/payment/utils/use-stripe-checkout.ts
+++ b/packages/react/src/components/checkout/payment/utils/use-stripe-checkout.ts
@@ -3,16 +3,22 @@ import type {
   PaymentMethodCreateParams,
   StripeExpressCheckoutElementConfirmEvent,
 } from '@stripe/stripe-js';
-import { useCallback, useState } from 'react';
+import { useCallback, useRef, useState } from 'react';
 import { useCheckoutContext } from '@/components/checkout/checkout';
 import { useBuildPaymentRequest } from '@/components/checkout/payment/utils/use-build-payment-request';
 import {
+  isCheckoutConfirmationBlockedError,
   PaymentProvider,
   useConfirmCheckout,
 } from '@/components/checkout/payment/utils/use-confirm-checkout';
 import { useConfirmExpressCheckout } from '@/components/checkout/payment/utils/use-confirm-express-checkout';
 import { useFlushCheckoutSync } from '@/components/checkout/payment/utils/use-flush-checkout-sync';
-import { GraphQLErrorWithCodes } from '@/lib/graphql-with-errors';
+import {
+  GraphQLErrorWithCodes,
+  getPaymentActionRequiredResult,
+} from '@/lib/graphql-with-errors';
+import { eventIds } from '@/tracking/events';
+import { TrackingEventType, track } from '@/tracking/track';
 import type {
   CalculatedAdjustments,
   CalculatedTaxes,
@@ -20,6 +26,23 @@ import type {
   ShippingMethod,
 } from '@/types';
 import { PaymentMethodType } from '@/types';
+import {
+  getStripeNextAction,
+  stripeCheckoutErrorCode,
+} from './stripe-next-action';
+import { usePendingStripeIntent } from './stripe-provider';
+
+function confirmationErrorCodes(error: unknown): string[] {
+  if (
+    error instanceof GraphQLErrorWithCodes &&
+    error.codes.length &&
+    !getPaymentActionRequiredResult(error) &&
+    !error.codes.includes('PAYMENT_ACTION_REQUIRED')
+  ) {
+    return error.codes;
+  }
+  return ['TRANSACTION_PROCESSING_FAILED'];
+}
 
 type UseStripeCheckoutOptions = {
   mode: 'card' | 'express';
@@ -69,63 +92,180 @@ export function useStripeCheckout({ mode }: UseStripeCheckoutOptions) {
   const elements = useElements();
   const confirmCheckout = useConfirmCheckout();
   const confirmExpressCheckout = useConfirmExpressCheckout();
-  const { setCheckoutErrors } = useCheckoutContext();
+  const { session, setCheckoutErrors, setIsConfirmingCheckout } =
+    useCheckoutContext();
   const { stripePaymentMethodParams, buildPaymentRequestsFromOrder } =
     useBuildPaymentRequest();
   const flushCheckoutSync = useFlushCheckoutSync();
   const [isProcessingPayment, setIsProcessingPayment] = useState(false);
+  const isSubmittingRef = useRef(false);
+  const pendingIntent = usePendingStripeIntent();
 
   const handleSubmit = useCallback(
     async (
       expressData?: StripeExpressCheckoutData,
       resolvedOrder?: DraftOrder | null
     ) => {
+      if (isSubmittingRef.current) return;
+      isSubmittingRef.current = true;
       setIsProcessingPayment(true);
       try {
         if (!stripe || !elements) {
           return;
         }
 
-        if (mode === 'card') {
-          const cardElement = elements.getElement(CardElement);
+        if (pendingIntent.current?.sessionId !== session?.id) {
+          pendingIntent.current = null;
+        }
+
+        // Both card and express payments resume the same intent after authentication.
+        const confirmWithNextAction = async (
+          paymentToken: string,
+          paymentType: string,
+          confirm: (token: string) => Promise<unknown>
+        ) => {
+          const confirmPayment = async (token: string) => {
+            try {
+              await confirm(token);
+            } catch (error) {
+              // A generic confirmation failure may hide a completed payment.
+              // Only an explicit, unambiguous unpaid result permits replacement.
+              if (
+                error instanceof GraphQLErrorWithCodes &&
+                error.errors.length > 0 &&
+                error.errors.every(
+                  detail =>
+                    detail.code === 'TRANSACTION_PROCESSING_FAILED' &&
+                    detail.extensions?.transactionStatus === 'FAILED'
+                )
+              ) {
+                pendingIntent.current = null;
+              }
+              throw error;
+            }
+          };
+          try {
+            await confirmPayment(paymentToken);
+            pendingIntent.current = null;
+          } catch (error) {
+            if (isCheckoutConfirmationBlockedError(error)) throw error;
+            const nextAction = getStripeNextAction(error);
+            if (!nextAction) throw error;
+
+            // Keep the reference even if the SDK loses its response after payment completes.
+            pendingIntent.current = {
+              sessionId: session?.id,
+              id: nextAction.paymentReference,
+              paymentType,
+            };
+            track({
+              eventId: eventIds.paymentChallengeStarted,
+              type: TrackingEventType.EVENT,
+              properties: { provider: 'STRIPE' },
+            });
+            let challengeSucceeded = false;
+            try {
+              const actionResult = await stripe.handleNextAction({
+                clientSecret: nextAction.clientSecret,
+              });
+              if (
+                actionResult.error ||
+                actionResult.paymentIntent?.id !==
+                  nextAction.paymentReference ||
+                ![
+                  'succeeded',
+                  'processing',
+                  'requires_capture',
+                  'requires_confirmation',
+                ].includes(actionResult.paymentIntent.status)
+              ) {
+                const intent =
+                  actionResult.paymentIntent ??
+                  actionResult.error?.payment_intent;
+                // Only a definite unpaid outcome permits a replacement payment.
+                if (
+                  intent?.id === nextAction.paymentReference &&
+                  ['requires_payment_method', 'canceled'].includes(
+                    intent.status
+                  )
+                ) {
+                  pendingIntent.current = null;
+                }
+                throw new GraphQLErrorWithCodes([
+                  {
+                    code: actionResult.error
+                      ? stripeCheckoutErrorCode(actionResult.error.code)
+                      : 'AUTHORIZATION_FAILED',
+                  },
+                ]);
+              }
 
-          if (!cardElement) {
-            return;
+              challengeSucceeded = true;
+              await confirmPayment(actionResult.paymentIntent.id);
+              pendingIntent.current = null;
+            } finally {
+              track({
+                eventId: eventIds.paymentChallengeCompleted,
+                type: TrackingEventType.EVENT,
+                properties: { provider: 'STRIPE', success: challengeSucceeded },
+              });
+            }
           }
+        };
 
-          const latestOrder =
-            resolvedOrder ??
-            (
-              await flushCheckoutSync({
-                includeCurrentFormDiff: true,
-              })
-            ).latestOrder;
-          const { paymentMethod, error } = await stripe.createPaymentMethod({
-            ...(latestOrder
-              ? buildPaymentRequestsFromOrder(latestOrder)
-                  .stripePaymentMethodParams
-              : stripePaymentMethodParams),
-            card: cardElement,
-            type: 'card',
-          });
+        if (mode === 'card') {
+          let paymentToken = pendingIntent.current?.id;
+          if (!paymentToken) {
+            const cardElement = elements.getElement(CardElement);
+
+            if (!cardElement) {
+              return;
+            }
+
+            const latestOrder =
+              resolvedOrder ??
+              (
+                await flushCheckoutSync({
+                  includeCurrentFormDiff: true,
+                })
+              ).latestOrder;
+            const { paymentMethod, error } = await stripe.createPaymentMethod({
+              ...(latestOrder
+                ? buildPaymentRequestsFromOrder(latestOrder)
+                    .stripePaymentMethodParams
+                : stripePaymentMethodParams),
+              card: cardElement,
+              type: 'card',
+            });
 
-          if (error) {
-            setCheckoutErrors([error.code || 'TRANSACTION_PROCESSING_FAILED']);
-            return;
+            if (error) {
+              setCheckoutErrors([stripeCheckoutErrorCode(error.code)]);
+              return;
+            }
+            paymentToken = paymentMethod?.id;
           }
 
-          if (paymentMethod) {
+          if (paymentToken) {
+            const confirmInput = {
+              paymentToken,
+              paymentType: PaymentMethodType.CREDIT_CARD,
+              paymentProvider: PaymentProvider.STRIPE,
+            };
+
             try {
-              await confirmCheckout.mutateAsync({
-                paymentToken: paymentMethod.id,
-                paymentType: PaymentMethodType.CREDIT_CARD,
-                paymentProvider: PaymentProvider.STRIPE,
-              });
-            } catch (err: unknown) {
-              if (err instanceof GraphQLErrorWithCodes) {
-                setCheckoutErrors(err.codes);
-              }
-              // Other errors are silently ignored
+              await confirmWithNextAction(
+                paymentToken,
+                confirmInput.paymentType,
+                token =>
+                  confirmCheckout.mutateAsync({
+                    ...confirmInput,
+                    paymentToken: token,
+                  })
+              );
+            } catch (error) {
+              if (isCheckoutConfirmationBlockedError(error)) return;
+              setCheckoutErrors(confirmationErrorCodes(error));
+              setIsConfirmingCheckout(false);
             }
           } else {
             setCheckoutErrors(['TRANSACTION_PROCESSING_FAILED']);
@@ -133,28 +273,30 @@ export function useStripeCheckout({ mode }: UseStripeCheckoutOptions) {
         }
 
         if (mode === 'express') {
-          const { error, paymentMethod } = await stripe.createPaymentMethod({
-            elements,
-            params: buildStripeExpressPaymentMethodParams(
-              expressData?.event.billingDetails
-            ),
-          });
-
-          if (error) {
-            setCheckoutErrors([error.code || 'TRANSACTION_PROCESSING_FAILED']);
-            return;
+          let paymentToken = pendingIntent.current?.id;
+          let paymentType = pendingIntent.current?.paymentType;
+          if (!paymentToken) {
+            const { error, paymentMethod } = await stripe.createPaymentMethod({
+              elements,
+              params: buildStripeExpressPaymentMethodParams(
+                expressData?.event.billingDetails
+              ),
+            });
+            if (error || !paymentMethod) {
+              const code = stripeCheckoutErrorCode(error?.code);
+              setCheckoutErrors([code]);
+              throw new GraphQLErrorWithCodes([{ code }]);
+            }
+            paymentToken = paymentMethod.id;
+            paymentType = paymentMethod.card?.wallet?.type;
           }
 
-          if (paymentMethod) {
+          if (paymentToken) {
             try {
-              // Build the checkout body similar to godaddy.tsx
               const event = expressData?.event;
               const currencyCode =
                 expressData?.shippingTotal?.currencyCode || 'USD';
-
-              const walletType = paymentMethod.card?.wallet?.type;
-              const paymentType =
-                walletType || event?.expressPaymentType || 'card';
+              paymentType = paymentType || event?.expressPaymentType || 'card';
 
               // Map Stripe billing details to checkout format
               const billing = event?.billingDetails
@@ -231,8 +373,8 @@ export function useStripeCheckout({ mode }: UseStripeCheckoutOptions) {
                   ]
                 : undefined;
 
-              await confirmExpressCheckout.mutateAsync({
-                paymentToken: paymentMethod.id,
+              const confirmInput = {
+                paymentToken,
                 paymentType,
                 paymentProvider: PaymentProvider.STRIPE,
                 isExpress: true,
@@ -254,11 +396,27 @@ export function useStripeCheckout({ mode }: UseStripeCheckoutOptions) {
                 ...(shipping ? { shipping } : {}),
                 // Include shipping lines if available
                 ...(shippingLines ? { shippingLines } : {}),
-              });
-            } catch (err: unknown) {
-              if (err instanceof GraphQLErrorWithCodes) {
-                setCheckoutErrors(err.codes);
+              };
+              await confirmWithNextAction(paymentToken, paymentType, token =>
+                confirmExpressCheckout.mutateAsync({
+                  ...confirmInput,
+                  paymentToken: token,
+                })
+              );
+              if (event) {
+                track({
+                  eventId: eventIds.expressCheckoutCompleted,
+                  type: TrackingEventType.EVENT,
+                  properties: {
+                    paymentType: event.expressPaymentType,
+                    provider: 'stripe',
+                  },
+                });
               }
+            } catch (err: unknown) {
+              if (isCheckoutConfirmationBlockedError(err)) throw err;
+              setCheckoutErrors(confirmationErrorCodes(err));
+              setIsConfirmingCheckout(false);
               throw err; // Re-throw so caller can handle
             }
           } else {
@@ -268,11 +426,14 @@ export function useStripeCheckout({ mode }: UseStripeCheckoutOptions) {
 
         return { success: false, error: `Mode not supported: ${mode}` };
       } finally {
+        isSubmittingRef.current = false;
         setIsProcessingPayment(false);
       }
     },
     [
       mode,
+      pendingIntent,
+      session?.id,
       stripe,
       elements,
       confirmCheckout.mutateAsync,
@@ -280,6 +441,7 @@ export function useStripeCheckout({ mode }: UseStripeCheckoutOptions) {
       buildPaymentRequestsFromOrder,
       confirmExpressCheckout.mutateAsync,
       setCheckoutErrors,
+      setIsConfirmingCheckout,
       stripePaymentMethodParams,
     ]
   );
diff --git a/packages/react/src/components/checkout/utils/query-keys.ts b/packages/react/src/components/checkout/utils/query-keys.ts
index cf2c8d2d..07d854fd 100644
--- a/packages/react/src/components/checkout/utils/query-keys.ts
+++ b/packages/react/src/components/checkout/utils/query-keys.ts
@@ -32,4 +32,6 @@ export const checkoutQueryKeys = {
     ['draft-order-products', { sessionId }] as const,
   draftOrderShippingMethods: (sessionId?: string | null) =>
     ['draft-order-shipping-methods', { sessionId }] as const,
+  orderStatus: (sessionId?: string | null) =>
+    ['checkout-order-status', { sessionId }] as const,
 };
diff --git a/packages/react/src/lib/godaddy/checkout-env.ts b/packages/react/src/lib/godaddy/checkout-env.ts
index 1c5bd8b4..3c4a24ed 100644
--- a/packages/react/src/lib/godaddy/checkout-env.ts
+++ b/packages/react/src/lib/godaddy/checkout-env.ts
@@ -2020,6 +2020,27 @@ const introspection = {
             "args": [],
             "isDeprecated": false
           },
+          {
+            "name": "orderId",
+            "type": {
+              "kind": "NON_NULL",
+              "ofType": {
+                "kind": "SCALAR",
+                "name": "String"
+              }
+            },
+            "args": [],
+            "isDeprecated": false
+          },
+          {
+            "name": "orderStatus",
+            "type": {
+              "kind": "OBJECT",
+              "name": "DraftOrderStatuses"
+            },
+            "args": [],
+            "isDeprecated": false
+          },
           {
             "name": "paymentMethods",
             "type": {
@@ -9752,7 +9773,15 @@ const introspection = {
               "kind": "OBJECT",
               "name": "CheckoutSession"
             },
-            "args": [],
+            "args": [
+              {
+                "name": "id",
+                "type": {
+                  "kind": "SCALAR",
+                  "name": "ID"
+                }
+              }
+            ],
             "isDeprecated": false
           },
           {
diff --git a/packages/react/src/lib/godaddy/checkout-queries.ts b/packages/react/src/lib/godaddy/checkout-queries.ts
index 42e342f8..b4c49950 100644
--- a/packages/react/src/lib/godaddy/checkout-queries.ts
+++ b/packages/react/src/lib/godaddy/checkout-queries.ts
@@ -322,6 +322,20 @@ export const AddressMatchesQuery = graphql(`
     }
 `);
 
+// Unlike draftOrder, orderStatus stays available once checkout is finished
+// (paid or pending offline payment), so it is safe to poll after confirmation.
+export const CheckoutOrderStatusQuery = graphql(`
+  query CheckoutOrderStatus {
+    checkoutSession {
+      id
+      orderStatus {
+        status
+        paymentStatus
+      }
+    }
+  }
+`);
+
 export const DraftOrderQuery = graphql(`
   query DraftOrder {
       checkoutSession {
diff --git a/packages/react/src/lib/godaddy/godaddy.ts b/packages/react/src/lib/godaddy/godaddy.ts
index dc2dfc46..872fdabf 100644
--- a/packages/react/src/lib/godaddy/godaddy.ts
+++ b/packages/react/src/lib/godaddy/godaddy.ts
@@ -57,6 +57,7 @@ import {
 } from './checkout-mutations.ts';
 import {
   AddressMatchesQuery,
+  CheckoutOrderStatusQuery,
   DraftOrderPriceAdjustmentsQuery,
   DraftOrderQuery,
   DraftOrderShippingRatesQuery,
@@ -314,6 +315,47 @@ export function getDraftOrder(
   );
 }
 
+export function getCheckoutOrderStatus(
+  sessionOrAuth:
+    | CheckoutSession
+    | undefined
+    | null
+    | { accessToken: string | undefined },
+  apiHost?: string
+): Promise<ResultOf<typeof CheckoutOrderStatusQuery>> {
+  const GODADDY_HOST = getHostByEnvironment(apiHost);
+
+  if (sessionOrAuth && 'accessToken' in sessionOrAuth) {
+    if (!sessionOrAuth.accessToken) {
+      throw new Error('No access token provided');
+    }
+    return graphqlRequestWithErrors<ResultOf<typeof CheckoutOrderStatusQuery>>(
+      GODADDY_HOST,
+      CheckoutOrderStatusQuery,
+      undefined,
+      {
+        Authorization: `Bearer ${sessionOrAuth.accessToken}`,
+      }
+    );
+  }
+
+  const session = sessionOrAuth;
+  if (!session?.token || !session?.id) {
+    throw new Error('No session token or ID provided');
+  }
+
+  return graphqlRequestWithErrors<ResultOf<typeof CheckoutOrderStatusQuery>>(
+    GODADDY_HOST,
+    CheckoutOrderStatusQuery,
+    undefined,
+    {
+      'x-session-token': `${session.token}`,
+      'x-session-id': session.id,
+      'x-store-id': session.storeId,
+    }
+  );
+}
+
 export function getDraftOrderTaxes(
   session: CheckoutSession | undefined,
   params: {
diff --git a/packages/react/src/lib/graphql-with-errors.test.ts b/packages/react/src/lib/graphql-with-errors.test.ts
new file mode 100644
index 00000000..8217002e
--- /dev/null
+++ b/packages/react/src/lib/graphql-with-errors.test.ts
@@ -0,0 +1,131 @@
+import { GraphQLError } from 'graphql';
+import { ClientError } from 'graphql-request';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import {
+  GraphQLErrorWithCodes,
+  getPaymentActionRequiredResult,
+  graphqlRequestWithErrors,
+} from './graphql-with-errors';
+
+const requestMock = vi.hoisted(() => vi.fn());
+
+vi.mock('graphql-request', async importOriginal => {
+  const actual = await importOriginal<typeof import('graphql-request')>();
+  return { ...actual, request: requestMock };
+});
+
+describe('graphqlRequestWithErrors', () => {
+  beforeEach(() => {
+    requestMock.mockReset();
+  });
+
+  it.each(['FAILED', 'PENDING', undefined])(
+    'preserves optional transaction status %s without changing the error code',
+    async transactionStatus => {
+      const extensions = {
+        code: 'TRANSACTION_PROCESSING_FAILED',
+        ...(transactionStatus ? { transactionStatus } : {}),
+      };
+      requestMock.mockRejectedValue(
+        new ClientError(
+          {
+            status: 200,
+            errors: [
+              new GraphQLError('Failed to process transaction', { extensions }),
+            ],
+          },
+          {
+            query: 'mutation ConfirmCheckout { confirmCheckoutSession { id } }',
+          }
+        )
+      );
+
+      await expect(
+        graphqlRequestWithErrors('https://example.test/graphql', 'query')
+      ).rejects.toMatchObject({
+        codes: ['TRANSACTION_PROCESSING_FAILED'],
+        errors: [{ code: 'TRANSACTION_PROCESSING_FAILED', extensions }],
+      });
+    }
+  );
+
+  it('preserves payment action-required extensions', async () => {
+    requestMock.mockRejectedValue(
+      new ClientError(
+        {
+          status: 200,
+          errors: [
+            new GraphQLError('Payment requires additional customer action', {
+              extensions: {
+                code: 'PAYMENT_ACTION_REQUIRED',
+                paymentResult: {
+                  status: 'ACTION_REQUIRED',
+                  provider: 'STRIPE',
+                  nextStep: {
+                    type: 'SDK_ACTION',
+                    sdk: 'STRIPE_JS',
+                    action: 'HANDLE_NEXT_ACTION',
+                    clientSecret: 'pi-secret',
+                  },
+                },
+              },
+            }),
+          ],
+        },
+        {
+          query:
+            'mutation ConfirmCheckout { confirmCheckoutSession { status } }',
+        }
+      )
+    );
+
+    let thrown: unknown;
+    try {
+      await graphqlRequestWithErrors('https://example.test/graphql', 'query');
+    } catch (error) {
+      thrown = error;
+    }
+
+    expect(thrown).toBeInstanceOf(GraphQLErrorWithCodes);
+    expect(getPaymentActionRequiredResult(thrown)).toEqual({
+      status: 'ACTION_REQUIRED',
+      provider: 'STRIPE',
+      nextStep: {
+        type: 'SDK_ACTION',
+        sdk: 'STRIPE_JS',
+        action: 'HANDLE_NEXT_ACTION',
+        clientSecret: 'pi-secret',
+      },
+    });
+  });
+  it('preserves tip input paths alongside error extensions', async () => {
+    requestMock.mockRejectedValue(
+      new ClientError(
+        {
+          status: 200,
+          errors: [
+            new GraphQLError('Invalid tip', {
+              path: ['confirmCheckoutSession'],
+              extensions: { code: 'INVALID_TIP_AMOUNT', path: ['tipAmount'] },
+            }),
+          ],
+        },
+        {
+          query:
+            'mutation ConfirmCheckout { confirmCheckoutSession { status } }',
+        }
+      )
+    );
+    await expect(
+      graphqlRequestWithErrors('https://example.test/graphql', 'query')
+    ).rejects.toMatchObject({
+      errors: [
+        {
+          code: 'INVALID_TIP_AMOUNT',
+          path: ['tipAmount'],
+          extensions: { path: ['tipAmount'] },
+        },
+      ],
+    });
+  });
+});
diff --git a/packages/react/src/lib/graphql-with-errors.ts b/packages/react/src/lib/graphql-with-errors.ts
index 78a078b1..ed425f97 100644
--- a/packages/react/src/lib/graphql-with-errors.ts
+++ b/packages/react/src/lib/graphql-with-errors.ts
@@ -5,13 +5,15 @@ import {
   type Variables,
 } from 'graphql-request';
 
-// Define the shape of GraphQL errors explicitly
+export type GraphQLErrorDetails = {
+  message?: string;
+  code?: string;
+  path?: string[];
+  extensions?: Record<string, unknown>;
+};
+
 export class GraphQLErrorWithCodes<
-  T extends { message?: string; code?: string; path?: string[] } = {
-    message?: string;
-    code?: string;
-    path?: string[];
-  },
+  T extends GraphQLErrorDetails = GraphQLErrorDetails,
 > extends Error {
   constructor(public errors: T[]) {
     const errorMessage =
@@ -35,6 +37,44 @@ export class GraphQLErrorWithCodes<
   }
 }
 
+export type PaymentActionRequiredResult = {
+  status: 'ACTION_REQUIRED';
+  provider?: string;
+  reason?: string;
+  transactionId?: string;
+  paymentReference?: string;
+  nextStep: Record<string, unknown> & { type: string };
+};
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+export function getPaymentActionRequiredResult(
+  error: unknown
+): PaymentActionRequiredResult | undefined {
+  if (!(error instanceof GraphQLErrorWithCodes)) return undefined;
+
+  for (const graphqlError of error.errors) {
+    if (graphqlError.code !== 'PAYMENT_ACTION_REQUIRED') continue;
+
+    const paymentResult = graphqlError.extensions?.paymentResult;
+    if (
+      !isRecord(paymentResult) ||
+      paymentResult.status !== 'ACTION_REQUIRED'
+    ) {
+      continue;
+    }
+
+    const nextStep = paymentResult.nextStep;
+    if (!isRecord(nextStep) || typeof nextStep.type !== 'string') continue;
+
+    return paymentResult as PaymentActionRequiredResult;
+  }
+
+  return undefined;
+}
+
 export async function graphqlRequestWithErrors<T = any>(
   endpoint: string,
   query: RequestDocument,
@@ -48,6 +88,7 @@ export async function graphqlRequestWithErrors<T = any>(
       const parsedErrors = err.response.errors.map(e => ({
         message: e.message as string,
         code: e.extensions?.code as string,
+        extensions: e.extensions as Record<string, unknown> | undefined,
         // The input path the API blamed, e.g. `['tipAmount']`. Read from
         // `extensions` rather than the GraphQL `path`, which points at the
         // response field. Lets a caller attach the error to that form field
diff --git a/packages/react/src/tests/setup.ts b/packages/react/src/tests/setup.ts
index 835bc678..23a5e979 100644
--- a/packages/react/src/tests/setup.ts
+++ b/packages/react/src/tests/setup.ts
@@ -7,6 +7,7 @@ vi.mock('@/lib/godaddy/godaddy', () => ({
   getCheckoutSession: vi.fn(),
   getAddressMatches: vi.fn(),
   getDraftOrder: vi.fn(),
+  getCheckoutOrderStatus: vi.fn(),
   getDraftOrderTaxes: vi.fn(),
   verifyAddress: vi.fn(),
   updateDraftOrder: vi.fn(),
diff --git a/packages/react/src/tracking/events.ts b/packages/react/src/tracking/events.ts
index 8c6f3f31..85c1e23d 100644
--- a/packages/react/src/tracking/events.ts
+++ b/packages/react/src/tracking/events.ts
@@ -18,6 +18,7 @@ export const eventIds = {
 
   // Express checkout events
   expressCheckoutImpression: 'express_checkout.impression',
+  expressCheckoutCompleted: 'express_checkout_completed.event',
   expressApplePayImpression: 'express_apple_pay.impression',
   expressGooglePayImpression: 'express_google_pay.impression',
   expressApplePayClick: 'express_apple_pay.click',
@@ -48,6 +49,8 @@ export const eventIds = {
   selectPaymentMethod: 'select_payment_method.click',
   toggleSameAsBillingAddress: 'toggle_same_as_billing_address.click',
   paymentStart: 'payment_start.event',
+  paymentChallengeStarted: 'payment_challenge_started.event',
+  paymentChallengeCompleted: 'payment_challenge_completed.event',
 
   // Shipping events
   selectShippingMethod: 'select_shipping_method.click',