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

# European Payment Methods

> Accept iDEAL, Bancontact, EPS, Multibanco, BLIK, SEPA Direct Debit, and Satispay. Learn which currency, country, and billing type each method needs.

Accept iDEAL, Bancontact, EPS, Multibanco, BLIK, SEPA Direct Debit, and Satispay to reach European customers who prefer to pay from their bank or a local payment app instead of a card. In markets where a local method is the most common way to pay online, offering it can raise conversion.

## Why Local European Payment Methods?

<CardGroup cols={3}>
  <Card title="Higher Conversion" icon="chart-line">
    iDEAL is the most-used online payment method in the Netherlands. Without it, you lose Dutch customers who won't pay another way.
  </Card>

  <Card title="Bank Authentication" icon="shield-check">
    For bank-authenticated methods, the customer approves the payment in their banking app or on their bank's site.
  </Card>

  <Card title="Real-Time Settlement" icon="bolt">
    Most methods on this page confirm the payment during checkout. SEPA Direct Debit and Multibanco ATM payments confirm later.
  </Card>
</CardGroup>

## Supported Methods

Each method is offered only when the checkout matches its currency and billing type:

| Method | Country | Currency | Subscriptions |
| :- | :- | :- | :-: |
| **iDEAL** | Netherlands | EUR | No |
| **Bancontact** | Belgium | EUR | No |
| **EPS** | Austria | EUR | No |
| **Multibanco** | Portugal | EUR | No |
| **BLIK** | Poland | PLN | No |
| **SEPA Direct Debit** | Eurozone | EUR | No |
| **Satispay** | Europe (Italy) | EUR | Yes |

## iDEAL (Netherlands)

iDEAL is the most-used online payment method in the Netherlands. It connects directly to all major Dutch banks, and the customer approves each payment with their own bank.

### How It Works

The customer selects iDEAL, picks their bank, and authenticates there:

```mermaid theme={null}
sequenceDiagram
    participant Customer
    participant Checkout
    participant Dodo
    participant iDEAL
    participant Bank
    
    Customer->>Checkout: Select iDEAL
    Checkout->>Dodo: Create payment
    Dodo->>iDEAL: Initiate payment
    iDEAL->>Customer: Redirect to bank selection
    Customer->>Bank: Select bank & authenticate
    Bank->>iDEAL: Payment confirmed
    iDEAL->>Dodo: Success callback
    Dodo->>Checkout: Payment complete
```

### Supported Banks

iDEAL works with all major Dutch banks, including:

* ABN AMRO
* ASN Bank
* Bunq
* ING
* Knab
* Rabobank
* RegioBank
* Revolut
* SNS
* Triodos Bank
* Van Lanschot

### Configuration

To offer iDEAL, include `ideal` in `allowed_payment_method_types` and bill in EUR:

```javascript theme={null}
// `client` is an initialized DodoPayments client.
const session = await client.checkoutSessions.create({
  product_cart: [{ product_id: 'pdt_123', quantity: 1 }],
  allowed_payment_method_types: ['ideal', 'credit', 'debit'],
  billing_currency: 'EUR',
  billing_address: {
    country: 'NL',
    zipcode: '1012JS'
  },
  return_url: 'https://example.com/success'
});
```

## Bancontact (Belgium)

Bancontact is Belgium's national payment scheme. Almost all Belgian banks use it for online payments.

### Features

* Works with the Bancontact debit cards that Belgian customers already have
* Supports payment in the Bancontact mobile app
* Confirms the payment during checkout
* Requires no extra registration from the customer

### Configuration

To offer Bancontact, include `bancontact_card` and bill in EUR:

```javascript theme={null}
// `client` is an initialized DodoPayments client.
const session = await client.checkoutSessions.create({
  product_cart: [{ product_id: 'pdt_123', quantity: 1 }],
  allowed_payment_method_types: ['bancontact_card', 'credit', 'debit'],
  billing_currency: 'EUR',
  billing_address: {
    country: 'BE',
    zipcode: '1000'
  },
  return_url: 'https://example.com/success'
});
```

