# Manual/User triggered Retries

### Overview

The Manual or User triggered Retries feature in Hyperswitch allows customers to retry a failed payment attempt under the same Payment Intent, without needing to restart the entire checkout flow.

This capability helps merchants recover from transient payment failures — such as card declines or temporary PSP issues — and significantly improves authorization success rates and customer experience.

Once enabled, Hyperswitch automatically determines if a failed payment is eligible for retry through a new response field: `manual_retry_allowed`.

### Configuring Manual Retries

1. Log in to your Hyperswitch Dashboard.
2. Navigate to Developers → Payment Settings → Manual Retries.
3. Toggle the setting ON to enable Manual Retries for your profile.

Once enabled, the `manual_retry_allowed` field will be included in payment responses whenever a payment attempt fails.

### Integration Behavior

#### Case 1: Frictionless Flows (No Redirection)

For payments without redirection (e.g., standard card transactions, wallet flows):

* The Hyperswitch SDK automatically handles retries when `manual_retry_allowed` is true.
* Merchants need not make any code changes.
* The SDK automatically invokes the retry flow under the same payment\_id.
* Customers can update their card or payment details directly in the checkout UI and reattempt payment — all within the same session.

**Example Flow:**

1. Customer enters card details → clicks Pay Now.
2. SDK triggers /payments/confirm internally.
3. Payment fails.
4. SDK detects `manual_retry_allowed : true` and displays retry UI.
5. Customer re-enters updated payment details → retry succeeds.

#### Case 2: Redirect Flows (e.g., 3DS / SCA)

For payment flows that involve redirection (like 3-D Secure authentication):

* After the customer completes redirection and returns to your site, your frontend regains control.
* If the payment fails and `manual_retry_allowed : true`, you should remount the Hyperswitch SDK using the same client\_secret corresponding to that Payment Intent.
* This allows the customer to retry within the same checkout context.

#### SDK Integration sample logic:

```javascript
// Manual Retry: determine whether to reuse the existing client secret
if (manualRetryAllowed && existingClientSecret) {
  // Reuse the existing client secret for retry
  // No need to create a new payment intent
  paymentIntentData = { clientSecret: existingClientSecret };
} else {
  // Fallback: request a new payment intent from the backend
  paymentIntentData = await fetchNewPaymentIntent();
}

```

**Behavior**:

* The SDK is re-initialized on the same Payment Intent.
* The customer can retry payment by entering updated details.
* The SDK then performs /payments/confirm again under the same payment\_id.\\

### API Workflow

#### 1️⃣ Create a Payment Intent

Create a Payment Intent before initiating checkout.

```json
{
  "amount": 1000,
  "currency": "EUR",
  "confirm": false,
  "capture_method": "automatic",
  "capture_on": "2022-09-10T10:11:12Z",
  "customer_id": "{{customer_id}}",
  "email": "guest@example.com",
  "name": "John Doe",
  "authentication_type": "three_ds",
  "return_url": "https://hyperswitch.io",
  "billing": {
    "address": {
      "city": "Vienna",
      "country": "AT",
      "line1": "123 Test Street",
      "zip": "560095"
    }
  },
  "setup_future_usage": "on_session"
}

```

#### 2️⃣ Confirm the Payment (Triggered by Checkout SDK)

When the customer enters card details and clicks Pay Now, the Hyperswitch SDK automatically makes a /payments/confirm call.

```json
{
  "payment_method": "card",
  "payment_method_data": {
    "card": {
      "card_number": "4242424242424242",
      "card_exp_month": "02",
      "card_exp_year": "2026",
      "card_holder_name": "John Doe",
      "card_cvc": "999"
    }
  },
  "connector": ["cybersource"],
  "client_secret": "{{client_secret}}"
}

```

If this payment fails, the response will include:

`manual_retry_allowed : true`

#### 3️⃣ Retry the Payment (If Allowed)

If `manual_retry_allowed : true` , you can retry on the same Payment Intent.\\

* For redirect flows, this can be done by remounting the SDK as described earlier.
* For SDK-managed (non-redirect) flows, Hyperswitch automatically handles this internally.

**Example Retry Request (for redirect flows):**

```json
{
  "payment_method": "card",
  "payment_method_data": {
    "card": {
      "card_number": "4000000000000002",
      "card_exp_month": "03",
      "card_exp_year": "2028",
      "card_holder_name": "Jane Doe",
      "card_cvc": "123"
    }
  },
  "connector": ["cybersource"],
  "client_secret": "{{client_secret}}"
}

```

### Response Field Reference

**Field:** `manual_retry_allowed`\
**Type:** Boolean / null

Specifies whether manual retry is supported for a failed payment.

| Value   | Description                                            |
| ------- | ------------------------------------------------------ |
| `true`  | Manual retry is allowed on the same Payment Intent.    |
| `false` | Manual retry is not allowed.                           |
| `null`  | Manual retry is not enabled for this merchant profile. |

### Customer Journey Example

**Frictionless Flow**

1. Customer fills card details → clicks Pay Now
2. /payments/confirm triggered by SDK
3. Payment fails → SDK detects manual\_retry\_allowed = true
4. Retry prompt shown → customer retries within same checkout
5. Payment succeeds

**Redirect Flow (e.g., 3DS)**

1. Customer completes 3DS authentication → redirected back to merchant
2. Payment fails → manual\_retry\_allowed = true in response
3. Merchant frontend remounts Hyperswitch SDK with the same client\_secret
4. Customer retries payment → payment succeeds


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.hyperswitch.io/~/revisions/iPtyU5MKxmgIsGywgRhI/explore-hyperswitch/workflows/smart-retries/manual-user-triggered-retries.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.