# Pay By Bank

Source: https://docs.gocardless.com/docs/collect-payments/one-off-payments/pay-by-bank

# Pay By Bank

Pay By Bank lets you collect a one-off payment directly from your customer's bank account with confirmation within minutes. Unlike Direct Debit, there's no mandate — the customer must authorise each payment individually via their banking app.

**Availability:** GBP (Faster Payments), EUR (SEPA Instant). You can also use [Hosted Pages](/docs/collect-payments/integration-types/gocardless-hosted-pages) for a no-code approach — Drop-in Flow does not support Pay By Bank.

**Best for:** E-commerce checkouts, one-time purchases, time-sensitive payments, high-value transactions where immediate confirmation is needed, replacing card payments to reduce fees and eliminate chargebacks.

## Pay By Bank vs One-off Direct Debit

|                            | Pay By Bank                      | One-off via Direct Debit                    |
| -------------------------- | -------------------------------- | ------------------------------------------- |
| Mandate required           | No                               | Yes                                         |
| Customer authorisation     | Per payment                      | Once (mandate setup)                        |
| Confirmation speed         | Minutes                          | 2-5 business days                           |
| Re-use for future payments | No, new authorisation each time  | Yes, collect again without re-authorisation |
| Protection                 | None                             | Scheme-specific                             |
| Customer experience        | The bank app redirects each time | One-time setup, then hands-off              |

If you expect to charge the customer more than once, a [Direct Debit mandate](/docs/collect-payments/setting-up-mandates) is usually better — the customer authorises once and you can collect future payments without requiring them to open their banking app again. If you need immediate confirmation for the first payment but also want a mandate for future charges, use [Instant Payment + DD Setup](/docs/collect-payments/recurring-payments/instant-first-payment-with-mandate) instead.

## How it works

1. You create a Billing Request with a payment_request — no mandate_request
2. The customer authorises the payment via your chosen integration
3. The customer is redirected to their banking app to approve
4. Payment is confirmed within seconds
5. You receive a billing_requests.fulfilled webhook — payment is processing
6. You receive a payments.confirmed webhook — payment is settled
7. Funds arrive in your account (typically next business day)

## Step-by-step guide

### Create a Billing Request

```http
curl -X POST https://api.gocardless.com/billing_requests \\
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \\
  -H "Content-Type: application/json" \\
  -d '
    }
  }'
```

```php
<?php
require 'vendor/autoload.php';

$client = new \\GoCardlessPro\\Client([
'access_token' => getenv('GC_ACCESS_TOKEN'),
'environment' => \\GoCardlessPro\\Environment::SANDBOX
]);

$response = $client->billingRequests()->create([
'params' => [
'payment_request' => [
'description' => 'Order #9012',
'amount' => 12000,
'currency' => 'GBP',
'scheme' => 'faster_payments',
],
],
]);
```

```python
import os

client = gocardless_pro.Client(
access_token=os.environ['GC_ACCESS_TOKEN'],
environment='sandbox'
)

response = client.billing_requests.create(
params=
}
)
```

```ruby
require 'gocardless_pro'

client = GoCardlessPro::Client.new(
access_token: ENV['GC_ACCESS_TOKEN'],
environment: :sandbox
)

response = client.billing_requests.create(
params: 
}
)
```

```java
import com.gocardless.GoCardlessClient;

GoCardlessClient client = GoCardlessClient
.newBuilder(System.getenv("GC_ACCESS_TOKEN"))
.withEnvironment(GoCardlessClient.Environment.SANDBOX)
.build();

BillingRequestCreateResponse response = client.billingRequests()
.create()
.withPaymentRequestDescription("Order #9012")
.withPaymentRequestAmount(12000)
.withPaymentRequestCurrency("GBP")
.withPaymentRequestScheme("faster_payments")
.execute();
```

```javascript
const gocardless = require("gocardless-nodejs");
const constants = require("gocardless-nodejs/constants");

const client = gocardless(process.env.GC_ACCESS_TOKEN, constants.Environments.Sandbox);

const response = await client.billingRequests.create(,
});
```

```net
using GoCardless;

var client = GoCardlessClient.Create(
Environment.GetEnvironmentVariable("GC_ACCESS_TOKEN"),
GoCardlessClient.Environment.SANDBOX
);

var response = await client.BillingRequests.CreateAsync(
new BillingRequestCreateRequest

}
);
```

```go
package main

    "context"
    "fmt"
    "os"

    gocardless "github.com/gocardless/gocardless-pro-go/v6"

)

func main() 

    params := gocardless.BillingRequestCreateParams,
    }

    result, err := client.BillingRequests.Create(context.TODO(), params)
    if err != nil 
    fmt.Println(result)

}
```

**Response:**

```json
,
    "actions": [
      ,
      ,
      
    ]
  }
}
```

### Confirm the payment

After creating the Billing Request, direct the customer to authorise the payment. How you do this depends on your integration type:

- Hosted Pages — Create a Billing Request Flow and redirect the customer to the authorisation_url. See [Hosted Pages](/docs/collect-payments/integration-types/gocardless-hosted-pages).
- Custom API — Collect customer details and bank account via Billing Request actions, then confirm. See [Custom Payment Pages](/docs/collect-payments/integration-types/custom-payment-pages).

> **Warning:**
> Don't use the redirect to confirm the outcome. Always use webhooks.

### Handle the outcome

Listen for webhooks to confirm the payment status:

| Event                     | Meaning                                         |
| ------------------------- | ----------------------------------------------- |
| billing_request_fulfilled | Customer authorised, payment is being processed |
| payment_confirmed         | Payment confirmed and settled                   |
| payment_failed            | Payment failed (e.g., insufficient funds)       |

## What's next?

  
#### [Billing Request Events](/docs/collect-payments/events-and-webhooks/billing-request-events)

Understand the full event lifecycle for Pay By Bank payments.

  
#### [One-off Direct Debit](/docs/collect-payments/one-off-payments/one-off-direct-debit)

Set up a mandate so future payments don't require re-authorisation.

  
#### [Instant Payment + DD Setup](/docs/collect-payments/recurring-payments/instant-first-payment-with-mandate)

Combine instant first payment with mandate setup for future charges.

  
#### [Retain Customers with Fallbacks](/docs/optimise/retain-customers-with-fallbacks)

Offer a fallback payment method when bank authorisation fails.