## EPS (Austria)

EPS (Electronic Payment Standard) lets Austrian customers pay by online bank transfer from their own bank.

### Features

* Connects directly to Austrian banks
* Confirms the payment during checkout
* Has high trust among Austrian consumers

### Supported Banks

EPS works with major Austrian banks, including:

* Erste Bank
* Bank Austria
* Raiffeisen
* BAWAG
* Volksbank

### Configuration

To offer EPS, include `eps` and bill in EUR:

```javascript theme={null}
// `client` is an initialized DodoPayments client.
const session = await client.checkoutSessions.create({
  product_cart: [{ product_id: 'pdt_123', quantity: 1 }],
  allowed_payment_method_types: ['eps', 'credit', 'debit'],
  billing_currency: 'EUR',
  billing_address: {
    country: 'AT',
    zipcode: '1010'
  },
  return_url: 'https://example.com/success'
});
```

## Multibanco (Portugal)

Multibanco is Portugal's interbank network. Customers can pay online, or pay a payment reference at an ATM.

### Payment Options

Customers can complete a Multibanco payment in three ways:

1. **Online banking**: A bank transfer through the customer's internet banking.
2. **ATM payment**: The customer receives a payment reference and pays it at any Multibanco ATM.
3. **Mobile banking**: A payment in the customer's banking app.

### How ATM Payment Works

For an ATM payment, the customer receives a payment reference like this one:

```text theme={null}
Entity: 12345
Reference: 123 456 789
Amount: €50.00
```

The customer pays with this reference at any Portuguese ATM or through online banking. The reference is valid for a limited time, which is shown to the customer with the reference.

### Configuration

To offer Multibanco, include `multibanco` and bill in EUR:

```javascript theme={null}
// `client` is an initialized DodoPayments client.
const session = await client.checkoutSessions.create({
  product_cart: [{ product_id: 'pdt_123', quantity: 1 }],
  allowed_payment_method_types: ['multibanco', 'credit', 'debit'],
  billing_currency: 'EUR',
  billing_address: {
    country: 'PT',
    zipcode: '1000-001'
  },
  return_url: 'https://example.com/success'
});
```

<Note>
  A Multibanco ATM payment completes when the customer pays the reference, which can be well after checkout. Use webhooks to learn when the payment is confirmed.
</Note>

## BLIK (Poland)

BLIK is Poland's most popular mobile payment method. The customer pays with a one-time 6-digit code that they generate in their banking app. BLIK payments are billed in **PLN** (Polish złoty), not EUR.

### How It Works

The customer generates a code in their banking app, enters it at checkout, and approves the payment in the app:

```mermaid theme={null}
sequenceDiagram
    participant Customer
    participant Checkout
    participant Dodo
    participant BLIK
    participant BankApp

    Customer->>Checkout: Select BLIK
    Checkout->>Dodo: Create payment
    Customer->>BankApp: Generate 6-digit code
    Customer->>Checkout: Enter BLIK code
    Checkout->>Dodo: Submit code
    Dodo->>BLIK: Authorize payment
    BLIK->>BankApp: Confirmation request
    Customer->>BankApp: Approve payment
    BankApp->>BLIK: Payment confirmed
    BLIK->>Dodo: Success callback
    Dodo->>Checkout: Payment complete
```

### Availability

* **Billing currency:** PLN only
* **Transaction type:** One-time payments only. BLIK isn't offered for subscriptions.
* **Coverage:** All major Polish banks that support BLIK

### Configuration

To offer BLIK, include `blik` and set `billing_currency` to `PLN`:

```javascript theme={null}
// `client` is an initialized DodoPayments client.
const session = await client.checkoutSessions.create({
  product_cart: [{ product_id: 'pdt_123', quantity: 1 }],
  allowed_payment_method_types: ['blik', 'credit', 'debit'],
  billing_currency: 'PLN',
  billing_address: {
    country: 'PL',
    zipcode: '00-001'
  },
  return_url: 'https://example.com/success'
});
```

