One-off Direct Debit#

View as Markdown

One-off Direct Debits allow you to collect fixed or variable amounts from your customers on a flexible schedule. The customer sets up a Direct Debit mandate once; after that, you can collect payments of any amount at any time without requiring re-authorisation.

Best for: Usage-based billing, professional services with variable charges, invoice payments.

One-off Direct Debit vs Pay By Bank#

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

For time-sensitive payments, consider Pay By Bank, which confirms within seconds. If you need immediate confirmation for the first payment but also want a mandate for future charges, use Instant Payment + DD Setup instead.

How it works#

The customer sets up a mandate via your chosen integration
You create a payment against the mandate via the API
GoCardless collects the payment (typically 2-5 business days)
You receive a webhook confirming the payment status
Funds are included in your next payout

Key differences from recurring payments: You control when and how much to charge. There's no automatic schedule; you create each payment individually via the API.

Step-by-step guide#

Create a billing request#

HTTPPHPPythonRubyJavaJavaScript.NETGo

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

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

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

$response = $client->billingRequests()->create([
  'params' => [
    'mandate_request' => [
      'scheme' => 'bacs',
    ],
  ],
]);

import os
import gocardless_pro

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

response = client.billing_requests.create(
    params={
        'mandate_request': {
            'scheme': 'bacs',
        }
    }
)

require 'gocardless_pro'

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

response = client.billing_requests.create(
  params: {
    mandate_request: {
      scheme: 'bacs'
    }
  }
)

import com.gocardless.GoCardlessClient;

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

BillingRequestCreateResponse response = client.billingRequests()
    .create()
    .withMandateRequestScheme("bacs")
    .execute();

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({
  mandate_request: {
    scheme: "bacs",
  },
});

using GoCardless;

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

var response = await client.BillingRequests.CreateAsync(
    new BillingRequestCreateRequest
    {
        MandateRequest = new BillingRequestCreateRequest.BillingRequestMandateRequest
        {
            Scheme = "bacs"
        }
    }
);

package main

import (
    "context"
    "fmt"
    "os"

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

func main() {
    opts := gocardless.WithEndpoint(gocardless.SandboxEndpoint)
    client, err := gocardless.New(os.Getenv("GC_ACCESS_TOKEN"), opts)
    if err != nil {
        panic(err)
    }

    params := gocardless.BillingRequestCreateParams{
        MandateRequest: &gocardless.BillingRequestCreateParamsMandateRequest{
            Scheme: "bacs",
        },
    }

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

Response:

{
  "billing_requests": {
    "id": "BRQ000123",
    "status": "pending",
    "mandate_request": {
      "currency": "GBP",
      "scheme": "bacs"
    }
  }
}

Confirm the mandate#

After creating the Billing Request, direct the customer to authorise the mandate. 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.
Custom API — Collect customer details and bank account via Billing Request actions, then confirm. See Custom Payment Pages.

Handle the outcome#

Listen for webhooks to confirm the payment status:

Event	Meaning
billing_request_fulfilled	Customer authorised the mandate
mandates_created	Mandate created and ready to use
mandates_active	Mandate active

Collect a payment#

Retrieve the mandate ID from the fulfilled billing request:

HTTPPHPPythonRubyJavaJavaScript.NETGo

curl https://api.gocardless.com/billing_requests/BRQ000123 \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

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

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

$response = $client->billingRequests()->get('BRQ000123');

$mandateId = $response->mandate_request->links->mandate;

import os
import gocardless_pro

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

response = client.billing_requests.get('BRQ000123')

mandate_id = response.mandate_request.links.mandate

require 'gocardless_pro'

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

response = client.billing_requests.get('BRQ000123')

mandate_id = response.mandate_request.links.mandate

import com.gocardless.GoCardlessClient;

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

BillingRequest billingRequest = client.billingRequests()
    .get("BRQ000123")
    .execute();

String mandateId = billingRequest.getMandateRequest().getLinks().getMandate();

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

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

const billingRequest = await client.billingRequests.find("BRQ000123");

const mandateId = billingRequest.mandate_request.links.mandate;

using GoCardless;

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

var billingRequest = await client.BillingRequests.GetAsync("BRQ000123");

var mandateId = billingRequest.MandateRequest.Links.Mandate;

package main

import (
    "context"
    "fmt"
    "os"

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

func main() {
    opts := gocardless.WithEndpoint(gocardless.SandboxEndpoint)
    client, err := gocardless.New(os.Getenv("GC_ACCESS_TOKEN"), opts)
    if err != nil {
        panic(err)
    }

    billingRequest, err := client.BillingRequests.Get(context.TODO(), "BRQ000123")
    if err != nil {
        panic(err)
    }

    mandateId := billingRequest.MandateRequest.Links.Mandate
    fmt.Println(mandateId)
}

Response:

{
  "billing_requests": {
    "id": "BRQ000123",
    "status": "fulfilled",
    "mandate_request": {
      "scheme": "bacs",
      "links": {
        "mandate": "MD123"
      }
    }
  }
}

Then collect whenever you need to:

HTTPPHPPythonRubyJavaJavaScript.NETGo

curl -X POST https://api.gocardless.com/payments \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "payments": {
      "amount": 5000,
      "currency": "GBP",
      "description": "Order #1234",
      "links": {
        "mandate": "MD123"
      }
    }
  }'

$response = $client->payments()->create([
    'params' => [
        'amount'      => 5000,
        'currency'    => 'GBP',
        'description' => 'Order #1234',
        'links'       => [
            'mandate' => 'MD123',
        ],
    ],
]);

response = client.payments.create(
    params={
        'amount':      5000,
        'currency':    'GBP',
        'description': 'Order #1234',
        'links': {
            'mandate': 'MD123',
        },
    }
)

response = client.payments.create(
  params: {
    amount:      5000,
    currency:    'GBP',
    description: 'Order #1234',
    links: {
      mandate: 'MD123'
    }
  }
)

Payment payment = client.payments()
    .create()
    .withAmount(5000)
    .withCurrency("GBP")
    .withDescription("Order #1234")
    .withLinksMandate("MD123")
    .execute();

const payment = await client.payments.create({
  amount: 5000,
  currency: "GBP",
  description: "Order #1234",
  links: {
    mandate: "MD123",
  },
});

var payment = await client.Payments.CreateAsync(
    new PaymentCreateRequest
    {
        Amount      = 5000,
        Currency    = "GBP",
        Description = "Order #1234",
        Links = new PaymentCreateRequest.PaymentLinks
        {
            Mandate = "MD123"
        }
    }
);

params := gocardless.PaymentCreateParams{
    Amount:      5000,
    Currency:    "GBP",
    Description: "Order #1234",
    Links: gocardless.PaymentCreateParamsLinks{
        Mandate: "MD123",
    },
}

payment, err := client.Payments.Create(context.TODO(), params)

What's next?#

Pay By Bank

Instant bank payments that confirm within seconds — no mandate required.

Learn more

Recurring Payments

Set up automatic subscription schedules against an active mandate.

Learn more

Instant Payment + DD Setup

Collect an instant first payment while setting up a mandate for future charges.

Learn more

Mandate Events

Understand the webhooks fired during the mandate and payment lifecycle.

Learn more