> ## Documentation Index
> Fetch the complete documentation index at: https://docs.didit.me/llms.txt
> Use this file to discover all available pages before exploring further.

# When the person cannot verify their bank

> Bank Verification is never a dead end: the other ways to verify per country, Continue without your bank, the outcome you choose, and how the result reports it.

Bank Verification never leaves a person stuck. While the step waits for them, they can always pick **Continue without your bank**, and the step shows it as soon as no method works for their country or their bank. The session then follows the outcome you chose for that case, a review by default. When a failed attempt uses up the last attempt of every way they are still offered, a statement upload included, the step does not wait: it ends on its own and follows `bank_attempts_exhausted_action`, a decline by default, unless an earlier attempt already reached a verdict, such as a name mismatch. That verdict then stands.

This page covers the other ways to verify each country offers, when the person sees **Continue without your bank**, how each case is decided, and how to read it in the result.

## The ways to verify

| Way to verify | `method` | Where it is offered |
| - | - | - |
| Bank sign-in | `open_banking` | Where a route serves the country. |
| Account check | `account_lookup` | Where a route serves the country. |
| Statement upload | `statement` | Any country, when the step turns it on (`bank_statement_enabled`). |
| Micro-deposits | `microdeposits` | Only where a route sends the deposits, after a charged bank sign-in or account check in the same session (`bank_microdeposits_enabled`). |
| Continue without your bank | `none` | Always. It cannot be turned off. |