<Note>
  BLIK requires a **PLN** billing currency, and Dodo Payments bills in PLN only when [Adaptive Currency](/features/adaptive-currency) is enabled. Enable Adaptive Currency so Polish customers are billed in PLN and BLIK becomes available.
</Note>

## SEPA Direct Debit (Eurozone)

SEPA Direct Debit lets customers in the Eurozone pay from their bank account instead of a card. It's offered on EUR checkouts for one-time payments, not for subscriptions, when the billing country is Austria, Belgium, Estonia, Finland, France, Germany, Ireland, Italy, Latvia, Lithuania, the Netherlands, Portugal, Slovakia, or Spain.

<Warning>
  **SEPA Direct Debit isn't instant. A payment takes up to 6 business days to confirm.** Unlike a card payment, the customer's authorization at checkout doesn't mean the money has cleared. Don't fulfill the order on the checkout redirect or on `payment.processing`. Wait for the `payment.succeeded` webhook.
</Warning>

### How It Works

The customer authorizes the debit at checkout, and Dodo Payments then collects the funds from their bank account. The bank clears the debit asynchronously, so the payment stays in the `processing` state until it reaches a final outcome:

```mermaid theme={null}
sequenceDiagram
    participant Customer
    participant Checkout
    participant Dodo
    participant Server as Your Server
    participant Bank

    Customer->>Checkout: Authorize SEPA debit
    Checkout->>Dodo: Create payment
    Dodo->>Checkout: Redirect (payment accepted, NOT settled)
    Dodo-->>Server: Webhook: payment.processing
    Note over Dodo,Bank: Bank clears the debit (up to 6 business days)
    Bank->>Dodo: Debit cleared
    Dodo-->>Server: Webhook: payment.succeeded
    Note over Server: Fulfill the order here
```

### Payment Timeline

A SEPA payment moves through these stages:

| Stage | When | Payment status | What it means |
| :- | :- | :- | :- |
| **Authorization** | At checkout | `processing` | The customer approved the debit and was redirected back. The money has **not** moved yet, so don't fulfill. |
| **Confirmation** | Up to **6 business days** later | `succeeded` | The bank cleared the debit. Fulfill the order now. |
| **Failure** | Up to **6 business days** later | `failed` | The debit couldn't be collected, for example because of insufficient funds. Don't fulfill, and notify the customer. |

Confirmation arrives days after the customer leaves your site, so your webhook handler, not the checkout redirect, must grant access. See [Handling the Confirmation Delay](#handling-the-confirmation-delay).

### Availability

* **Billing currency:** EUR
* **Transaction type:** One-time payments only. SEPA Direct Debit isn't offered for subscriptions.

### Configuration

To offer SEPA Direct Debit, include `sepa` and bill in EUR:

```javascript theme={null}
// `client` is an initialized DodoPayments client.
const session = await client.checkoutSessions.create({
  product_cart: [{ product_id: 'pdt_123', quantity: 1 }],
  allowed_payment_method_types: ['sepa', 'credit', 'debit'],
  billing_currency: 'EUR',
  billing_address: {
    country: 'DE',
    zipcode: '10115'
  },
  return_url: 'https://example.com/success'
});
```

### SEPA Test IBANs

In test mode, enter one of these IBANs at checkout to force a specific outcome:

| Test IBAN | Behavior |
| :- | :- |
| `DE89370400440532013000` | The payment succeeds. |
| `DE08370400440532013003` | The payment succeeds after a delay of at least three minutes. |
| `DE62370400440532013001` | The payment fails. |
| `DE78370400440532013004` | The payment fails after a delay of at least three minutes. |
| `DE35370400440532013002` | The payment succeeds, then is immediately disputed. |
| `DE65370400440002222227` | The payment fails due to insufficient funds. |
| `DE18370400440000066666` | The bank account is unusable, so the payment method can't be created. |

To test country-specific behavior, use the success IBAN for another Eurozone country:

| Country | Success IBAN |
| :- | :- |
| Austria | `AT611904300234573201` |
| Belgium | `BE62510007547061` |
| Estonia | `EE382200221020145685` |
| Finland | `FI2112345600000785` |
| France | `FR1420041010050500013M02606` |
| Ireland | `IE29AIBK93115212345678` |
| Luxembourg | `LU280019400644750000` |

<Note>
  Use the delayed test IBANs to confirm that your webhook handler, not the checkout redirect, grants access. SEPA payments confirm long after the customer leaves checkout.
</Note>

### Handling the Confirmation Delay

SEPA settles up to 6 business days after checkout, so the browser redirect can't tell you whether a payment cleared. Drive fulfillment from webhook events instead. Switch on the event `type` and handle each stage:

| Event Type | When it fires | What to do |
| :- | :- | :- |
| `payment.processing` | The customer authorized the debit at checkout and was redirected back. | **Don't fulfill.** Mark the order pending. Optionally, tell the customer that their payment is processing. |
| `payment.succeeded` | The bank cleared the debit, up to 6 business days later. | Fulfill the order: grant access, provision the product, and send the receipt. |
| `payment.failed` | The debit couldn't be collected. | Notify the customer and prompt a retry. Don't fulfill. |

<Tip>
  Fulfill on **`payment.succeeded` from the webhook**, not on the checkout redirect or on `payment.processing`. The redirect happens as soon as the customer authorizes the debit, days before the money clears.
</Tip>

The following Express handler verifies each event's signature with `client.webhooks.unwrap` before it acts on the event. For endpoint setup, see the [Webhooks guide](/developer-resources/webhooks). For every event, see the [Webhook Event Guide](/developer-resources/webhooks/intents/webhook-events-guide).

```javascript Handling SEPA payment events expandable theme={null}
import express from 'express';
import DodoPayments from 'dodopayments';

const client = new DodoPayments({
  bearerToken: process.env.DODO_PAYMENTS_API_KEY,
  webhookKey: process.env.DODO_PAYMENTS_WEBHOOK_KEY,
});
const app = express();

// markOrderPending, fulfillOrder, and markOrderFailed are your own order functions.
app.post('/webhooks/dodo', express.raw({ type: 'application/json' }), async (req, res) => {
  let event;
  try {
    // Checks the webhook-id, webhook-signature, and webhook-timestamp headers.
    event = client.webhooks.unwrap(req.body.toString(), { headers: req.headers });
  } catch {
    return res.status(400).send('Invalid signature');
  }

  switch (event.type) {
    case 'payment.processing': {
      // SEPA debit authorized but NOT settled. This can last up to 6 business days.
      // Record the order as pending; do not grant access yet.
      await markOrderPending(event.data.payment_id);
      break;
    }
    case 'payment.succeeded': {
      // The debit cleared, so it's safe to fulfill now.
      await fulfillOrder(event.data.payment_id);
      break;
    }
    case 'payment.failed': {
      // The debit could not be collected (for example, insufficient funds).
      await markOrderFailed(event.data.payment_id);
      // Notify the customer and prompt a retry.
      break;
    }
  }

  res.json({ received: true });
});
```

<Warning>
  Set customer expectations at checkout. Access is granted only after the debit clears, so tell SEPA customers that their order is processing and that you'll notify them when the payment confirms. Otherwise, they may expect immediate access, as with a card payment.
</Warning>

## Satispay (Europe)

Satispay is a European mobile payment network with its largest user base in Italy. Customers pay from the Satispay app without sharing card or bank details. Satispay payments are billed in **EUR**.

### Features

* App-based payments that don't depend on card networks
* Strong adoption in Italy, and growing use in other European markets
* Support for both one-time payments and subscriptions

### Availability

* **Billing currency:** EUR
* **Transaction type:** One-time payments and subscriptions
* **Amount:** From €0.50 to €999,999.99 per payment

### Configuration

To offer Satispay, include `satispay` and bill in EUR:

```javascript theme={null}
// `client` is an initialized DodoPayments client.
const session = await client.checkoutSessions.create({
  product_cart: [{ product_id: 'pdt_123', quantity: 1 }],
  allowed_payment_method_types: ['satispay', 'credit', 'debit'],
  billing_currency: 'EUR',
  billing_address: {
    country: 'IT',
    zipcode: '00100'
  },
  return_url: 'https://example.com/success'
});
```

## API Method Types

Pass these values in `allowed_payment_method_types`:

| Type | Method | Country |
| :- | :- | :- |
| `ideal` | iDEAL | Netherlands |
| `bancontact_card` | Bancontact | Belgium |
| `eps` | EPS | Austria |
| `multibanco` | Multibanco | Portugal |
| `blik` | BLIK | Poland |
| `sepa` | SEPA Direct Debit | Eurozone |
| `satispay` | Satispay | Europe (Italy) |

## Multi-Country European Checkout

To sell in several European countries, include every regional method, plus cards as a fallback:

```javascript theme={null}
// `client` is an initialized DodoPayments client.
const session = await client.checkoutSessions.create({
  product_cart: [{ product_id: 'pdt_123', quantity: 1 }],
  allowed_payment_method_types: [
    'ideal',           // Netherlands
    'bancontact_card', // Belgium
    'eps',             // Austria
    'multibanco',      // Portugal
    'blik',            // Poland (requires PLN billing currency)
    'sepa',            // Eurozone (one-time payments only)
    'satispay',        // Europe / Italy
    'credit',          // Fallback
    'debit'            // Fallback
  ],
  billing_currency: 'EUR',
  return_url: 'https://example.com/success'
});
```

Dodo Payments shows each customer only the methods that match their billing country and currency. A Dutch customer sees iDEAL, and a Belgian customer sees Bancontact. This session bills in EUR, so BLIK doesn't appear.

## Testing

You can test European payment methods in test mode. The test flow simulates the bank authentication step.

<Note>
  SEPA Direct Debit uses a different test flow. Instead of a simulated bank flow, you enter a test IBAN directly. See [SEPA Test IBANs](#sepa-test-ibans).
</Note>

<Note>
  Multibanco also uses a different test flow. Checkout shows a voucher instead of a bank flow, and the email you enter decides the result. See [Multibanco Test Emails](#multibanco-test-emails).
</Note>

<Steps>
  <Step title="Enable Test Mode">
    Turn off the **Live Mode** switch in the dashboard sidebar, and use API keys created in test mode.
  </Step>

  <Step title="Set Appropriate Billing Address">
    Set the billing address country to match the payment method:

    * `NL` for iDEAL
    * `BE` for Bancontact
    * `AT` for EPS
    * `PT` for Multibanco
    * `PL` for BLIK (with PLN billing currency)
    * `IT` for Satispay
  </Step>

  <Step title="Complete the Test Flow">
    Follow the simulated bank authentication flow in test mode.
  </Step>
</Steps>

### Multibanco Test Emails

After you click **Pay**, checkout shows a Multibanco voucher. In test mode, the email you enter decides the result:

| Email | Result |
| :- | :- |
| Any email, for example `jenny@example.com` | Payment succeeds after about 3 minutes. |
| `succeed_immediately@example.com` | Payment succeeds within a few seconds. |
| `expire_immediately@example.com` | Payment fails within a few seconds. |
| `expire_with_delay@example.com` | Payment fails after about 3 minutes. |
| `fill_never@example.com` | Payment never completes. |

To see the success page, use `succeed_immediately@example.com`, wait a few seconds, and tap **Done**.

## Best Practices

<AccordionGroup>
  <Accordion title="Always include regional methods for target markets">
    If you sell to Dutch customers, include iDEAL. Leaving it out is like not accepting Visa in the US: you lose a significant share of sales.
  </Accordion>

  <Accordion title="Match currency to region">
    Most European payment methods require EUR, so make sure your pricing supports EUR transactions. The one exception is BLIK, which is offered only with **PLN** (Polish złoty) billing.
  </Accordion>

  <Accordion title="Handle redirects gracefully">
    Most European methods redirect the customer to their bank or payment app. Make sure your return URL handling works for customers who abandon the flow midway.
  </Accordion>

  <Accordion title="Provide card fallbacks">
    Not every customer in Europe can use these regional methods, for example tourists and expats. Include `credit` and `debit` as fallbacks. If no method is available, the checkout session fails.
  </Accordion>

  <Accordion title="Consider Multibanco timing">
    A Multibanco ATM payment can take hours to complete. Don't block fulfillment on immediate payment. Use webhooks for asynchronous confirmation.
  </Accordion>

  <Accordion title="Account for the SEPA 6-day delay">
    SEPA Direct Debit takes up to **6 business days** to confirm. Don't fulfill on the checkout redirect or on `payment.processing`. Grant access only from the `payment.succeeded` webhook, and tell customers at checkout that their order is pending. See [Handling the Confirmation Delay](#handling-the-confirmation-delay).
  </Accordion>
</AccordionGroup>

## Troubleshooting

<AccordionGroup>
  <Accordion title="European method not appearing">
    **Check:**

    1. Does the customer's billing country match the method's country?
    2. Is the billing currency EUR, or PLN for BLIK?
    3. Is the method included in `allowed_payment_method_types`?
    4. Is the checkout for a one-time payment? iDEAL, Bancontact, EPS, Multibanco, BLIK, and SEPA Direct Debit aren't offered for subscriptions.

    **Solution:** Country-specific methods appear only for their own country. A customer with billing country `DE` (Germany) doesn't see iDEAL, which is Netherlands-only.
  </Accordion>

  <Accordion title="Bank authentication failed">
    **Causes:**

    * The customer cancelled during bank authentication.
    * The bank's authentication system was temporarily unavailable.
    * The customer entered incorrect credentials.

    **Solution:** The customer should retry. If the failure persists, suggest a different payment method.
  </Accordion>

  <Accordion title="Redirect not completing">
    **Causes:**

    * The customer closed the browser during the bank redirect.
    * A network issue interrupted authentication.
    * The return URL is misconfigured.

    **Solution:** Check that your return URL is correct and reachable, and that it handles both success and failure states.
  </Accordion>

  <Accordion title="Multibanco payment pending">
    **Cause:** The customer received a payment reference but hasn't paid yet.

    **Solution:** This is expected for ATM payments. Wait for the webhook confirmation. The reference expires after the limited time shown to the customer.
  </Accordion>

  <Accordion title="SEPA payment stuck in processing">
    **Cause:** SEPA Direct Debit clears asynchronously through the customer's bank.

    **Solution:** This is expected. A `payment.processing` state can last up to **6 business days** before the debit clears. Wait for the final `payment.succeeded` webhook (fulfill) or `payment.failed` webhook (don't fulfill). Don't treat the checkout redirect as confirmation. See [Handling the Confirmation Delay](#handling-the-confirmation-delay).
  </Accordion>
</AccordionGroup>

## Related Pages

<CardGroup cols={2}>
  <Card title="Payment Methods Overview" icon="credit-card" href="/features/payment-methods">
    See all supported payment methods.
  </Card>

  <Card title="Adaptive Currency" icon="globe" href="/features/adaptive-currency">
    Currency support and automatic conversion.
  </Card>

  <Card title="Checkout Guide" icon="book" href="/developer-resources/checkout-session">
    Complete checkout implementation guide.
  </Card>

  <Card title="Webhooks" icon="webhook" href="/developer-resources/webhooks">
    Handle payment confirmations asynchronously.
  </Card>
</CardGroup>


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