The person starts on bank sign-in or the account check, in the order you set for their country: see [Choose the methods per country](https://docs.didit.me/core-technology/bank-verification/verification-methods.md#choose-the-methods-per-country). The statement upload and micro-deposits are fallbacks after those two. **Continue without your bank** comes last.

A way a country cannot use is never offered to the person there. In the console, **Countries and methods** shows it as **Not available** for that country.

### A country no bank route serves

A country where neither bank sign-in nor the account check has a route stays in the step. Its people upload a statement, when the step offers one, or continue without a bank.

A save keeps such a country when it leaves out `methods` or sets it to `null`. Its `methods` cannot list a method, because no route serves one there: that is refused on save, for example `Account check is not available in VNM.` An empty list is refused too, as in every enabled country, with `Choose a method: bank sign-in, account check, or both.` If your contract sets its own prices and does not include the statement upload, a save that offers one with no bank attempt before it also refuses such a country.

```json theme={null}
{
  "bank_statement_enabled": true,
  "bank_countries": {
    "GBR": { "enabled": true, "institutions": "all" },
    "VNM": { "enabled": true, "institutions": "all" }
  }
}
```

Here Vietnam stands for a country no bank route serves. It sets no `methods`, so the save keeps it, and its people see the statement upload and **Continue without your bank**.

### The statement upload

The statement upload asks for a bank statement from the last 3 months that shows the person's name, their bank and the account number. Didit reads it, checks it for edits, and matches the holder name the same way it matches a bank's.

With `bank_statement_enabled` on, the step offers it in two cases:

* **After a charged attempt:** once a bank sign-in or an account check was charged in the same session, the statement upload is a fallback, included at no extra charge.
* **With no bank attempt before it:** in any country, including one no bank route serves. This needs `bank_statement_standalone_enabled`, which is on by default. Turn it off to offer the statement upload only after a charged attempt.

The statement upload and micro-deposits each spend one of the step's `bank_max_attempts`, the same attempts bank sign-in uses. Once the person has spent them all, neither is offered any more, even after a charged attempt. The account check has its own `bank_account_check_max_attempts`, so where it is the only method, a person who has used every account check can still upload a statement, when the step offers one. When a failed attempt uses up the last attempt of every way the person is still offered, a statement upload included, the step ends on its own: the person is not asked to continue, and the result records no continuation. The session follows `bank_attempts_exhausted_action`, unless an earlier attempt already reached a verdict, such as a name mismatch, which then stands. To leave room for a fallback after a failed bank sign-in, set `bank_max_attempts` to `2` or more.

## When the person sees Continue without your bank

`bank_continue_without_bank` sets when the step shows **Continue without your bank**:

| Value | The step shows it |
| - | - |
| `when_needed` (the default) | Once no method works for the person's country or bank, when their bank cannot be reached right now and no other method could verify them, or when they say they have no online banking or their bank is not listed. |
| `from_start` | On the first screen too. |

Neither value turns the option off: the person can always continue. In the console, set it in the Bank Verification step under **When the person cannot verify**, as **Show Continue without a bank**: **When nothing else works** or **From the start**.

```json theme={null}
{
  "bank_continue_without_bank": "when_needed"
}
```

### What the person sees

* **No route in their country:** for example "We can't connect to banks in Vietnam yet", with the statement upload under **Other ways to verify**, and **Continue without your bank**.
* **A bank that cannot be used here:** "This bank cannot be used here". The person can enter their account details where the country offers the account check, upload a statement, choose a different bank, or continue without their bank.
* **No online banking, or a bank that is not listed:** "Verify your account another way", with the ways their country offers, and **Continue without your bank**.
* **A bank that cannot be reached right now:** the person can try again. The screen also offers **Continue without your bank** once the other method, bank sign-in or the account check, cannot help: their country does not offer it, it has no attempts left, or its last attempt could not reach the bank either.
* **After continuing:** "Thanks, you can continue". The person is never shown a failure, and moves on to the next step of your workflow.

## Choose the outcome

When the person continues without a bank, Didit works out why from what happened in the step. It never takes a reason from the person's device. Each reason, recorded as `continuation.reason`, follows its own outcome setting:

* `no_route`: no bank sign-in or account check route serves their country. Decided by `bank_unsupported_action`, `REVIEW` by default, with reason code `NOT_COVERED`.
* `institution_unsupported`: the bank they picked cannot be used on this step. Decided by `bank_unsupported_action`, `REVIEW` by default, with reason code `NOT_COVERED`.
* `attempts_exhausted`: every attempt was already spent, and none was still in progress, when they continued. Decided by `bank_attempts_exhausted_action`, `DECLINE` by default.
* `person_choice`: a way to verify was there, and they chose to continue. This includes a bank that could not be reached right now: the bank is covered, so the person's own choice is the reason. Decided by `bank_skipped_action`, `REVIEW` by default, with reason code `SKIPPED`.

`bank_skipped_action` and `bank_attempts_exhausted_action` take `REVIEW` or `DECLINE`. `bank_unsupported_action` also takes `NO_ACTION`, which approves the step and still records `NOT_COVERED`.

In the console, these are the **Bank or country not covered**, **Continued without a bank** and **Attempts exhausted** rows of the step's **Outcomes** tab.

```json theme={null}
{
  "bank_continue_without_bank": "when_needed",
  "bank_unsupported_action": "REVIEW",
  "bank_skipped_action": "REVIEW",
  "bank_attempts_exhausted_action": "DECLINE"
}
```

> [!NOTE]
>
> Continuing never replaces a verdict an attempt already reached. If an attempt was already evaluated, for example the bank or a statement returned a holder that does not match and the person had attempts left, or a close match they did not confirm, the step keeps that verdict and its reason codes. No outcome setting from the list above applies then, and no `NOT_COVERED` or `SKIPPED` is added. The result still records that the person continued: see [Read it in the result](#read-it-in-the-result).

## Read it in the result

### Decision and webhooks

The step's item in `bank_verifications[]`, in the [session decision](https://docs.didit.me/sessions-api/retrieve-session.md#bank-verification) and in the `decision` object of [`status.updated` webhooks](https://docs.didit.me/integration/webhooks#v3-plural-arrays-important), says the person continued without a bank:

* `continued_without_bank` is `true`: the person left the step with **Continue without your bank**.
* `method` is `none` when no attempt was evaluated before the person continued. After an evaluated attempt, such as a holder that does not match, `method` stays the method of that attempt, and its verdict stands.
* `continuation` says how the person continued:
  * `reason`: `no_route`, `institution_unsupported`, `attempts_exhausted` or `person_choice`.
  * `country`: the country the person was verifying in, ISO 3166-1 alpha-3, or `null` when they continued before picking one.
  * `offered`: the other ways to verify that country offered, in the order it offered them: `statement`, then `microdeposits`. Empty when it offered none.
  * `institution_id` and `institution_name`: for `institution_unsupported`, the bank the person could not use: the bank they picked, or the bank their last attempt ended on. Didit takes both from its own list of banks, never from the person's device, so a bank that list does not have leaves both `null`. Both are `null` for every other reason.
  * `continued_at`: when the person continued.
* `reason_codes` holds `NOT_COVERED` or `SKIPPED`, as in [Choose the outcome](#choose-the-outcome), when the continuation decided the step. After an evaluated attempt, it keeps that attempt's reason codes.
* `not_covered` is `true` for `no_route` and `institution_unsupported`.

```json theme={null}
{
  "bank_verifications": [
    {
      "node_id": "feature_bank_verification",
      "status": "In Review",
      "method": "none",
      "continued_without_bank": true,
      "continuation": {
        "reason": "institution_unsupported",
        "country": "ESP",
        "offered": ["statement"],
        "institution_id": "example_bank_es",
        "institution_name": "Example Bank",
        "continued_at": "2026-11-03T08:15:41.512870+00:00"
      },
      "not_covered": true,
      "ownership": null,
      "reason_codes": ["NOT_COVERED"]
    }
  ]
}
```

The example shows only the fields this page discusses. Every field is in the `BankVerificationResult` schema of the [API reference](https://docs.didit.me/sessions-api/retrieve-session.md).

When your workflow narrows the data it returns, `continued_without_bank` and `continuation.reason` are still returned, so you can still tell `no_route` from `institution_unsupported`, which share `NOT_COVERED`. Every other key of `continuation` is then `null`: the country, the bank, what was offered and when. `continuation` itself is `null` when the person did not continue. `method` is not returned then either, so read `continued_without_bank`, not `method`, to know that the person continued.

### Workflow rules

Branches and custom status rules can read:

* `bank.continued_without_bank`: `true` or `false`.
* `bank.continue_reason`: `no_route`, `institution_unsupported`, `attempts_exhausted` or `person_choice`.
* `bank.method`: `none` when the person continued without a bank before any attempt was evaluated. After an evaluated attempt, the method of that attempt.

### Session report

When the person continued without a bank before any attempt was evaluated, the session PDF report's **Verification method** row reads **Continued without a bank**. After an evaluated attempt, it names the method of that attempt.

## Pricing

* **Continue without your bank** is never billed. Attempts the person made before continuing are billed as usual.
* **A statement upload with no charged bank attempt before it** is \$0.20 per statement Didit reads and evaluates. It is billed on its own usage line, **Bank verification - statement upload** (`bank_statement_upload`), and your contract rate or special price applies to it as to any add-on. If your contract sets its own prices and does not include it, the step does not offer it.
* **A statement upload or micro-deposits after a charged bank sign-in or account check** in the same session are included at no extra charge.

## Nodes saved before Continue without your bank

`bank_allow_skip` is retired. A node saved with it now runs with the value it meant:

| `bank_allow_skip` | The node runs with |
| - | - |
| `true` | `bank_continue_without_bank: "from_start"` |
| `false` or unset | `bank_continue_without_bank: "when_needed"` |

A node that did not allow skipping used to leave a person with no way forward when nothing worked for them. It now shows **Continue without your bank** in those cases, and `bank_unsupported_action`, `bank_attempts_exhausted_action` or `bank_skipped_action` decides the session.

For one release, a save that sends `bank_allow_skip` but no `bank_continue_without_bank` still sets the mode from it. Every save writes `bank_allow_skip` back: `true` for `from_start`, `false` for `when_needed`. Use `bank_continue_without_bank` in new integrations.

## Test in sandbox

A sandbox application bills nothing, and the statement upload and micro-deposits need no bank attempt before them. Set `bank_continue_without_bank` to `from_start` to see **Continue without your bank** on the first screen, and pick it to test `bank_skipped_action`. See [Sandbox testing](https://docs.didit.me/integration/sandbox-testing.md) for how sandbox applications work in general.

## Related

* [Bank verification methods](https://docs.didit.me/core-technology/bank-verification/verification-methods.md): bank sign-in and the account check, per country.
* [Account check](https://docs.didit.me/core-technology/bank-verification/account-check.md): account formats, results and sandbox values.
* [Bank Verification config keys](https://docs.didit.me/management-api/workflows/feature-configs.md#bank-verification): every key of the step.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.