GET https://api.gocardless.com/resources?after=ID789 HTTP/1.1

HTTP/1.1 200 (OK)
Content-Type: application/json
{
  "meta": {
    "cursors": {
      "after": "ID456",
      "before": "ID123"
    },
    "limit": 50
  },
  "resources": [{
    ...
  }]
}

POST https://api.gocardless.com/customer_bank_accounts HTTP/1.1
Content-Type: application/json
{
  "customer_bank_accounts": {
    "account_number": "55779911",
    "branch_code": "I'm not a sort code",
    "account_holder_name": "Frank Osborne",
    "country_code": "GB",
    "links": {
      "customer": "CU123"
    }
  }
}

HTTP/1.1 422 (Unprocessable Entity)
Content-Type: application/json
{
  "error": {
    "documentation_url": "https://developer.gocardless.com/#validation_failed",
    "message": "Validation failed",
    "type": "validation_failed",
    "code": 422,
    "request_id": "dd50eaaf-8213-48fe-90d6-5466872efbc4",
    "errors": [
      {
        "message": "must be a number",
        "field": "branch_code",
        "request_pointer": "/customer_bank_accounts/branch_code"
      }, {
        "message": "is the wrong length (should be 8 characters)",
        "field": "branch_code",
        "request_pointer": "/customer_bank_accounts/branch_code"
      }
    ]
  }
}

POST https://api.gocardless.com/customer_bank_accounts HTTP/1.1
Content-Type: application/json
{
  "customer_bank_accounts": {
    "account_number": "55779911",
    "branch_code": "200000",
    "account_holder_name": "Frank Osborne",
    "country_code": "GB",
    "links": {
      "customer": "CU123"
    }
  }
}

HTTP/1.1 400 (Bad Request)
Content-Type: application/json
{
  "error": {
    "message": "Invalid document structure",
    "documentation_url": "https://developer.gocardless.com/#invalid_document_structure",
    "type": "invalid_api_usage",
    "request_id": "bd271b37-a2f5-47c8-b461-040dfe0e9cb1",
    "code": 400,
    "errors": [
      {
        "reason": "invalid_document_structure",
        "message": "Invalid document structure"
      }
    ]
  }
}

POST https://api.gocardless.com/creditor_bank_accounts HTTP/1.1
Content-Type: application/json
{
  "creditor_bank_accounts": {
    "account_number": "55779911",
    "branch_code": "200000",
    "country_code": "GB",
    "set_as_default_payout_account": true,
    "account_holder_name": "Nude Wines",
    "links": {
      "creditor": "CR123"
    }
  }
}

HTTP/1.1 409 (Conflict)
Content-Type: application/json
{
  "error": {
    "message": "Bank account already exists",
    "documentation_url": "https://developer.gocardless.com/#bank_account_exists",
    "type": "validation_failed",
    "request_id": "bd271b37-a2f5-47c8-b461-040dfe0e9cb1",
    "code": 409,
    "errors": [
      {
        "reason": "bank_account_exists",
        "message": "Bank account already exists",
        "links": {
          "creditor_bank_account": "BA123"
        }
      }
    ]
  }
}

POST https://api.gocardless.com/bank_authorisations HTTP/1.1
Content-Type: application/json
{
  "bank_authorisations": {
    "redirect_uri": "https://my-company.com/landing",
    "links": {
      "billing_request": "BRQ123"
    }
  }
}

HTTP/1.1 201 Created
Location: /bank_authorisations/BAU123
Content-Type: application/json
{
  "bank_authorisations": {
    "id": "BAU123",
    "url": "https://pay-staging.gocardless.com/obauth/BAU123",
    "qr_code_url": "https://pay-staging.gocardless.com/obauth/BAU123/qr_code",
    "created_at": "2021-03-25T17:26:28.305Z",
    "authorisation_type": "payment",
    "last_visited_at": null,
    "authorised_at": null,
    "expires_at": "2021-03-25T17:41:28.000Z",
    "redirect_uri": "https://my-company.com/landing",
    "links": {
      "billing_request": "BRQ123",
      "institution": "monzo"
    }
  }
}

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

$client->bankAuthorisations()->create([
  "params" => [
    "redirect_uri" => "https://my-company.com/landing",
    "links" => [
      "billing_request" => "BRQ123"
    ]
  ]
]);

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

client.bank_authorisations.create(params={
  "redirect_uri": "https://my-company.com/landing",
  "links": {
    "billing_request": "BRQ123"
  }
})

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

@client.bank_authorisations.create(
  params: {
    redirect_uri: "https://my-company.com/landing",
    links: {
        billing_request: "BRQ123"
    }
  }
)

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

BankAuthorisation bankAuthorisation = client.bankAuthorisations().create()
  .withRedirectUri("https://my-company.com/landing")
  .withLinksBillingRequest("BRQ123")
  .execute();

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

const bankAuthorisation = await client.bankAuthorisations.create({
  redirect_uri: "https://my-company.com/landing",
  links: {
    billing_request: "BRQ123"
  }
});

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

var authorisationLinks = new gocardless.BankAuthorisationCreateRequest.BankAuthorisationLinks
{
  BillingRequest = "BRQ123"
};

var resp = await gocardless.BankAuthorisations.CreateAsync(
  new GoCardless.Services.BankAuthorisationCreateRequest()
  {
    RedirectUri = "https://my-company.com/landing",
    links = authorisationLinks,
  }
);

GoCardless.Resources.BankAuthorisation bankAuthorisation = resp.BankAuthorisation;

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  bankAuthorisationCreateParams := gocardless.BankAuthorisationCreateParams{
    RedirectUri: "https://my-company.com/landing",
    Links: gocardless.BankAuthorisationCreateParamsLinks{
      BillingRequest: "BR123",
    },
  }
  
  bankAuthorisation, err :=  client.BankAuthorisations.Create(context, bankAuthorisationCreateParams)

}

GET https://api.gocardless.com/bank_authorisations/BAU123 HTTP/1.1

HTTP/1.1 200
Content-Type: application/json
{
  "bank_authorisations": {
    "id": "BAU123",
    "url": "https://pay-staging.gocardless.com/obauth/BAU123",
    "qr_code_url": "https://pay-staging.gocardless.com/obauth/BAU123/qr_code",
    "created_at": "2021-03-25T17:26:28.305Z",
    "authorisation_type": "payment",
    "last_visited_at": null,
    "authorised_at": null,
    "expires_at": "2021-03-25T17:41:28.000Z",
    "redirect_uri": "https://my-company.com/landing",
    "links": {
      "billing_request": "BRQ123",
      "institution": "monzo"
    }
  }
}

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

$client->bankAuthorisations()->get("BAU123");

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

client.bank_authorisations.get("BAU123")

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

@client.bank_authorisations.get("BAU123")

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

client.bankAuthorisations().get("BAU123").execute();

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

const resp = await client.bankAuthorisations.find("BAU123");

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

var resp = await gocardless.BankAuthorisations.GetAsync("BAU123");

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  bankAuthorisation, err := client.BankAuthorisations.Get(context, "BAU123")

}

POST https://api.gocardless.com/billing_requests HTTP/1.1
Content-Type: application/json
{
  "billing_requests": {
    "payment_request": {
      "description": "First Payment",
      "amount": "500",
      "currency": "GBP"
    },
    "mandate_request": {
      "scheme": "bacs"
    }
  }
}

HTTP/1.1 201 Created
Location: /billing_requests/BRQ123
Content-Type: application/json
{
    "billing_requests": {
        "id": "BRQ123",
        "created_at": "2021-03-22T12:20:04.397Z",
        "status": "pending",
        "mandate_request": {
            "currency": "GBP",
            "scheme": "bacs",
            "links": {}
        },
        "payment_request": {
            "description": "First Payment",
            "currency": "GBP",
            "amount": 500,
            "scheme": "faster_payments",
            "links": {}
        },
        "metadata": null,
        "links": {
            "customer": "CU123",
            "customer_billing_detail": "CBD123"
        },
        "creditor_name": "Mr Creditor",
        "actions": [
            {
                "type": "choose_currency",
                "required": true,
                "completes_actions": [],
                "requires_actions": [],
                "status": "completed"
            },
            {
                "type": "collect_customer_details",
                "required": true,
                "completes_actions": [],
                "requires_actions": [
                    "choose_currency"
                ],
                "status": "pending",
                "collect_customer_details": {
                    "incomplete_fields": {
                        "customer": [
                            "email",
                            "given_name",
                            "family_name"
                        ],
                        "customer_billing_detail": [
                            "address_line1",
                            "city",
                            "postal_code",
                            "country_code"
                        ]
                    }
                }
            },
            {
              "type": "select_institution",
              "required": false,
              "completes_actions": [],
              "requires_actions": [],
              "status": "pending"
            },
            {
                "type": "collect_bank_account",
                "required": true,
                "completes_actions": [
                    "choose_currency"
                ],
                "requires_actions": [],
                "status": "pending"
            },
            {
                "type": "bank_authorisation",
                "required": true,
                "completes_actions": [],
                "requires_actions": [
                    "collect_bank_account"
                ],
                "status": "pending"
            }
        ],
        "resources": {
            "customer": {
                "id": "CU123",
                "created_at": "2021-03-22T12:20:04.238Z",
                "email": null,
                "given_name": null,
                "family_name": null,
                "company_name": null,
                "language": "en",
                "phone_number": null,
                "metadata": {}
            },
            "customer_billing_detail": {
                "id": "CBD123",
                "created_at": "2021-03-22T12:20:04.374Z",
                "address_line1": null,
                "address_line2": null,
                "address_line3": null,
                "city": null,
                "region": null,
                "postal_code": null,
                "country_code": null,
                "swedish_identity_number": null,
                "danish_identity_number": null
            }
        }
    }
}

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

$client->billingRequests()->create([
  "params" => [
    "payment_request" => [
      "description" => "First Payment",
      "amount" => "500",
      "currency" => "GBP",
    ],
    "mandate_request" => [
      "scheme" => "bacs"
    ]
  ]
]);

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

client.billing_requests.create(params={
  "payment_request": {
    "description": "First Payment",
    "amount": "500",
    "currency": "GBP",
  },
  "mandate_request": {
    "scheme": "bacs"
  }
})

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

@client.billing_requests.create(
  params: {
    payment_request: {
      description: "First Payment",
      amount: "500",
      currency: "GBP",
    },
    mandate_request: {
      scheme: "bacs"
    }
  }
)

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

BillingRequest billingRequest = client.billingRequests().create()
  .withPaymentRequestDescription("First Payment")
  .withPaymentRequestAmount(500)
  .withPaymentRequestCurrency(Currency.GBP)
  .withMandateRequestScheme("bacs")
  .execute();

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

const billingRequest = await client.billingRequests.create({
  payment_request: {
    description: "First Payment",
    amount: "500",
    currency: "GBP",
  },
  mandate_request: {
    scheme: "bacs"
  }
});

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

var paymentRequest = new gocardless.BillingRequestCreateRequest.BillingRequestPaymentRequest
{
  Description = "First payment",
  Amount = 500,
  Currency = "GBP",
};

var mandateRequest = new gocardless.BillingRequestCreateRequest.BillingRequestMandateRequest
{
  Scheme = "bacs",
};

var resp = await gocardless.BillingRequests.CreateAsync(
  new GoCardless.Services.BillingRequestCreateRequest()
  {
    PaymentRequest = paymentRequest,
    MandateRequest = mandateRequest,
  }
);

GoCardless.Resources.BillingRequest billingRequest = resp.BillingRequest;

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  billingRequestCreateParams := gocardless.BillingRequestCreateParams{
    PaymentRequest: &gocardless.BillingRequestCreateParamsPaymentRequest{
      Amount:      1000,
      Currency:    "GBP",
      Description: "First Payment",
    },
    MandateRequest: &gocardless.BillingRequestCreateParamsMandateRequest{
      Scheme: "bacs",
    },
  }
  
  billingRequest, err := client.BillingRequests.Create(context, billingRequestCreateParams)

}

POST https://api.gocardless.com/billing_requests/BRQ123/actions/collect_customer_details HTTP/1.1
Content-Type: application/json
{
  "data": {
    "customer": {
      "email": "alice@example.com",
      "given_name": "Alice",
      "family_name": "Smith"
    },
    "customer_billing_detail": {
      "address_line1": "1 Somewhere Lane"
    }
  }
}

HTTP/1.1 200
Content-Type: application/json
{
    "billing_requests": {
        "id": "BRQ123",
        "created_at": "2021-03-22T12:20:04.397Z",
        "status": "pending",
        "mandate_request": {
            "currency": "GBP",
            "scheme": "bacs",
            "links": {}
        },
        "payment_request": {
            "description": "First Payment",
            "currency": "GBP",
            "amount": 500,
            "scheme": "faster_payments",
            "links": {}
        },
        "metadata": null,
        "links": {
            "customer": "CU123",
            "creditor": "CR123",
            "mandate_request": "MRQ123"
        },
        "creditor_name": "Mr Creditor",
        "actions": [
            {
                "type": "choose_currency",
                "required": true,
                "completes_actions": [],
                "requires_actions": [],
                "status": "completed"
            },
            {
                "type": "collect_customer_details",
                "required": true,
                "completes_actions": [],
                "requires_actions": [
                    "choose_currency"
                ],
                "status": "pending",
                "collect_customer_details": {
                    "incomplete_fields": {
                        "customer": [],
                        "customer_billing_detail": [
                            "address_line1",
                            "city",
                            "postal_code",
                            "country_code"
                        ]
                    }
                }
            },
            {
              "type": "select_institution",
              "required": false,
              "completes_actions": [],
              "requires_actions": [],
              "status": "pending"
            },
            {
                "type": "collect_bank_account",
                "required": true,
                "completes_actions": [
                    "choose_currency"
                ],
                "requires_actions": [],
                "status": "pending"
            },
            {
                "type": "bank_authorisation",
                "required": true,
                "completes_actions": [],
                "requires_actions": [
                    "collect_bank_account"
                ],
                "status": "pending"
            }
        ],
        "resources": {
            "customer": {
                "id": "CU123",
                "created_at": "2021-03-22T12:20:04.238Z",
                "email": "alice@example.com",
                "given_name": "Alice",
                "family_name": "Smith",
                "company_name": null,
                "language": "en",
                "phone_number": null,
                "metadata": {}
            }
        }
    }
}

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

$client->billingRequests()->collectCustomerDetails("BR123", [
  "params" => [
    "customer" => [
      "email" => "alice@example.com",
      "given_name" => "Alice",
      "family_name" => "Smith"
    ],
    "customer_billing_detail" => [
      "address_line1" => "1 Somewhere Lane"
    ]
  ]
]);

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

client.billing_requests.collect_customer_details("BR123", params={
  customer: {
    email: "alice@example.com",
    given_name: "Alice",
    family_name: "Smith",
  },
  customer_billing_detail: {
    address_line1: "1 Somewhere Lane"
  }
})

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

@client.billing_requests.collect_customer_details("BR123", {
  params: {
    customer: {
      email: "alice@example.com",
      given_name: "Alice",
      family_name: "Smith",
    },
    customer_billing_detail: {
      address_line1: "1 Somewhere Lane"
    }
  }
})

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

client.billingRequests().collectCustomerDetails("BR123")
  .withCustomerEmail("alice@example.com")
  .withCustomerGivenName("Alice")
  .withCustomerFamilyName("Smith")
  .withCustomerBillingDetailAddressLine1("1 Somewhere Lane")
  .execute();

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

const resp = await client.billingRequests.collectCustomerDetails("BR123", {
  customer: {
    email: "alice@example.com",
    given_name: "Alice",
    family_name: "Smith",
  },
  customer_billing_detail: {
    address_line1: "1 Somewhere Lane"
  }
});

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

var customer = new gocardless.BillingRequests.CollectCustomerDetailsRequest.BillingRequestCustomer
{
  Email = "alice@example.com",
  GivenName = "Alice",
  FamilyName = "Smith",
};

var customerBillingDetail = = new gocardless.BillingRequests.CollectCustomerDetailsRequest.BillingRequestCustomerBillingDetail
{
  AddressLine1 = "1 Somewhere Lane",
};

var resp = await gocardless.BillingRequests.CollectCustomerDetails("BR123",
  new BillingRequestCollectCustomerDetailsRequest
  {
    Customer = customer,
    CustomerBillingDetail = customerBillingDetail,
  });

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  billingRequestCollectCustomerDetailsParams := gocardless.BillingRequestCollectCustomerDetailsParams{
    Customer: &gocardless.BillingRequestCollectCustomerDetailsParamsCustomer{
      GivenName:  "Alice",
      FamilyName: "Smith",
      Email:      "alice@example.com",
    },
    CustomerBillingDetail: &gocardless.BillingRequestCollectCustomerDetailsParamsCustomerBillingDetail{
      AddressLine1: "1 Somewhere Lane",
    },
  }
  
  billingRequest, err := client.BillingRequests.CollectCustomerDetails(context, "BR123", billingRequestCollectCustomerDetailsParams)

}

POST https://api.gocardless.com/billing_requests/BRQ123/actions/collect_bank_account HTTP/1.1
Content-Type: application/json
{
  "data": {
    "account_number": "55779911",
    "branch_code": "200000",
    "account_holder_name": "Frank Osborne",
    "country_code": "GB"
  }
}

HTTP/1.1 200
Content-Type: application/json
{
    "billing_requests": {
        "id": "BRQ123",
        "created_at": "2021-03-22T12:20:04.397Z",
        "status": "pending",
        "mandate_request": {
            "currency": "GBP",
            "scheme": "bacs",
            "links": {}
        },
        "payment_request": {
            "description": "First Payment",
            "currency": "GBP",
            "amount": 500,
            "scheme": "faster_payments",
            "links": {}
        },
        "metadata": null,
        "links": {
          "customer": "CU123",
          "customer_bank_account": "BA123",
          "creditor": "CR123",
          "mandate_request": "MRQ123"
        },
        "creditor_name": "Mr Creditor",
        "actions": [
            {
                "type": "choose_currency",
                "required": true,
                "completes_actions": [],
                "requires_actions": [],
                "status": "completed"
            },
            {
                "type": "collect_customer_details",
                "required": true,
                "completes_actions": [],
                "requires_actions": [
                    "choose_currency"
                ],
                "status": "pending",
                "collect_customer_details": {
                    "incomplete_fields": {
                        "customer": [
                            "email",
                            "given_name",
                            "family_name"
                        ],
                        "customer_billing_detail": [
                            "address_line1",
                            "city",
                            "postal_code",
                            "country_code"
                        ]
                    }
                }
            },
            {
              "type": "select_institution",
              "required": false,
              "completes_actions": [],
              "requires_actions": [],
              "status": "pending"
            },
            {
                "type": "collect_bank_account",
                "required": true,
                "completes_actions": [
                    "choose_currency"
                ],
                "requires_actions": [],
                "status": "pending"
            },
            {
                "type": "bank_authorisation",
                "required": true,
                "completes_actions": [],
                "requires_actions": [
                    "collect_bank_account"
                ],
                "status": "pending"
            }
        ],
        "resources": {
            "customer": {
                "id": "CU123",
                "created_at": "2021-03-22T12:20:04.238Z",
                "email": null,
                "given_name": "Alice",
                "family_name": "Smith",
                "company_name": null,
                "language": "en",
                "phone_number": null,
                "metadata": {}
            },
            "customer_bank_account": {
                "id": "BA123",
                "created_at": "2014-05-08T17:01:06.000Z",
                "account_holder_name": "Frank Osborne",
                "account_number_ending": "11",
                "country_code": "GB",
                "currency": "GBP",
                "bank_name": "BARCLAYS BANK PLC",
                "metadata": {},
                "enabled": true,
                "links": {
                  "customer": "CU123"
                }
            }
        }
    }
}

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

$client->billingRequests()->collectBankAccount("BR123", [
  "params" => [
    "account_number" => "55779911",
    "branch_code" => "200000",
    "account_holder_name" => "Frank Osborne",
    "country_code" => "GB"
  ]
]);

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

client.billing_requests.collect_bank_account("BR123", params={
  account_number: "55779911",
  branch_code: "200000",
  account_holder_name: "Frank Osborne",
  country_code: "GB",
})

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

@client.billing_requests.collect_bank_account("BR123", {
  params: {
    account_number: "55779911",
    branch_code: "200000",
    account_holder_name: "Frank Osborne",
    country_code: "GB",
  }
})

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

client.billingRequests().collectBankAccount("BR123")
  .withAccountNumber("55779911")
  .withBranchCode("200000")
  .withAccountHolderName("Frank Osborne")
  .withCountryCode("GB")
  .execute();

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

const resp = await client.billingRequests.collectBankAccount("BR123", {
  account_number: "55779911",
  branch_code: "200000",
  account_holder_name: "Frank Osborne",
  country_code: "GB",
});

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

var resp = await gocardless.BillingRequests.CollectBankAccountAsync("BR123",
  new BillingRequestCollectBankAccountRequest
  {
    AccountNumber = "55779911",
    BranchCode = "200000",
    AccountHolderName = "Frank Osborne",
    CountryCode = "GB",
  });

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  billingRequestCollectBankAccountParams := gocardless.BillingRequestCollectBankAccountParams{
    BranchCode:        "200000",
    CountryCode:       "GB",
    AccountNumber:     "55779911",
    AccountHolderName: "Frank Osborne",
  }
  
  billingRequest, err := client.BillingRequests.CollectBankAccount(context, "BR123", billingRequestCollectBankAccountParams)

}

POST https://api.gocardless.com/billing_requests/BRQ123/actions/confirm_payer_details HTTP/1.1

HTTP/1.1 200
Content-Type: application/json
{
    "billing_requests": {
        "id": "BRQ123",
        "created_at": "2021-03-22T12:20:04.397Z",
        "status": "ready_to_fulfil",
        "mandate_request": {
            "currency": "GBP",
            "scheme": "bacs",
            "links": {}
        },
        "payment_request": null
        "metadata": null,
        "links": {
            "customer": "CU123",
            "customer_bank_account": "BA123",
            "creditor": "CR123",
            "mandate_request": "MRQ123"
        },
        "creditor_name": "Mr Creditor",
        "actions": [
            {
                "type": "choose_currency",
                "required": true,
                "completes_actions": [],
                "requires_actions": [],
                "status": "completed"
            },
            {
                "type": "collect_customer_details",
                "required": true,
                "completes_actions": [],
                "requires_actions": [
                    "choose_currency"
                ],
                "status": "completed"
            },
            {
                "type": "collect_bank_account",
                "required": true,
                "completes_actions": [
                    "choose_currency"
                ],
                "requires_actions": [],
                "status": "completed"
            },
            {
                "type": "confirm_payer_details",
                "required": true,
                "completes_actions": [],
                "requires_actions": [
                    "collect_customer_details",
                    "collect_bank_account"
                ],
                "status": "completed"
            }
        ],
        "resources": {
            "customer": {
                "id": "CU123",
                "created_at": "2021-03-22T12:20:04.238Z",
                "email": null,
                "given_name": "Alice",
                "family_name": "Smith",
                "company_name": null,
                "language": "en",
                "phone_number": null,
                "metadata": {}
            },
            "customer_bank_account": {
                "id": "BA123",
                "created_at": "2022-11-01T16:30:37.969Z",
                "account_number_ending": "11",
                "account_holder_name": "HOME LOAN ACCOUNT",
                "account_type": null,
                "bank_name": "BARCLAYS BANK PLC",
                "currency": "GBP",
                "country_code": "GB",
                "metadata": {},
                "enabled": true,
                "links": {
                    "customer": "CU123"
                },
                "branch_code_ending": "00"
            }
        }
    }
}

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

$client->billingRequests()->confirmPayerDetails("BR123");

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

client.billing_requests.confirm_payer_details("BR123")

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

@client.billing_requests.confirm_payer_details("BR123")

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

client.billingRequests().confirmPayerDetails("BR123").execute();

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

const resp = await client.billingRequests.confirmPayerDetails("BR123");

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

var resp = await gocardless.BillingRequests.ConfirmPayerDetailsAsync("BR123");

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  BillingRequestConfirmPayerDetailsParams := gocardless.BillingRequestConfirmPayerDetailsParams{}
  billingRequest, err := client.BillingRequests.ConfirmPayerDetails(context, "BR123", BillingRequestConfirmPayerDetailsParams)

}

POST https://api.gocardless.com/billing_requests/BRQ123/actions/fulfil HTTP/1.1

HTTP/1.1 200
Content-Type: application/json
{
    "billing_requests": {
        "id": "BRQ123",
        "created_at": "2021-03-22T12:20:04.397Z",
        "status": "fulfilled",
        "mandate_request": {
            "currency": "GBP",
            "scheme": "bacs",
            "links": {
              "mandate": "MD123"
            }
        },
        "payment_request": {
            "description": "First Payment",
            "currency": "GBP",
            "amount": 500,
            "scheme": "faster_payments",
            "links": {
              "payment": "PM123"
            }
        },
        "metadata": null,
        "links": {
            "customer": "CU123",
            "customer_billing_detail": "CBD123"
        },
        "creditor_name": "Mr Creditor",
        "actions": [],
        "resources": {
            "customer": {
                "id": "CU123",
                "created_at": "2021-03-22T12:20:04.238Z",
                "email": null,
                "given_name": "Alice",
                "family_name": "Smith",
                "company_name": null,
                "language": "en",
                "phone_number": null,
                "metadata": {}
            },
            "customer_billing_detail": {
                "id": "CBD123",
                "created_at": "2021-03-22T12:20:04.374Z",
                "address_line1": "1 Somewhere Lane",
                "address_line2": null,
                "address_line3": null,
                "city": null,
                "region": null,
                "postal_code": null,
                "country_code": null,
                "swedish_identity_number": null,
                "danish_identity_number": null
            }
        }
    }
}

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

$client->billingRequests()->fulfil("BR123");

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

client.billing_requests.fulfil("BR123")

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

@client.billing_requests.fulfil("BR123")

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

client.billingRequests().fulfil("BR123").execute();

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

const resp = await client.billingRequests.fulfil("BR123");

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

var resp = await gocardless.BillingRequests.FulfilAsync("BR123");

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  billingRequestFulfilParams := gocardless.BillingRequestFulfilParams{}
  billingRequest, err := client.BillingRequests.Fulfil(context, "BR123", billingRequestFulfilParams)

}

POST https://api.gocardless.com/billing_requests/BRQ123/actions/cancel HTTP/1.1

HTTP/1.1 200
Content-Type: application/json
{
    "billing_requests": {
        "id": "BRQ123",
        "created_at": "2021-03-22T12:20:04.397Z",
        "status": "cancelled",
        "mandate_request": {
            "currency": "GBP",
            "scheme": "bacs",
            "links": {}
        },
        "payment_request": {
            "description": "First Payment",
            "currency": "GBP",
            "amount": 500,
            "scheme": "faster_payments",
            "links": {}
        },
        "metadata": null,
        "links": {
            "customer": "CU123",
            "customer_billing_detail": "CBD123"
        },
        "creditor_name": "Mr Creditor",
        "actions": [],
        "resources": {
            "customer": {
                "id": "CU123",
                "created_at": "2021-03-22T12:20:04.238Z",
                "email": null,
                "given_name": "Alice",
                "family_name": "Smith",
                "company_name": null,
                "language": "en",
                "phone_number": null,
                "metadata": {}
            },
            "customer_billing_detail": {
                "id": "CBD123",
                "created_at": "2021-03-22T12:20:04.374Z",
                "address_line1": "1 Somewhere Lane",
                "address_line2": null,
                "address_line3": null,
                "city": null,
                "region": null,
                "postal_code": null,
                "country_code": null,
                "swedish_identity_number": null,
                "danish_identity_number": null
            }
        }
    }
}

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

$client->billingRequests()->cancel("BR123");

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

client.billing_requests.cancel("BR123")

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

@client.billing_requests.cancel("BR123")

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

client.billingRequests().cancel("BR123").execute();

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

const resp = await client.billingRequests.cancel("BR123");

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

var resp = await gocardless.BillingRequests.CancelAsync("BR123");

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  billingRequestCancelParams := gocardless.BillingRequestCancelParams{}
  billingRequest, err := client.BillingRequests.Fulfil(context, "BR123", billingRequestCancelParams)

}

GET https://api.gocardless.com/billing_requests HTTP/1.1

HTTP/1.1 200 OK
Content-Type: application/json
{
  "meta": {
    "cursors": {
      "before": null,
      "after": null
    },
    "limit": 50
  },
  "billing_requests": [
    {
       "id": "BRQ123",
       "created_at": "2021-03-22T16:23:48.486Z",
       "status": "pending",
       "mandate_request": null,
       "payment_request": {
           "description": "£5 Top Up",
           "currency": "GBP",
           "amount": 500,
           "scheme": "faster_payments",
           "links": {}
       },
       "metadata": null,
       "links": {
           "customer": "CU123",
           "customer_billing_detail": "CBD123",
           "customer_bank_account": "BA123"
       }
     }
   ]
}

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

$client->billingRequests()->list();

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

client.billing_requests.list().records

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

@client.billing_requests.list

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

for (BillingRequest billingRequest : client.billingRequests().all().execute()) {
  System.out.println(billingRequest.getId());
}

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

const billingRequests = await client.billingRequests.list();

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

var billingRequestListResponse = gocardless.BillingRequests.All();
foreach (GoCardless.Resources.BillingRequest billingRequest in billingRequestListResponse)
{
    Console.WriteLine(billingRequest.Id);
}

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  billingRequestListParams := gocardless.BillingRequestListParams{}
  billingRequestListResult, err :=  client.BillingRequests.List(context, billingRequestListParams)
  for _, billingRequest := range billingRequestListResult.BillingRequests {
      fmt.Println(billingRequest.Id)
  }

}

GET https://api.gocardless.com/billing_requests/BRQ123 HTTP/1.1

HTTP/1.1 200
Content-Type: application/json
{
    "billing_requests": {
        "id": "BRQ123",
        "created_at": "2021-03-22T12:20:04.397Z",
        "status": "pending",
        "mandate_request": {
            "currency": "GBP",
            "scheme": "bacs",
            "links": {}
        },
        "payment_request": {
            "description": "First Payment",
            "currency": "GBP",
            "amount": 500,
            "scheme": "faster_payments",
            "links": {}
        },
        "metadata": null,
        "links": {
            "customer": "CU123",
            "customer_billing_detail": "CBD123"
        },
        "creditor_name": "Mr Creditor",
        "actions": [
            {
                "type": "choose_currency",
                "required": true,
                "completes_actions": [],
                "requires_actions": [],
                "status": "completed"
            },
            {
                "type": "collect_customer_details",
                "required": true,
                "completes_actions": [],
                "requires_actions": [
                    "choose_currency"
                ],
                "status": "pending",
                "collect_customer_details": {
                    "incomplete_fields": {
                        "customer": [
                            "email",
                            "given_name",
                            "family_name"
                        ],
                        "customer_billing_detail": [
                            "address_line1",
                            "city",
                            "postal_code",
                            "country_code"
                        ]
                    }
                }
            },
            {
              "type": "select_institution",
              "required": false,
              "completes_actions": [],
              "requires_actions": [],
              "status": "pending"
            },
            {
                "type": "collect_bank_account",
                "required": true,
                "completes_actions": [
                    "choose_currency"
                ],
                "requires_actions": [],
                "status": "pending"
            },
            {
                "type": "bank_authorisation",
                "required": true,
                "completes_actions": [],
                "requires_actions": [
                    "collect_bank_account"
                ],
                "status": "pending"
            }
        ],
        "resources": {
            "customer": {
                "id": "CU123",
                "created_at": "2021-03-22T12:20:04.238Z",
                "email": null,
                "given_name": null,
                "family_name": null,
                "company_name": null,
                "language": "en",
                "phone_number": null,
                "metadata": {}
            },
            "customer_billing_detail": {
                "id": "CBD123",
                "created_at": "2021-03-22T12:20:04.374Z",
                "address_line1": null,
                "address_line2": null,
                "address_line3": null,
                "city": null,
                "region": null,
                "postal_code": null,
                "country_code": null,
                "swedish_identity_number": null,
                "danish_identity_number": null
            }
        }
    }
}

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

$client->billingRequests()->get("BR123");

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

client.billing_requests.get("BR123")

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

@client.billing_requests.get("BR123")

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

client.billingRequests().get("BR123").execute();

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

const resp = await client.billingRequests.find("BR123");

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

var resp = await gocardless.BillingRequests.GetAsync("BR123");

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  billingRequest, err := client.BillingRequests.Get(context, "BR123")

}

POST https://api.gocardless.com/billing_requests/BRQ123/actions/notify HTTP/1.1
Content-Type: application/json
{
  "data": {
    "notification_type": "email",
    "redirect_uri": "https://my-company.com"
  }
}

HTTP/1.1 200
Content-Type: application/json
{
    "billing_requests": {
        "id": "BRQ123",
        "created_at": "2021-03-22T12:20:04.397Z",
        "status": "pending",
        "mandate_request": {
            "currency": "GBP",
            "scheme": "bacs",
            "links": {}
        },
        "payment_request": {
            "description": "First Payment",
            "currency": "GBP",
            "amount": 500,
            "scheme": "faster_payments",
            "links": {}
        },
        "metadata": null,
        "links": {
            "customer": "CU123",
            "customer_billing_detail": "CBD123"
        },
        "creditor_name": "Mr Creditor",
        "actions": [
            {
                "type": "choose_currency",
                "required": true,
                "completes_actions": [],
                "requires_actions": [],
                "status": "completed"
            },
            {
                "type": "collect_customer_details",
                "required": true,
                "completes_actions": [],
                "requires_actions": [
                    "choose_currency"
                ],
                "status": "pending",
                "collect_customer_details": {
                    "incomplete_fields": {
                        "customer": [
                            "email",
                            "given_name",
                            "family_name"
                        ],
                        "customer_billing_detail": [
                            "address_line1",
                            "city",
                            "postal_code",
                            "country_code"
                        ]
                    }
                }
            },
            {
              "type": "select_institution",
              "required": false,
              "completes_actions": [],
              "requires_actions": [],
              "status": "pending"
            },
            {
                "type": "collect_bank_account",
                "required": true,
                "completes_actions": [
                    "choose_currency"
                ],
                "requires_actions": [],
                "status": "pending"
            },
            {
                "type": "bank_authorisation",
                "required": true,
                "completes_actions": [],
                "requires_actions": [
                    "collect_bank_account"
                ],
                "status": "pending"
            }
        ],
        "resources": {
            "customer": {
                "id": "CU123",
                "created_at": "2021-03-22T12:20:04.238Z",
                "email": null,
                "given_name": "Alice",
                "family_name": "Smith",
                "company_name": null,
                "language": "en",
                "phone_number": null,
                "metadata": {}
            },
            "customer_billing_detail": {
                "id": "CBD123",
                "created_at": "2021-03-22T12:20:04.374Z",
                "address_line1": "1 Somewhere Lane",
                "address_line2": null,
                "address_line3": null,
                "city": null,
                "region": null,
                "postal_code": null,
                "country_code": null,
                "swedish_identity_number": null,
                "danish_identity_number": null
            }
        }
    }
}

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

$client->billingRequests()->notify("BR123", [
  "params" => [
    "notification_type" => "email",
    "redirect_uri" => "https://my-company.com"
  ]
]);

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

client.billing_requests.notify("BR123", params={
  notification_type: "email",
  redirect_uri: "https://my-company.com",
})

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

@client.billing_requests.notify("BR123", {
  params: {
    notification_type: "email",
    redirect_uri: "https://my-company.com",
  }
})

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

client.billingRequests().notify("BR123")
  .withNotificationType("email")
  .withRedirectUri("https://my-company.com")
  .execute();

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

const resp = await client.billingRequests.notify("BR123", {
  notification_type: "email",
  redirect_uri: "https://my-company.com",
});

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

var resp = await gocardless.BillingRequests.NotifyAsync("BR123",
  new BillingRequestNotifyRequest
  {
    NotificationType = "email",
    RedirectUri = "https://my-company.com",
  });

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  billingRequestNotifyParams := gocardless.BillingRequestNotifyParams{
    NotificationType: "email",
    RedirectUri:      "https://my-company.com",
  }
  
  billingRequest, err := client.BillingRequests.Fulfil(context, "BR123", billingRequestNotifyParams)

}

POST https://api.gocardless.com/billing_requests/BRQ123/actions/fallback HTTP/1.1

HTTP/1.1 200
Content-Type: application/json
{
    "billing_requests": {
        "id": "BRQ123",
        "created_at": "2021-03-22T12:20:04.397Z",
        "status": "pending",
        "mandate_request": {
            "currency": "GBP",
            "scheme": "bacs",
            "links": {}
        },
        "payment_request": {
            "description": "First Payment",
            "currency": "GBP",
            "amount": 500,
            "scheme": "bacs",
            "links": {}
        },
        "metadata": null,
        "links": {
            "customer": "CU123",
            "customer_billing_detail": "CBD123"
        },
        "creditor_name": "Mr Creditor",
        "actions": [
            {
                "type": "choose_currency",
                "required": true,
                "completes_actions": [],
                "requires_actions": [],
                "status": "completed"
            },
            {
                "type": "collect_customer_details",
                "required": true,
                "completes_actions": [],
                "requires_actions": [
                    "choose_currency"
                ],
                "status": "pending",
                "collect_customer_details": {
                    "incomplete_fields": {
                        "customer": [
                            "email",
                            "given_name",
                            "family_name"
                        ],
                        "customer_billing_detail": [
                            "address_line1",
                            "city",
                            "postal_code",
                            "country_code"
                        ]
                    }
                }
            },
            {
              "type": "select_institution",
              "required": false,
              "completes_actions": [],
              "requires_actions": [],
              "status": "completed"
            },
            {
                "type": "collect_bank_account",
                "required": true,
                "completes_actions": [
                    "choose_currency"
                ],
                "requires_actions": [],
                "status": "pending"
            }
        ],
        "resources": {
            "customer": {
                "id": "CU123",
                "created_at": "2021-03-22T12:20:04.238Z",
                "email": null,
                "given_name": "Alice",
                "family_name": "Smith",
                "company_name": null,
                "language": "en",
                "phone_number": null,
                "metadata": {}
            },
            "customer_billing_detail": {
                "id": "CBD123",
                "created_at": "2021-03-22T12:20:04.238Z",
                "address_line1": null,
                "address_line2": null,
                "address_line3": null,
                "city": null,
                "region": null,
                "postal_code": null,
                "country_code": null,
                "swedish_identity_number": null,
                "danish_identity_number": null
            }
      },
      "fallback_enabled": true,
      "fallback_occurred": true
  }
}

POST https://api.gocardless.com/billing_requests/BRQ123/actions/select_institution HTTP/1.1
Content-Type: application/json
{
  "data": {
    "institution": "monzo",
    "country_code": "GB"
  }
}

HTTP/1.1 200
Content-Type: application/json
{
    "billing_requests": {
        "id": "BRQ123",
        "created_at": "2021-03-22T12:20:04.397Z",
        "status": "pending",
        "mandate_request": {
            "currency": "GBP",
            "scheme": "bacs",
            "links": {}
        },
        "payment_request": {
            "description": "First Payment",
            "currency": "GBP",
            "amount": 500,
            "scheme": "faster_payments",
            "links": {}
        },
        "metadata": null,
        "links": {
            "customer": "CU123",
            "customer_billing_detail": "CBD123"
        },
        "creditor_name": "Mr Creditor",
        "actions": [
            {
                "type": "choose_currency",
                "required": true,
                "completes_actions": [],
                "requires_actions": [],
                "status": "completed"
            },
            {
                "type": "collect_customer_details",
                "required": true,
                "completes_actions": [],
                "requires_actions": [
                    "choose_currency"
                ],
                "status": "pending",
                "collect_customer_details": {
                    "incomplete_fields": {
                        "customer": [
                            "email",
                            "given_name",
                            "family_name"
                        ],
                        "customer_billing_detail": [
                            "address_line1",
                            "city",
                            "postal_code",
                            "country_code"
                        ]
                    }
                }
            },
            {
              "type": "select_institution",
              "required": false,
              "completes_actions": [],
              "requires_actions": [],
              "status": "completed"
            },
            {
                "type": "collect_bank_account",
                "required": true,
                "completes_actions": [
                    "choose_currency"
                ],
                "requires_actions": [],
                "status": "pending"
            },
            {
                "type": "bank_authorisation",
                "required": true,
                "completes_actions": [],
                "requires_actions": [
                    "collect_bank_account"
                ],
                "status": "pending"
            }
        ],
        "resources": {
            "customer": {
                "id": "CU123",
                "created_at": "2021-03-22T12:20:04.238Z",
                "email": null,
                "given_name": "Alice",
                "family_name": "Smith",
                "company_name": null,
                "language": "en",
                "phone_number": null,
                "metadata": {}
            },
            "customer_billing_detail": {
                "id": "CBD123",
                "created_at": "2021-03-22T12:20:04.374Z",
                "address_line1": "1 Somewhere Lane",
                "address_line2": null,
                "address_line3": null,
                "city": null,
                "region": null,
                "postal_code": null,
                "country_code": null,
                "swedish_identity_number": null,
                "danish_identity_number": null
            },
            "institution": {
                "id": "monzo",
                "name": "Monzo",
                "icon_url": "https://images.example.com/image/332bb781-3cc2-4f3e-ae79-1aba09fac991?size",
                "roles": ["institutions_list", "heartbeat", "read_refund_account", "read_debtor_account"],
                "country_code": "GB"
            }
        }
    }
}

POST https://api.gocardless.com/billing_request_flows HTTP/1.1
Content-Type: application/json
{
  "billing_request_flows": {
    "redirect_uri": "https://my-company.com/landing",
    "exit_uri": "https://my-company.com/exit",
    "prefilled_customer": {
      "given_name": "Frank",
      "family_name": "Osborne",
      "email": "frank.osborne@acmeplc.com"
    },
    "links": {
      "billing_request": "BRQ123"
    }
  }
}

HTTP/1.1 201 Created
Location: /billing_request_flows/BRF123456
Content-Type: application/json
{
  "billing_request_flows": {
    "id": "BRF123456",
    "auto_fulfil": true,
    "redirect_uri": "https://my-company.com/landing",
    "exit_uri": "https://my-company.com/exit",
    "authorisation_url": "https://pay.gocardless.com/billing/static/flow?id=BRF123456",
    "lock_customer_details": false,
    "lock_currency": false,
    "lock_bank_account": false,
    "skip_success_screen": false,
    "session_token": null,
    "expires_at": "2021-07-30T16:25:16.982Z",
    "created_at": "2021-07-23T16:25:16.983Z",
    "links": {
      "billing_request": "BRQ123"
    },
    "show_redirect_buttons": false,
    "show_success_redirect_button": false,
    "customer_details_captured": false,
  }
}

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

$client->billingRequestFlows()->create([
  "params" => [
    "redirect_uri" => "https://my-company.com/landing",
    "exit_uri" => "https://my-company.com/exit",
    "prefilled_customer" => [
      "given_name" => "Frank",
      "family_name" => "Osborne",
      "email" => "frank.osborne@acmeplc.com"
    ],
    "links" => [
      "billing_request" => "BRQ123"
    ]
  ]
]);

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

client.billing_request_flows.create(params={
  "redirect_uri": "https://my-company.com/landing",
  "exit_uri": "https://my-company.com/exit",
  "prefilled_customer": {
      "given_name": "Frank",
      "family_name": "Osborne",
      "email": "frank.osborne@acmeplc.com"
  },
  "links": {
    "billing_request": "BRQ123"
  }
})

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

@client.billing_request_flows.create(
  params: {
    redirect_uri: "https://my-company.com/landing",
    exit_uri: "https://my-company.com/exit",
    prefilled_customer: {
      given_name: "Frank",
      family_name: "Osborne",
      email: "frank.osborne@acmeplc.com"
    },
    links: {
      billing_request: "BRQ123",
    }
  }
)

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

BillingRequestFlow billingRequestFlow = client.billingRequestFlows().create()
  .withRedirectUri("https://my-company.com/landing")
  .withExitUri("https://my-company.com/exit")
  .withPrefilledCustomerGivenName("Frank")
  .withPrefilledCustomerFamilyName("Osborne")
  .withPrefilledCustomerEmail("frank.osborne@acmeplc.com")
  .withLinksBillingRequest("BRQ123")
  .execute();

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

const billingRequestFlow = await client.billingRequestFlows.create({
  redirect_uri: "https://my-company.com/landing",
  exit_uri: "https://my-company.com/exit",
  prefilled_customer: {
    given_name: "Frank",
    family_name: "Osborne",
    email: "frank.osborne@acmeplc.com"
  },
  links: {
    billing_request: "BRQ123",
  }
});

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

var prefilledCustomer = new GoCardless.Services.RedirectFlowCreateRequest.RedirectFlowPrefilledCustomer()
{
    AddressLine1 = "338 Goswell Road",
    Email = "api@gocardless.com",
    GivenName = "Bobby",
    FamilyName = "Tables"
};

var resp = await gocardless.BillingRequestFlows.CreateAsync(
  new GoCardless.Services.BillingRequestFlowCreateRequest()
  {
    RedirectUri = "https://my-company.com/landing",
    ExitUri = "https://my-company.com/exit",
    PrefilledCustomer = prefilledCustomer,
    Links = new gocardless.BillingRequestFlowCreateRequest.BillingRequestFlowLinks
    {
      BillingRequest = "BRQ123",
    },
  }
);

GoCardless.Resources.BillingRequestFlow billingRequestFlow = resp.BillingRequestFlow;

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  billingRequestFlowCreateParams := gocardless.BillingRequestFlowCreateParams{
    RedirectUri: "https://my-company.com/landing",
    ExitUri:     "https://my-company.com/exit",
    PrefilledCustomer: &gocardless.RedirectFlowCreateParamsPrefilledCustomer{
      AddressLine1: "338-346 Goswell Road",
      City:         "London",
      GivenName:    "Tim",
      FamilyName:   "Rogers",
      Email:        "tim@gocardless.com",
      PostalCode:   "EC1V 7LQ",
    },
    Links: gocardless.BillingRequestFlowCreateParamsLinks{
      BillingRequest: "BR123",
    },
  }
  
  billingRequestFlow, err := client.BillingRequestFlows.Create(context, billingRequestFlowCreateParams)

}

POST https://api.gocardless.com/billing_request_flows/BRF123/actions/initialise HTTP/1.1

HTTP/1.1 200
Content-Type: application/json
{
  "billing_request_flows":{
      "id":"BRF123",
      "auto_fulfil":true,
      "redirect_uri":null,
      "exit_uri":null,
      "authorisation_url":"https://pay-sandbox.gocardless.com/billing/static/flow?id=BRF123",
      "lock_customer_details":false,
      "lock_bank_account":false,
      "lock_currency": false,
      "skip_success_screen": false,
      "session_token":"sesh_sandbox_DHTMvJAUajbd9KTCoXNFcTv4RSoWdMbauhnalxiqwbdsb",
      "expires_at":"2021-09-01T08:45:38.016Z",
      "created_at":"2021-08-25T08:45:38.017Z",
      "links":{
        "billing_request":"BRQ123"
      },
      "show_redirect_buttons": false,
    "show_success_redirect_button": false,
    "customer_details_captured": false,
  }
}

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

$client->billingRequestFlows()->initialise("BRF123");

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

client.billing_request_flows.initialise("BRF123")

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

@client.billing_request_flows.initialise("BRF123")

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

client.billingRequestFlows().initialise("BRF123").execute();

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

const resp = await client.billingRequestFlows.initialise("BRF123");

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

var resp = await gocardless.BillingRequestFlows.InitialiseAsync("BRF123");

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  billingRequestFlowInitialiseParams := gocardless.BillingRequestFlowInitialiseParams{}
  billingRequestFlow, err := client.BillingRequestFlows.Initialise(context, "BRF123", billingRequestFlowInitialiseParams)

}

GET https://api.gocardless.com/billing_request_templates HTTP/1.1

HTTP/1.1 200 OK
Content-Type: application/json
{
  "meta": {
    "cursors": {
      "before": null,
      "after": null
    },
    "limit": 50
  },
  "billing_request_templates": [
    {
      "id": "BRT123",
      "name": "12 Month Gold Plan",
      "mandate_request_currency": "GBP",
      "mandate_request_scheme": null,
      "mandate_request_verify": null,
      "mandate_request_metadata": null,
      "payment_request_description": "One-time joining fee",
      "mandate_request_description": "Recurring fee",
      "payment_request_amount": "69.99",
      "payment_request_currency": "GBP",
      "payment_request_scheme": null,
      "payment_request_metadata": null,
      "redirect_uri": "https://my-company.com/landing",
      "authorisation_url": "https://pay.gocardless.com/BRT123",
      "metadata": {
        "checkout-flow": "primary"
      },
      "created_at": "2021-07-27T17:10:33.784Z",
      "updated_at": "2021-07-27T17:10:33.784Z"
    }
  ]
}

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

$client->billingRequestTemplates()->list();

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

client.billing_request_templates.list().records

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

@client.billing_request_templates.list

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

for (BillingRequestTemplate billingRequestTemplate : client.billingRequestTemplates().all().execute()) {
  System.out.println(billingRequestTemplate.getId());
}

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

const billingRequestTemplates = await client.billingRequestTemplates.list();

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

var billingRequestTemplateListResponse = gocardless.BillingRequestTemplates.All();
foreach (GoCardless.Resources.BillingRequestTemplate billingRequestTemplate in billingRequestTemplateListResponse)
{
    Console.WriteLine(billingRequestTemplate.Id);
}

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  billingRequestTemplateListParams := gocardless.BillingRequestTemplateListParams{}
  billingRequestTemplateListResult, err := client.BillingRequestTemplates.List(context, billingRequestTemplateListParams)
  for _, billingRequestTemplate := range billingRequestTemplateListResult.BillingRequestTemplates {
      fmt.Println(billingRequestTemplate.Id)
  }

}

GET https://api.gocardless.com/billing_request_templates/BRT123 HTTP/1.1

HTTP/1.1 200
Content-Type: application/json
{
  "billing_request_templates": {
    "id": "BRT123",
    "name": "12 Month Gold Plan",
    "mandate_request_currency": "GBP",
    "mandate_request_scheme": null,
    "mandate_request_verify": null,
    "mandate_request_metadata": null,
    "payment_request_description": "One-time joining fee",
    "mandate_request_description": "Recurring fee",
    "payment_request_amount": "69.99",
    "payment_request_currency": "GBP",
    "payment_request_scheme": null,
    "payment_request_metadata": null,
    "redirect_uri": "https://my-company.com/landing",
    "authorisation_url": "https://pay.gocardless.com/BRT123",
    "metadata": {
      "checkout-flow": "primary"
    },
    "created_at": "2021-07-27T17:10:33.784Z",
    "updated_at": "2021-07-27T17:10:33.784Z"
  }
}

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

$client->billingRequestTemplates()->get("BRT123");

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

client.billing_request_templates.get("BRT123")

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

@client.billing_request_templates.get("BRT123")

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

client.billingRequestTemplates().get("BRT123").execute();

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

const resp = await client.billingRequestTemplates.find("BRT123");

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

var resp = await gocardless.BillingRequestTemplates.GetAsync("BRT123");

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  billingRequestTemplate, err := client.BillingRequestTemplates.Get(context, "BRT123")

}

POST https://api.gocardless.com/billing_request_templates HTTP/1.1
Content-Type: application/json
{
  "billing_request_templates": {
    "name": "12 Month Gold Plan",
    "payment_request_description": "One-time joining fee",
    "mandate_request_description": "Recurring fee",
    "payment_request_currency": "GBP",
    "payment_request_amount": "69.99",
    "mandate_request_currency": "GBP",
    "redirect_uri": "https://my-company.com/landing",
    "metadata": {
      "checkout-flow": "primary"
    }
  }
}

HTTP/1.1 201 Created
Location: /billing_request_templates/BRT123
Content-Type: application/json
{
  "billing_request_templates": {
    "id": "BRT123",
    "name": "12 Month Gold Plan",
    "mandate_request_currency": "GBP",
    "mandate_request_scheme": null,
    "mandate_request_verify": null,
    "mandate_request_metadata": null,
    "payment_request_description": "One-time joining fee",
    "mandate_request_description": "Recurring fee",
    "payment_request_amount": "69.99",
    "payment_request_currency": "GBP",
    "payment_request_scheme": null,
    "payment_request_metadata": null,
    "redirect_uri": "https://my-company.com/landing",
    "authorisation_url": "https://pay.gocardless.com/BRT123",
    "metadata": {
      "checkout-flow": "primary"
    },
    "created_at": "2021-07-27T17:10:33.784Z",
    "updated_at": "2021-07-27T17:10:33.784Z"
  }
}

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

$client->billingRequestTemplates()->create([
  "params" => [
    "name" => "12 Month Gold Plan",
    "payment_request_description" => "One-time joining fee",
    "mandate_request_description" => "Recurring fee",
    "payment_request_currency" => "GBP",
    "payment_request_amount" => "69.99",
    "mandate_request_currency" => "GBP",
    "redirect_uri" => "https://my-company.com/landing",
  ]
]);

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

client.billing_request_templates.create(params={
  "name": "12 Month Gold Plan",
  "payment_request_description": "One-time joining fee",
  "mandate_request_description": "Recurring fee",
  "payment_request_currency": "GBP",
  "payment_request_amount": "69.99",
  "mandate_request_currency": "GBP",
  "redirect_uri": "https://my-company.com/landing",
})

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

@client.billing_request_templates.create(
  params: {
    name: "12 Month Gold Plan",
    payment_request_description: "One-time joining fee",
    mandate_request_description: "Recurring fee",
    payment_request_currency: "GBP",
    payment_request_amount: "69.99",
    mandate_request_currency: "GBP",
    redirect_uri: "https://my-company.com/landing",
  }
)

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

BillingRequestTemplate billingRequestTemplate = client.billingRequestTemplates().create()
  .withPaymentRequestDescription("One-time joining fee")
  .withPaymentRequestCurrency("GBP")
  .withPaymentRequestAmount("69.99")
  .withMandateRequestCurrency("GBP")
  .withRedirectUri("https://my-company.com/landing")
  .execute();

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

const billingRequestTemplate = await client.billingRequestTemplates.create({
  name: "12 Month Gold Plan",
  payment_request_description: "One-time joining fee",
  mandate_request_description: "Recurring fee",
  payment_request_currency: "GBP",
  payment_request_amount: "69.99",
  mandate_request_currency: "GBP",
  redirect_uri: "https://my-company.com/landing",
});

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

var resp = await gocardless.BillingRequestTemplates.CreateAsync(
  new GoCardless.Services.BillingRequestTemplateCreateRequest()
  {
    PaymentRequestDescription = "One-time joining fee",
    PaymentRequestCurrency = "GBP",
    PaymentRequestAmount = 6999,
    MandateRequestCurrency = "GBP",
    RedirectUri = "https://my-company.com/landing",
  }
);

GoCardless.Resources.BillingRequestTemplate billingRequestTemplate = resp.BillingRequestTemplate;

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  billingRequestTemplateCreateParams := gocardless.BillingRequestTemplateCreateParams{
    Name:                      "12 Month Gold Plan",
    PaymentRequestDescription: "One-time joining fee",
    PaymentRequestCurrency:    "GBP",
    PaymentRequestAmount:      6999,
    MandateRequestCurrency:    "GBP",
    RedirectUri:               "https://my-company.com/landing",
  }
  
  billingRequestTemplate, err := client.BillingRequestTemplates.Create(context, billingRequestTemplateCreateParams)

}

PUT https://api.gocardless.com/billing_request_templates/BRT123 HTTP/1.1
Content-Type: application/json
{
  "billing_request_templates": {
    "name": "12 Month Silver Plan",
    "payment_request_amount": "49.99"
  }
}

HTTP/1.1 200 OK
Location: /billing_request_templates/BRT123
Content-Type: application/json
{
  "billing_request_templates": {
    "id": "BRT123",
    "name": "12 Month Silver Plan",
    "mandate_request_currency": "GBP",
    "mandate_request_scheme": null,
    "mandate_request_verify": null,
    "mandate_request_metadata": null,
    "payment_request_description": "One-time joining fee",
    "mandate_request_description": "Recurring fee",
    "payment_request_amount": "49.99",
    "payment_request_currency": "GBP",
    "payment_request_scheme": null,
    "payment_request_metadata": null,
    "redirect_uri": "https://my-company.com/landing",
    "authorisation_url": "https://pay.gocardless.com/BRT123",
    "metadata": {
      "checkout-flow": "primary"
    },
    "created_at": "2021-07-27T17:10:33.784Z",
    "updated_at": "2021-07-30T11:28:11.123Z"
  }
}

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

$client->billingRequestTemplates()->update("BRT123", [
  "params" => [
    "name" => "12 Month Silver Plan",
    "payment_request_amount" => "49.99"
  ]
]);

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

client.billing_request_templates.update("BRT123", params={
  "name": "12 Month Silver Plan",
  "payment_request_amount": "49.99",
})

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

@client.billing_request_templates.update("BRT123", params: {
  name: "12 Month Silver Plan",
  payment_request_amount: "49.99",
})

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

BillingRequestTemplate billingRequestTemplate = client.billingRequestTemplates().update("BRT123")
  .withName("12 Month Silver Plan")
  .withPaymentRequestAmount("49.99")
  .execute();

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

const billingRequestTemplate = await client.billingRequestTemplates.update({
  name: "12 Month Silver Plan",
  payment_request_amount: "49.99",
});

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

var resp = await gocardless.BillingRequestTemplates.UpdateAsync(
  "BRT123",
  new GoCardless.Services.BillingRequestTemplateUpdateRequest()
  {
    Name = "12 Month Silver Plan",
    PaymentRequestAmount = 4999,
  }
);

GoCardless.Resources.BillingRequestTemplate billingRequestTemplate = resp.BillingRequestTemplate;

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  billingRequestTemplateUpdateParams := gocardless.BillingRequestTemplateUpdateParams{
    Name:                 "12 Month Silver Plan",
    PaymentRequestAmount: 4999,
  }
  
  billingRequestTemplate, err := client.BillingRequestTemplates.Update(context, "BRT123", billingRequestTemplateUpdateParams)

}

GET https://api.gocardless.com/institutions?country_code=GB HTTP/1.1

HTTP/1.1 200 OK
Content-Type: application/json
{
  "institutions": [
    {
      "id": "monzo",
      "name": "Monzo",
      "logo_url": "https://assets.gocardless.com/icon",
      "icon_url": "https://assets.gocardless.com/icon",
      "country_code": "GB"
    }
  ]
}

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

$client->institutions()->list([
  "params" => ["country_code" => "GB"]
]);

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

@client.institutions.list(params={"country_code": "GB" }).records

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

@client.institutions.list(params: { country_code: "GB" })

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

Institution institution = client.institutions().all().withCountryCode("GB").execute();

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

// List of all institutions.
const institutions = await client.institutions.list();

// List of institutions for a country code.
const institutions = await client.institutions.list({ countryCode: 'GB'});

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

// List of institutions for a country code.
var request = new GoCardless.Services.InstitutionListRequest()
 {
     CountryCode = "GB",
 };

var institutionListResponse = gocardless.Institutions.All(request);

// List of all institutions.
var institutionListResponse = gocardless.Institutions.All();

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  institutionListParams := gocardless.InstitutionListParams{}
  institutionListResult, err := client.Institutions().List(context, institutionListParams)
  for _, institution := range institutionListResult.Institutions {
      fmt.Println(institution.Id)
  }

}

GET https://api.gocardless.com/billing_requests/BRQ123/institutions?country_code=GB HTTP/1.1

HTTP/1.1 200
Content-Type: application/json
{
  "institutions": [
    {
        "id": "BANK_OF_SCOTLAND_BUSINESS_BOFSGBS1",
        "name": "Bank of Scotland Business",
        "logo_url": "https://cdn-logos.gocardless.com/ais/BANK_OF_SCOTLAND_BUSINESS_BOFSGBS1.png",
        "icon_url": "https://cdn-logos.gocardless.com/ais/BANK_OF_SCOTLAND_BUSINESS_BOFSGBS1.png",
        "country_code": "GB",
        "autocompletes_collect_bank_account": true
    },
    {
        "id": "BANK_OF_SCOTLAND_BOFSGBS1",
        "name": "Bank of Scotland Personal",
        "logo_url": "https://cdn-logos.gocardless.com/ais/BANK_OF_SCOTLAND_BUSINESS_BOFSGBS1.png",
        "icon_url": "https://cdn-logos.gocardless.com/ais/BANK_OF_SCOTLAND_BUSINESS_BOFSGBS1.png",
        "country_code": "GB",
        "autocompletes_collect_bank_account": true
    }
  ]
}

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

$client->institutions()->listForBillingRequest("BR123", [
  "params" => ["country_code" => "GB"]
]);

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

@client.institutions.listForBillingRequest("BR123", params={
  "country_code": "GB"
}).records

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

@client.institutions.listForBillingRequest("BR123", {
  params: { country_code: "GB" }
})

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

client.institutions().listForBillingRequest("BR123").withCountryCode("GB").execute();

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

const institutions = await client.institutions.list_for_billing_request("BR123", { countryCode: 'GB'});

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

var request = new GoCardless.Services.InstitutionListForBillingRequestRequest()
 {
     CountryCode = "GB",
 };

var institutionListResponse = await gocardless.Institutions.ListForBillingRequestAsync("BR123", request);

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  institutionListForBillingRequestParams := gocardless.InstitutionListForBillingRequestParams{
    CountryCode: "GB",
  }
  institutionListForBillingRequestResult, err := client.Institutions().ListForBillingRequest(context, "BR123", institutionListForBillingRequestParams)
  for _, institution := range institutionListForBillingRequestResult.Institutions {
      fmt.Println(institution.Id)
  }

}

POST https://api.gocardless.com/blocks HTTP/1.1
Content-Type: application/json
{
  "blocks": {
    "block_type": "email",
    "reason_type": "no_intent_to_pay",
    "resource_reference": "example@example.com"
  }
}

HTTP/1.1 201 Created
Location: /block/BLC123
Content-Type: application/json
{
  "blocks": {
    "id": "BLC123",
    "block_type": "email",
    "reason_type": "no_intent_to_pay",
    "resource_reference": "example@example.com",
    "active": "true",
    "created_at": "2021-03-25T17:26:28.305Z",
    "updated_at": "2021-03-25T17:26:28.305Z"
  }
}

POST https://api.gocardless.com/blocks HTTP/1.1
Content-Type: application/json
{
  "blocks": {
    "block_type": "bank_account",
    "reason_type": "no_intent_to_pay",
    "resource_reference": "BA123"
  }
}

HTTP/1.1 201 Created
Location: /block/BLC456
Content-Type: application/json
{
  "blocks": {
    "id": "BLC456",
    "block_type": "bank_account",
    "reason_type": "no_intent_to_pay",
    "resource_reference": "BA123",
    "active": "true",
    "created_at": "2021-03-25T17:26:28.305Z",
    "updated_at": "2021-03-25T17:26:28.305Z"
  }
}

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

$block = $client->blocks()->create([
  "params" => [
      "block_type" => "email",
      "reason_type" => "no_intent_to_pay",
      "resource_reference" => "example@example.com",
  ]
]);

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

block = client.blocks.create(
  params={
    "block_type": "email",
    "reason_type": "no_intent_to_pay",
    "resource_reference": "example@example.com"
  }
)

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

block = @client.blocks.create(
  params: {
    block_type: "email",
    reason_type: "no_intent_to_pay",
    resource_reference: "example@example.com"
  }
)

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

Block block = client.blocks().create()
  .withBlockType(Block.BlockType.EMAIL)
  .withReasonType(Block.ReasonType.NO_INTENT_TO_PAY)
  .withResourceReference("example@example.com")
  .execute();

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

const block = await client.blocks.create({
  block_type: Types.BlockBlockType.Email,
  resource_reference: 'CU123',
  reason_type: Types.BlockReasonType.NoIntentToPay,
})

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

var resp = await gocardless.Blocks.CreateAsync(
  new GoCardless.Services.BlockCreateRequest()
  {
      BlockType = GoCardless.Services.BlockCreateRequest.BlockBlockType.Email,
      ReasonType = GoCardless.Services.BlockCreateRequest.BlockReasonType.NoIntentToPay,
      ResourceReference = "example@example.com"
  }
);
GoCardless.Resources.Block block = resp.Block;

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  blockCreateParams := gocardless.BlockCreateParams{
    BlockType:         "email",
    ReasonType:        "no_intent_to_pay",
    ResourceReference: "example@example.com",
  }
  
  block, err := client.Blocks.Create(context, blockCreateParams)

}

GET https://api.gocardless.com/blocks/BLC456 HTTP/1.1

HTTP/1.1 200 OK
Content-Type: application/json
{
  "blocks": {
    "id": "BLC456",
    "block_type": "email",
    "reason_type": "no_intent_to_pay",
    "resource_reference": "example@example.com",
    "active": "true",
    "created_at": "2021-03-25T17:26:28.305Z",
    "updated_at": "2021-03-25T17:26:28.305Z"
  }
}

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

$block = $client->blocks()->get("BLC456");

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

block = client.blocks.get("BLC456")

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

block = @client.blocks.get("BLC456")

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

Block block = client.blocks().get("BLC456").execute();

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

const block = await client.blocks.find("BLC456");

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

var resp = await gocardless.Blocks.GetAsync("BLC456");
GoCardless.Resources.Block block = resp.Block;

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  block, err := client.Blocks.Get(context, "BLC456")

}

GET https://api.gocardless.com/blocks HTTP/1.1

HTTP/1.1 200 OK
Location: /blocks
Content-Type: application/json
{
  "meta": {
    "cursors": {
      "before": null,
      "after": null
    },
    "limit": 50
  },
  "blocks": [
    {
      "id": "BLC123",
      "block_type": "email",
      "reason_type": "no_intent_to_pay",
      "resource_reference": "example@example.com",
      "active": "true",
      "created_at": "2021-03-25T17:26:28.305Z",
      "updated_at": "2021-03-25T17:26:28.305Z"
    },
    {
      "id": "BLC456",
      "block_type": "email_domain",
      "reason_type": "identity_fraud",
      "resource_reference": "example.com",
      "active": "true",
      "created_at": "2021-03-25T17:26:28.305Z",
      "updated_at": "2021-03-25T17:26:28.305Z"
    }
  ]
}

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

foreach ($client->blocks()->all() as $record) {
  echo $record->id;
  echo $record->block_type;
}

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

for block in client.blocks.all():
  print(block.id)
  print(block.block_type)

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

@client.blocks.all.each do |block|
  puts block.id
  puts block.block_type
end

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

for (Block block : client.blocks().all().execute()) {
    System.out.println(block.getId());
    System.out.println(block.getBlockType());
}

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

for await (const block of client.blocks.all({})) {
  console.log(block.id);
  console.log(block.block_type);
}

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

foreach (GoCardless.Resources.Block block in gocardless.Blocks.All())
{
    Console.WriteLine(block.Id);
}

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  blockListParams := gocardless.BlockListParams{}
  blockListResult, err := client.Blocks.List(context, blockListParams)
  for _, block := range blockListResult.Blocks {
      fmt.Println(block.Id)

}

POST https://api.gocardless.com/blocks/BLC123/actions/disable HTTP/1.1

HTTP/1.1 200 OK
Content-Type: application/json
{
  "blocks": {
    "id": "BLC123",
    "block_type": "bank_account",
    "reason_type": "no_intent_to_pay",
    "resource_reference": "BA123",
    "active": "false",
    "created_at": "2021-03-25T17:26:28.305Z",
    "updated_at": "2021-03-25T19:26:28.305Z"
  }
}

POST https://api.gocardless.com/blocks/BLC123/actions/disable HTTP/1.1
HTTP/1.1 409 Conflict

POST https://api.gocardless.com/blocks/MISSING_BLOCK_ID/actions/disable HTTP/1.1
HTTP/1.1 404 NotFound

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

$block = $client->blocks()->disable("BLC123");

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

block = client.blocks.disable("BLC123")

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

block = @client.blocks.disable("BLC123")

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

Block block = client.blocks().disable("BLC123").execute();

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

const block = await client.blocks.disable("BLC456");

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

var resp = await gocardless.Blocks.DisableAsync("BLC123");

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  block, err := client.Blocks.Disable(context, "BLC123")

}

POST https://api.gocardless.com/blocks/BLC123/actions/enable HTTP/1.1

HTTP/1.1 200 OK
Content-Type: application/json
{
  "blocks": {
    "id": "BLC123",
    "block_type": "bank_account",
    "reason_type": "no_intent_to_pay",
    "resource_reference": "BA123",
    "active": "true",
    "created_at": "2021-03-25T17:26:28.305Z",
    "updated_at": "2021-03-25T19:26:28.305Z"
  }
}

POST https://api.gocardless.com/blocks/BLC123/actions/enable HTTP/1.1
HTTP/1.1 409 Conflict

POST https://api.gocardless.com/blocks/MISSING_BLOCK_ID/actions/enable HTTP/1.1
HTTP/1.1 404 NotFound

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

$block = $client->blocks()->enable("BLC123");

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

block = client.blocks.enable("BLC123")

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

block = @client.blocks.enable("BLC123")

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

Block block = client.blocks().enable("BLC123").execute();

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

const block = await client.blocks.enable("BLC456");

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

var resp = await gocardless.Blocks.EnableAsync("BLC123");

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  block, err := client.Blocks.Enable(context, "BLC123")

}

POST https://api.gocardless.com/blocks/block_by_ref HTTP/1.1
Content-Type: application/json
{
  "blocks": {
    "reference_type": "customer",
    "reference_value": "CU123",
    "reason_type": "no_intent_to_pay"
  }
}

HTTP/1.1 201 Created
Content-Type: application/json
{
  "meta": {
    "cursors": {
      "before": null,
      "after": null
    },
    "limit": 50
  },
  "blocks": [
    {
      "id": "BLC123",
      "block_type": "email",
      "reason_type": "no_intent_to_pay",
      "resource_reference": "example@example.com",
      "active": "true",
      "created_at": "2021-03-25T17:26:28.305Z",
      "updated_at": "2021-03-25T17:26:28.305Z"
    },
    {
      "id": "BLC456",
      "block_type": "bank_account",
      "reason_type": "no_intent_to_pay",
      "resource_reference": "BA123",
      "active": "true",
      "created_at": "2021-03-25T17:26:28.305Z",
      "updated_at": "2021-03-25T17:26:28.305Z"
    }
  ]
}

POST https://api.gocardless.com/blocks/block_by_ref HTTP/1.1
Content-Type: application/json
{
  "blocks": {
    "reference_type": "customer",
    "reference_value": "CU123",
    "reason_type": "no_intent_to_pay"
  }
}

HTTP/1.1 200 OK
Content-Type: application/json
{
  "meta": {
    "cursors": {
      "before": null,
      "after": null
    },
    "limit": 50
  },
  "blocks": [
    {
      "id": "BLC123",
      "block_type": "email",
      "reason_type": "no_intent_to_pay",
      "resource_reference": "example@example.com",
      "active": "true",
      "created_at": "2021-03-25T17:26:28.305Z",
      "updated_at": "2021-03-25T17:26:28.305Z"
    },
    {
      "id": "BLC456",
      "block_type": "bank_account",
      "reason_type": "no_intent_to_pay",
      "resource_reference": "BA123",
      "active": "true",
      "created_at": "2021-03-25T17:26:28.305Z",
      "updated_at": "2021-03-25T17:26:28.305Z"
    }
  ]
}

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

$block = $client->blocks()->blockByRef([
  "params" => [
      "reference_type" => "customer",
      "reference_value" => "CU123",
      "reason_type" => "no_intent_to_pay",
  ]
]);

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

response = client.blocks.block_by_ref(
  params={
    "reference_type": "customer",
    "reference_value": "CU123",
    "reason_type": "no_intent_to_pay"
  }
)
blocks = response.records

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

resp = @client.blocks.block_by_ref(
  params: {
    reference_type: "customer",
    reference_value: "CU123"
    reason_type: "no_intent_to_pay",
  }
)
blocks = resp.records

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

Iterable<Block> iterable = client.blocks().blockByRef()
        .withReferenceType("customer")
        .withReferenceValue("CU123")
        .withReasonType("no_intent_to_pay")
        .execute();
List<Block> blocks = Lists.newArrayList(iterable);

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

const response = await client.blocks.block_by_ref(
  {
    reference_type: Types.BlockReferenceType.Customer,
    reference_value: 'CU123',
    reason_type: Types.BlockReasonType.NoIntentToPay
  }
);
const blocks = response.blocks;

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

var resp = await client.Blocks.BlockByRefAsync(new BlockBlockByRefRequest() {
  ReferenceType = "customer",
    ReferenceValue = "CU123",
    ReasonType = "no_intent_to_pay",
});
IReadOnlyList < GoCardless.Resources.Block > blocks = resp.Blocks;

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  blockBlockByRefParams := gocardless.BlockBlockByRefParams{
    ReferenceType: "customer",
    ReferenceValue: "CU123",
    ReasonType: "no_intent_to_pay",
  }
  
  blockBlockByRefResult, err := client.Blocks.BlockByRef(context, blockBlockByRefParams)
  for _, block := range blockBlockByRefResult.Blocks {
      fmt.Println(block.Id)
  }

}

POST https://api.gocardless.com/creditors HTTP/1.1
Content-Type: application/json
{
  "creditors": {
    "name": "Acme",
    "country_code": "GB",
    "creditor_type": "company",
    "bank_reference_prefix": "ACME"
  }
}

HTTP/1.1 201 Created
Location: /creditors/CR123
Content-Type: application/json
{
  "creditors": {
    "id": "CR123",
    "created_at": "2017-02-16T12:34:56.000Z",
    "name": "Acme",
    "address_line1": null,
    "address_line2": null,
    "address_line3": null,
    "city": null,
    "region": null,
    "postal_code": null,
    "country_code": "GB",
    "creditor_type": "company",
    "logo_url": null,
    "scheme_identifiers": [],
    "verification_status": "successful",
    "can_create_refunds": false,
    "fx_payout_currency": null,
    "mandate_imports_enabled": false,
    "custom_payment_pages_enabled": true,
    "merchant_responsible_for_notifications": true,
    "bank_reference_prefix": "ACME",
    "links": {}
  }
}

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

$client->creditors()->create([
  'params' => ['name' => 'Acme',
               'country_code' => 'GB',
               'bank_reference_prefix' => 'ACME',
               'creditor_type' => 'company']
]);

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

client.creditors.create(params={
  "name": "Acme",
  "country_code": "GB",
  "creditor_type": "company",
  "bank_reference_prefix": "ACME",
})

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

@client.creditors.create(
  params: {
    name: "Acme",
    country_code: "GB",
    creditor_type: "company",
    bank_reference_prefix: "ACME",
  }
)

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

Creditor creditor = client.creditors().create()
  .withName("Acme")
  .withCountryCode("GB")
  .withCreditorType("company")
  .withBankReferencePrefix("ACME")
  .execute();

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

const creditor = await client.creditors.create({
  name: "Acme",
  country_code: "GB",
  creditor_type: "company",
  bank_reference_prefix: "ACME",
});

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

var creditorRequest = new GoCardless.Services.CreditorCreateRequest()
{
    Name = "Acme",
    CountryCode = "GB",
    CreditorType = "company",
    BankReferencePrefix = "ACME",
};

var creditorResponse = await gocardless.Creditors.CreateAsync(creditorRequest);
GoCardless.Resources.Creditor creditor = creditorResponse.Creditor;

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  creditorCreateParams := gocardless.CreditorCreateParams{
    Name:                "Acme",
    CountryCode:         "GB",
    CreditorType:        "company",
    BankReferencePrefix: "ACME",
  }
  
  creditor, err := client.Creditors.Create(context, creditorCreateParams)

}

GET https://api.gocardless.com/creditors HTTP/1.1

HTTP/1.1 200 OK
Content-Type: application/json
{
  "meta": {
    "cursors": {
      "before": null,
      "after": null,
    },
    "limit": 50
  },
  "creditors":[{
    "id": "CR123",
    "created_at": "2017-02-16T12:34:56.000Z",
    "name": "Acme",
    "address_line1": null,
    "address_line2": null,
    "address_line3": null,
    "city": null,
    "region": null,
    "postal_code": null,
    "country_code": "GB",
    "creditor_type": "company",
    "logo_url": null,
    "scheme_identifiers": [],
    "verification_status": "successful",
    "can_create_refunds": false,
    "fx_payout_currency": null,
    "mandate_imports_enabled": false,
    "custom_payment_pages_enabled": true,
    "merchant_responsible_for_notifications": true,
    "bank_reference_prefix": "ACME",
    "links": {}
  }]
}

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

$client->creditors()->list();

$client->creditors()->list([
  'params' => ['created_at[gt]' => '2014-05-08T17:01:06.000Z']
])

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

client.creditors.list().records

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

@client.creditors.list

@client.creditors.list(params: { limit: 2 })

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

for (Creditor creditor : client.creditors().all().execute()) {
  System.out.println(creditor.getId());
}

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

const creditors = await client.creditors.list();

// List the first three creditors.
const creditors = await client.creditors.list({ limit: 3 });

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

var creditorListResponse = gocardless.Creditors.All();
foreach (GoCardless.Resources.Creditor creditor in creditorListResponse)
{
    Console.WriteLine(creditor.Name);
}

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  creditorListParams := gocardless.CreditorListParams{
    Limit: 3,
  }
  
  // List the first three creditors.
  creditorListResult, err := client.Creditors.List(context, creditorListParams)
  for _, creditor := creditorListResult.Creditors {
      fmt.Println(creditor.Name)
  }

}

GET https://api.gocardless.com/creditors/CR123 HTTP/1.1

HTTP/1.1 200 OK
Content-Type: application/json
{
  "creditors": {
    "id": "CR123",
    "created_at": "2017-02-16T12:34:56.000Z",
    "name": "Acme",
    "address_line1": null,
    "address_line2": null,
    "address_line3": null,
    "city": null,
    "region": null,
    "postal_code": null,
    "country_code": "GB",
    "creditor_type": "company",
    "logo_url": null,
    "scheme_identifiers": [],
    "verification_status": "successful",
    "can_create_refunds": false,
    "fx_payout_currency": null,
    "mandate_imports_enabled": false,
    "custom_payment_pages_enabled": true,
    "merchant_responsible_for_notifications": true,
    "bank_reference_prefix": "ACME",
    "links": {}
  }
}

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

$client->creditors()->get('CR123');

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

client.creditors.get("CR123")

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

@client.creditors.get("CR123")

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

Creditor creditor = client.creditors().get("CR123").execute();

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

const creditor = await client.creditor.find("CR123");

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

var creditorResponse = await gocardless.Creditors.GetAsync("CR0123");
GoCardless.Resources.Creditor creditor = creditorResponse.Creditor;

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  creditor, err := client.Creditors.Get(context, "CR123")

}

PUT https://api.gocardless.com/creditors/CR123 HTTP/1.1
Content-Type: application/json
{
  "creditors": {
    "links": {
      "default_gbp_payout_account": "BA789"
    }
  }
}

HTTP/1.1 200 OK
Content-Type: application/json
{
  "creditors": {
    "id": "CR123",
    "created_at": "2017-02-16T12:34:56.000Z",
    "name": "Acme",
    "address_line1": null,
    "address_line2": null,
    "address_line3": null,
    "city": null,
    "region": null,
    "postal_code": null,
    "country_code": "GB",
    "creditor_type": "company",
    "logo_url": null,
    "scheme_identifiers": [],
    "verification_status": "successful",
    "can_create_refunds": false,
    "fx_payout_currency": null,
    "mandate_imports_enabled": false,
    "custom_payment_pages_enabled": true,
    "merchant_responsible_for_notifications": true,
    "bank_reference_prefix": "ACME",
    "links": {
      "default_gbp_payout_account": "BA789",
    }
  }
}

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

$client->creditors()->update('CR123', [
  'params' => ['links' => ['default_gbp_payout_account' => 'BA789']]
]);

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

client.creditors.update("CR123", params={
  "links": {
    "default_gbp_payout_account": "BA789"
  }
})

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

@client.creditors.update(
  "CR123",
  params: {
    links: { default_gbp_payout_account: "BA789" }
  }
)

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

client.creditors().update("CR123")
  .withLinksDefaultGbpPayoutAccount("BA789")
  .execute();

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

const creditor = await client.creditors.update(
  "CR123",
  {
    links: {
      default_gbp_payout_account: "BA789"
    }
  }
);

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

var creditorRequest = new GoCardless.Services.CreditorUpdateRequest()
{
    Links = new GoCardless.Services.CreditorUpdateRequest.CreditorLinks()
    {
        DefaultGbpPayoutAccount = "BA789"
    }
};

var creditorResponse = await gocardless.Creditors.UpdateAsync("CR0123", creditorRequest);

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  creditorUpdateParams := gocardless.CreditorUpdateParams{
    Links: &gocardless.CreditorUpdateParamsLinks{
      DefaultGbpPayoutAccount: "BA789",
    },
  }
  
  creditor, err := client.Creditors.Update(context, "CR123", creditorUpdateParams)

}

POST https://api.gocardless.com/creditor_bank_accounts HTTP/1.1
Content-Type: application/json
{
  "creditor_bank_accounts": {
    "account_number": "55779911",
    "branch_code": "200000",
    "country_code": "GB",
    "account_holder_name": "Acme",
    "links": {
      "creditor": "CR123"
    }
  }
}

HTTP/1.1 201 Created
Location: /creditor_bank_accounts/BA123
Content-Type: application/json
{
  "creditor_bank_accounts": {
    "id": "BA123",
    "created_at": "2014-05-27T12:43:17.000Z",
    "account_holder_name": "Acme",
    "account_number_ending": "11",
    "account_type": null,
    "country_code": "GB",
    "currency": "GBP",
    "bank_name": "BARCLAYS BANK PLC",
    "enabled": true,
    "links": {
      "creditor": "CR123"
    },
    "verification_status": "pending"
  }
}

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

$client->creditorBankAccounts()->create([
  "params" => ["account_number" => "55779911",
               "branch_code" => "200000",
               "country_code" => "GB",
               "account_holder_name" => "Acme",
               "links" => ["creditor" => "CR123"]]
]);

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

client.creditor_bank_accounts.create(params={
  "account_number": "55779911",
  "branch_code": "200000",
  "country_code": "GB",
  "account_holder_name": "Acme",
  "links": {
    "creditor": "CR123"
  }
})

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

@client.creditor_bank_accounts.create(
  params: {
    account_holder_name: "Example Ltd",
    account_number: "55779911",
    branch_code: "200000",
    country_code: "GB",
    links: {
      creditor: "CR123"
    }
  }
)

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

CreditorBankAccount creditorBankAccount = client.creditorBankAccounts().create()
  .withAccountNumber("55779911")
  .withBranchCode("200000")
  .withCountryCode("GB")
  .withAccountHolderName("Acme")
  .withLinksCreditor("CR123")
  .execute();

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

const creditorBankAccount = await client.creditorBankAccounts.create({
  account_number: "55779911",
  branch_code: "200000",
  country_code: "GB",
  account_holder_name: "Acme",
  links: {
    creditor: "CR123"
  }
});

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

var creditorBankAccountRequest = new GoCardless.Services.CreditorBankAccountCreateRequest()
{
    AccountHolderName = "Example Ltd",
    AccountNumber = "55779911",
    BranchCode = "200000",
    CountryCode = "GB",
    Links = new GoCardless.Services.CreditorBankAccountCreateRequest.CreditorBankAccountLinks()
    {
        Creditor = "CR0123"
    }
};

var creditorBankAccountResponse = await gocardless.CreditorBankAccounts.CreateAsync(creditorBankAccountRequest);
GoCardless.Resources.CreditorBankAccount creditorBankAccount = creditorBankAccountResponse.CreditorBankAccount;

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  creditorBankAccountCreateParams := gocardless.CreditorBankAccountCreateParams{
    AccountNumber:             "55779911",
    BranchCode:                "200000",
    CountryCode:               "GB",
    AccountHolderName:         "Acme",
  }
  
  creditorBankAccount, err := client.CreditorBankAccounts.Create(context, creditorBankAccountCreateParams)

}

GET https://api.gocardless.com/creditor_bank_accounts HTTP/1.1

HTTP/1.1 200 OK
Content-Type: application/json
{
  "meta": {
    "cursors": {
      "before": null,
      "after": "BA123",
    },
    "limit": 50
  },
  "creditor_bank_accounts":[{
    "id": "BA123",
    "created_at": "2014-05-27T12:43:17.000Z",
    "account_holder_name": "Acme",
    "account_number_ending": "11",
    "account_type": null,
    "country_code": "GB",
    "currency": "GBP",
    "bank_name": "BARCLAYS BANK PLC",
    "enabled": true,
    "links": {
      "creditor": "CR123"
    },
    "verification_status": "pending"
  }, {
  ...
  }]
}

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

$client->creditorBankAccounts()->list();

$client->creditorBankAccounts()->list([
  "params" => ["enabled" => true]
]);

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

client.creditor_bank_accounts.list().records

client.creditor_bank_accounts.list(params={"creditor": "CR123"}).records

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

@client.creditor_bank_accounts.list

@client.creditor_bank_accounts.list(params: { enabled: true })

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

for (CreditorBankAccount creditorBankAccount : client.creditorBankAccounts().all().withCreditor("CR123").execute()) {
  System.out.println(creditorBankAccount.getId());
}

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

const creditorBankAccounts = await client.creditorBankAccounts.list();

// List all 'enabled' creditor bank accounts.
const creditorBankAccounts = await client.creditorBankAccounts.list({ enabled: true });

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

var creditorBankAccountRequest = new GoCardless.Services.CreditorBankAccountListRequest()
{
    Creditor = "CR000123"
};

var creditorBankAccountListResponse = gocardless.CreditorBankAccounts.All(creditorBankAccountRequest);
foreach (GoCardless.Resources.CreditorBankAccount creditorBankAccount in creditorBankAccountListResponse)
{
    Console.WriteLine(creditorBank.Id);
}

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  creditorBankAccountListParams := gocardless.CreditorBankAccountListParams{}
  creditorBankAccountListResult, err := client.CreditorBankAccounts.List(context, creditorBankAccountListParams)
  for _, creditorBankAccount := range creditorBankAccountListResult.CreditorBankAccounts {
      fmt.Println(creditorBankAccount.Id)
  }

}

GET https://api.gocardless.com/creditor_bank_accounts/BA123 HTTP/1.1

HTTP/1.1 200 OK
Content-Type: application/json
{
  "creditor_bank_accounts": {
    "id": "BA123",
    "created_at": "2014-05-27T12:43:17.000Z",
    "account_holder_name": "Acme",
    "account_number_ending": "11",
    "account_type": null,
    "country_code": "GB",
    "currency": "GBP",
    "bank_name": "BARCLAYS BANK PLC",
    "enabled": true,
    "links": {
      "creditor": "CR123"
    },
    "verification_status": "pending"
  }
}

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

$client->creditorBankAccounts()->get("BA123");

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

client.creditor_bank_accounts.get("BA123")

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

@client.creditor_bank_accounts.get("BA123")

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

CreditorBankAccount creditorBankAccount = client.creditorBankAccounts().get("BA123").execute();

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

const creditorBankAccount = await client.creditorBankAccounts.find('BA123');

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

var creditorBankAccountResponse = await gocardless.CreditorBankAccounts.GetAsync("BA0123");
GoCardless.Resources.CreditorBankAccount creditorBankAccount = creditorBankAccountResponse.CreditorBankAccount;

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  creditorBankAccount, err := client.CreditorBankAccounts.Get(context, "BA123")

}

POST https://api.gocardless.com/creditor_bank_accounts/BA123/actions/disable HTTP/1.1

HTTP/1.1 200 OK
Content-Type: application/json
{
  "creditor_bank_accounts": {
    "id": "BA123",
    "created_at": "2014-05-27T12:43:17.000Z",
    "account_holder_name": "Acme",
    "account_number_ending": "11",
    "account_type": null,
    "country_code": "GB",
    "currency": "GBP",
    "bank_name": "BARCLAYS BANK PLC",
    "enabled": false,
    "links": {
      "creditor": "CR123"
    },
    "verification_status": "pending"
  }
}

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

$client->creditorBankAccounts()->disable("BA123");

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

client.creditor_bank_accounts.disable("BA123")

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

@client.creditor_bank_accounts.disable("BA123")

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

client.creditorBankAccounts().disable("BA123").execute();

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

const creditorBankAccountResponse = await client.creditorBankAccounts.disable("BA123");

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

var creditorBankAccountResponse = await gocardless.CreditorBankAccounts.DisableAsync("BA0123");

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  creditorBankAccount, err := client.CreditorBankAccounts.Disable(context, "BA123")

}

GET https://api.gocardless.com/currency_exchange_rates?source=GBP&target=EUR HTTP/1.1

HTTP/1.1 200 OK
Content-Type: application/json
{
    "currency_exchange_rates": [
        {
            "rate": "1.19111",
            "source": "GBP",
            "target": "EUR",
            "time": "2020-02-24T23:50:04.000Z"
        }
    ],
    "meta": {
        "cursors": {
            "after": null,
            "before": null
        },
        "limit": 50
    }
}

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

$client->currencyExchangeRates()->list([
  "params" => ["source" => "EUR", "target" => "GBP"]
]);

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

client.currency_exchange_rates.list(params={"source": "EUR", "target": "GBP"}).records

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

@client.currency_exchange_rates.list(params: { source: "EUR", target: "GBP" })

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

client.currencyExchangeRates().all().withSource("EUR").withTarget("GBP").execute()

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

const currencyExchangeRates = await client.currencyExchangeRates.list();

// List the currency exchange rate for a source and target currency.
const currencyExchangeRates = await client.currencyExchangeRates.list({ source: 'EUR', target: 'GBP' });

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

var request = new GoCardless.Services.CurrencyExchangeRateListRequest()
{
    Source = "EUR",
    Target = "GBP"
};

var response = gocardless.CurrencyExchangeRates.All(request);
foreach (GoCardless.Resources.CurrencyExchangeRate rate in response)
{
    Console.WriteLine(rate.Rate);
}

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  currencyExchangeRateListParams := gocardless.CurrencyExchangeRateListParams{
    Source: "EUR",
    Target: "GBP",
  }
  
  currencyExchangeRateListResult, err := client.CurrencyExchangeRates.List(context, currencyExchangeRateListParams)
  for _, currencyExchangeRate := range currencyExchangeRateListResult.CurrencyExchangeRates {
      fmt.Println(currencyExchangeRate.Id)
  }

}

POST https://api.gocardless.com/customers HTTP/1.1
Content-Type: application/json
{
  "customers": {
    "email": "user@example.com",
    "given_name": "Frank",
    "family_name": "Osborne",
    "address_line1": "27 Acer Road",
    "address_line2": "Apt 2",
    "city": "London",
    "postal_code": "E8 3GX",
    "country_code": "GB",
    "metadata": {
      "salesforce_id": "ABCD1234"
    }
  }
}

HTTP/1.1 201 Created
Location: /customers/CU123
Content-Type: application/json
{
  "customers": {
    "id": "CU123",
    "created_at": "2014-05-08T17:01:06.000Z",
    "email": "user@example.com",
    "given_name": "Frank",
    "family_name": "Osborne",
    "address_line1": "27 Acer Road",
    "address_line2": "Apt 2",
    "address_line3": null,
    "city": "London",
    "region": null,
    "postal_code": "E8 3GX",
    "country_code": "GB",
    "language": "en",
    "phone_number": null,
    "swedish_identity_number": null,
    "danish_identity_number": null,
    "metadata": {
      "salesforce_id": "ABCD1234"
    }
  }
}

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

$client->customers()->create([
  "params" => ["email" => "tim@gocardless.com",
               "given_name" => "Tim",
               "family_name" => "Rogers",
               "country_code" => "GB"]
]);

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

client.customers.create(params={
  "email": "user@example.com",
  "given_name": "Frank",
  "family_name": "Osborne",
  "address_line1": "27 Acer Road",
  "address_line2": "Apt 2",
  "city": "London",
  "postal_code": "E8 3GX",
  "country_code": "GB",
  "metadata": {
    "salesforce_id": "ABCD1234"
  }
})

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

@client.customers.create(
  params: {
    email: "user@example.com",
    given_name: "Jacob",
    family_name: "Pargin",
    country_code: "GB"
  }
)

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

Customer customer = client.customers().create()
  .withEmail("user@example.com")
  .withGivenName("Frank")
  .withFamilyName("Osborne")
  .withAddressLine1("27 Acer Road")
  .withAddressLine2("Apt 2")
  .withCity("London")
  .withPostalCode("E8 3GX")
  .withCountryCode("GB")
  .withMetadata("salesforce_id", "ABCD1234")
  .execute();

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

const customer = await client.customers.create({
  email: "user@example.com",
  given_name: "Frank",
  family_name: "Osborne",
  address_line1: "27 Acer Road",
  address_line2: "Apt 2",
  city: "London",
  postal_code: "E8 3GX",
  country_code: "GB",
  metadata: {
    salesforce_id: "ABCD1234"
  }
});

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

var customerRequest = new GoCardless.Services.CustomerCreateRequest()
{
    Email = "user@example.com",
    GivenName = "Frank",
    FamilyName = "Osborne",
    AddressLine1 = "27 Acer Road",
    AddressLine2 = "Apt 2",
    City = "London",
    PostalCode = "E8 3GX",
    CountryCode = "GB",
    Metadata = new Dictionary<string, string>()
    {
      {"salesforce_id", "ABCD1234"}
    }
};

var customerResponse = await gocardless.Customers.CreateAsync(customerRequest);
GoCardless.Resources.Customer customer = customerResponse.Customer;

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  customerCreateParams := gocardless.CustomerCreateParams{
    AddressLine1: "27 Acer Road",
    AddressLine2: "Apt 2",
    City:         "London",
    PostalCode:   "E8 3GX",
    CountryCode:  "GB",
    Email:        "user@example.com",
    GivenName:    "Frank",
    FamilyName:   "Osborne",
  }
  
  customer, err := client.Customers.Create(context, customerCreateParams)

}

GET https://api.gocardless.com/customers?after=CU123 HTTP/1.1

HTTP/1.1 200 OK
Content-Type: application/json
{
  "meta": {
    "cursors": {
      "before": "CU000",
      "after": "CU456",
    },
    "limit": 50
  },
  "customers": [{
    "id": "CU123",
    "created_at": "2014-05-08T17:01:06.000Z",
    "email": "user@example.com",
    "given_name": "Frank",
    "family_name": "Osborne",
    "address_line1": "27 Acer Road",
    "address_line2": "Apt 2",
    "address_line3": null,
    "city": "London",
    "region": null,
    "postal_code": "E8 3GX",
    "country_code": "GB",
    "language": "en",
    "metadata": {
      "salesforce_id": "ABCD1234"
    }
  }, {
  ...
  }]
}

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

$client->customers()->list();

$client->customers()->list([
  "params" => ["created_at[gt]" => "2015-11-03T09:30:00Z"]
]);

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

client.customers.list().records

client.customers.list(params={"after": "CU123"}).records

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

@client.customers.list

@client.customers.list(
  params: {
    "created_at[gt]" => "2016-08-06T09:30:00Z"
  }
)

@client.customers.list.records.each { |customer| puts customer.inspect }

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

for (Customer customer : client.customers().all().execute()) {
  System.out.println(customer.getId());
}

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

const customer = await client.customers.list();

// List customers with a given currency.
await client.customers.list({ currency: "GBP" });

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

var customerListResponse = gocardless.Customers.All();
foreach (GoCardless.Resources.Customer customer in customerListResponse)
{
    Console.WriteLine(customer.GivenName);
}

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  customerListParams := gocardless.CustomerListParams{
    Currency: "GBP",
  }
  
  customerListResult, err := client.Customers.List(context, customerListParams)
  for _, customer GivenName range customerListResult.Customers {
      fmt.Println(customer.GivenName)
  }

}

GET https://api.gocardless.com/customers/CU123 HTTP/1.1

HTTP/1.1 200 OK
Content-Type: application/json
{
  "customers": {
    "id": "CU123",
    "created_at": "2014-05-08T17:01:06.000Z",
    "email": "user@example.com",
    "given_name": "Frank",
    "family_name": "Osborne",
    "address_line1": "27 Acer Road",
    "address_line2": "Apt 2",
    "address_line3": null,
    "city": "London",
    "region": null,
    "postal_code": "E8 3GX",
    "country_code": "GB",
    "language": "en",
    "phone_number": null,
    "swedish_identity_number": null,
    "danish_identity_number": null,
    "metadata": {
      "salesforce_id": "ABCD1234"
    }
  }
}

GET https://api.gocardless.com/customers/CU123 HTTP/1.1

HTTP/1.1 410 Gone
Content-Type: application/json
{
  "error": {
    "documentation_url": "https://developer.gocardless.com/api-reference#customer_data_removed",
    "message": "This customer data has been removed",
    "type": "invalid_api_usage",
    "errors": [
      {
        "reason": "customer_removed",
        "message": "This customer data has been removed"
      }
    ],
    "code": 410,
    "request_id": "deadbeef-0000-4000-0000-444400004444"
  }
}

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

$client->customers()->get("CU123");

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

client.customers.get("CU123")

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

@client.customers.get("CU123")

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

Customer customer = client.customers().get("CU123").execute();

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

const customer = await client.customers.find("CU123");

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

var customerResponse = await gocardless.Customers.GetAsync("CU0123");
GoCardless.Resources.Customer customer = customerResponse.Customer;

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  customer, err := client.Customers.Get(context, "CU123")

}

PUT https://api.gocardless.com/customers/CU123 HTTP/1.1
Content-Type: application/json
{
  "customers": {
    "email": "updated_user@example.com",
    "given_name": "Jenny",
    "family_name": "Osborne",
    "metadata": {
      "salesforce_id": "EFGH5678"
    }
  }
}

HTTP/1.1 200 OK
Content-Type: application/json
{
  "customers": {
    "id": "CU123",
    "created_at": "2014-05-08T17:01:06.000Z",
    "email": "updated_user@example.com",
    "given_name": "Frank",
    "family_name": "Osborne",
    "address_line1": "29 Acer Road",
    "address_line2": "Apt 3",
    "address_line3": "Block 4",
    "city": "London",
    "region": null,
    "postal_code": "E8 3GX",
    "country_code": "GB",
    "language": "en",
    "phone_number": null,
    "swedish_identity_number": null,
    "danish_identity_number": null,
    "metadata": {
      "salesforce_id": "EFGH5678"
    }
  }
}

PUT https://api.gocardless.com/customers/CU123 HTTP/1.1

HTTP/1.1 410 Gone
Content-Type: application/json
{
  "error": {
    "documentation_url": "https://developer.gocardless.com/api-reference#customer_data_removed",
    "message": "This customer data has been removed",
    "type": "invalid_api_usage",
    "errors": [
      {
        "reason": "customer_removed",
        "message": "This customer data has been removed"
      }
    ],
    "code": 410,
    "request_id": "deadbeef-0000-4000-0000-444400004444"
  }
}

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

$client->customers()->update("CU123", [
  "params" => ["email" => "tim@gocardless.com"]
]);

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

client.customers.update("CU123", params={
  "email": "updated_user@example.com"
})

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

@client.customers.update(
  "CU123",
  params: {
    metadata: { custom_reference: "EXAMPLELTD01" }
  }
)

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

client.customers().update("CU123")
  .withEmail("updated_user@example.com")
  .withGivenName("Jenny")
  .execute();

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

const customer = await client.customers.update(
  "CU123",
  {
    email: "updated_user@example.com",
  }
);

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

var customerRequest = new GoCardless.Services.CustomerUpdateRequest()
{
    Metadata = new Dictionary<string, string>()
    {
        {"custom_reference", "NEWREFERENCE001"}
    }
};
var customerResponse = await gocardless.Customers.UpdateAsync("CU0123", customerRequest);

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  customerUpdateParams := gocardless.CustomerUpdateParams{
    Email: "updated_user@example.com",
  }
  
  customer, err := client.Customers.Update(context, "CU123", customerUpdateParams)

}

DELETE https://api.gocardless.com/customers/CU123 HTTP/1.1

HTTP/1.1 204 No Content

DELETE https://api.gocardless.com/customers/CU123 HTTP/1.1

HTTP/1.1 410 Gone
Content-Type: application/json
{
  "error": {
    "documentation_url": "https://developer.gocardless.com/api-reference#customer_data_removed",
    "message": "This customer data has been removed",
    "type": "invalid_api_usage",
    "errors": [
      {
        "reason": "customer_removed",
        "message": "This customer data has been removed"
      }
    ],
    "code": 410,
    "request_id": "deadbeef-0000-4000-0000-444400004444"
  }
}

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

$client->customers()->remove("CU123");

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

client.customers.remove("CU123")

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

@client.customers.remove("CU123")

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

client.customers().remove("CU123").execute();

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

const customer = await client.customers.remove("CU123");

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

await gocardless.Customers.RemoveAsync("CU0123");

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  customer, err := client.Customers.Remove(context, "CU123")

}

POST https://api.gocardless.com/customer_bank_accounts HTTP/1.1
Content-Type: application/json
{
  "customer_bank_accounts": {
    "account_number": "55779911",
    "branch_code": "200000",
    "account_holder_name": "Frank Osborne",
    "country_code": "GB",
    "links": {
      "customer": "CU123"
    }
  }
}

HTTP/1.1 201 Created
Location: /customer_bank_accounts/BA123
Content-Type: application/json
{
  "customer_bank_accounts": {
    "id": "BA123",
    "created_at": "2014-05-08T17:01:06.000Z",
    "account_holder_name": "Frank Osborne",
    "account_number_ending": "11",
    "country_code": "GB",
    "currency": "GBP",
    "bank_name": "BARCLAYS BANK PLC",
    "metadata": {},
    "enabled": true,
    "links": {
      "customer": "CU123"
    }
  }
}

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

$client->customerBankAccounts()->create([
  "params" => ["account_number" => "55779911",
               "branch_code" => "200000",
               "account_holder_name" => "Frank Osborne",
               "country_code" => "GB",
               "links" => ["customer" => "CU123"]]
]);

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

client.customer_bank_accounts.create(params={
  "account_number": "55779911",
  "branch_code": "200000",
  "account_holder_name": "Frank Osborne",
  "country_code": "GB",
  "links": {
    "customer": "CU123"
  }
})

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

@client.customer_bank_accounts.create(
  params: {
    account_holder_name: "Fran Cosborne",
    account_number: "55779911",
    branch_code: "200000",
    country_code: "GB",
    links: {
      customer: "CU123"
    }
  }
)

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

CustomerBankAccount customerBankAccount = client.customerBankAccounts().create()
  .withAccountNumber("55779911")
  .withBranchCode("200000")
  .withAccountHolderName("Frank Osborne")
  .withCountryCode("GB")
  .withLinksCustomer("CU123")
  .execute();

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

const customerBankAccount = await client.customerBankAccounts.create({
  account_number: "55779911",
  branch_code: "200000",
  account_holder_name: "Frank Osborne",
  country_code: "GB",
  links: {
    customer: "CU123"
  }
);

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

var customerBankAccountRequest = new GoCardless.Services.CustomerBankAccountCreateRequest()
{
    AccountHolderName = "Example Ltd",
    AccountNumber = "55779911",
    BranchCode = "200000",
    CountryCode = "GB",
    Links = new GoCardless.Services.CustomerBankAccountCreateRequest.CustomerBankAccountLinks()
    {
        Customer = "CU0123"
    }
};

var customerBankAccountResponse = await gocardless.CustomerBankAccounts.CreateAsync(customerBankAccountRequest);
GoCardless.Resources.CustomerBankAccount customerBankAccount = customerBankAccountResponse.CustomerBankAccount;

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  customerBankAccountCreateParams := gocardless.CustomerBankAccountCreateParams{
    AccountNumber:     "55779911",
    BranchCode:        "200000",
    AccountHolderName: "Frank Osborne",
    CountryCode:       "GB",
    Links: gocardless.CustomerBankAccountCreateParamsLinks{
      Customer: "CU123",
    },
  }
  
  customerBankAccount, err := client.CustomerBankAccounts.Create(context, customerBankAccountCreateParams)

}

GET https://api.gocardless.com/customer_bank_accounts HTTP/1.1

HTTP/1.1 200 OK
Content-Type: application/json
{
  "meta": {
    "cursors": {
      "before": null,
      "after": null
    },
    "limit": 50
  },
  "customer_bank_accounts": [{
    "id": "BA123",
    "created_at": "2014-05-08T17:01:06.000Z",
    "account_holder_name": "Frank Osborne",
    "account_number_ending": "11",
    "account_type": null,
    "country_code": "GB",
    "currency": "GBP",
    "bank_name": "BARCLAYS BANK PLC",
    "metadata": {},
    "enabled": true,
    "links": {
      "customer": "CU123"
    }
  }]
}

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

$client->customerBankAccounts()->list();

$client->customerBankAccounts()->list([
  "params" => ["customer" => "CU123",
               "enabled" => true]
]);

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

client.customer_bank_accounts.list(params={"customer": "CU123"}).records

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

@client.customer_bank_accounts.list

@client.customer_bank_accounts.list(
  params: {
    customer: "CU123",
    enabled: true
  }
)

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

for (CustomerBankAccount customerBankAccount : client.customerBankAccounts().all().withCustomer("CU123").withEnabled(true).execute()) {
  System.out.println(customerBankAccount.getAccountHolderName());
}

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

const customerBankAccount = await client.customerBankAccounts.list();

// List all 'enabled' customer bank accounts.
await client.customerBankAccounts.list({ enabled: true });

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

var customerBankAccountRequest = new GoCardless.Services.CustomerBankAccountListRequest()
{
    Customer = "CU000123"
};

var customerBankAccountListResponse = gocardless.CustomerBankAccounts.All(customerBankAccountRequest);
foreach (GoCardless.Resources.CustomerBankAccount customerBankAccount in customerBankAccountListResponse)
{
    Console.WriteLine(customerBank.Id);
}

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  customerBankAccountListParams := gocardless.CustomerBankAccountListParams{
    Enabled: true,
  }
  
  customerBankAccountListResult, err := client.CustomerBankAccounts.List(context, customerBankAccountListParams)
  for _, customerBankAccount := range customerBankAccountListResult.CustomerBankAccounts {
      fmt.Println(customerBankAccount.Id)
  }

}

GET https://api.gocardless.com/customer_bank_accounts/BA123 HTTP/1.1

HTTP/1.1 200 OK
Content-Type: application/json
{
  "customer_bank_accounts": {
    "id": "BA123",
    "created_at": "2014-05-08T17:01:06.000Z",
    "account_number_ending": "11",
    "account_holder_name": "Frank Osborne",
    "account_type": null,
    "country_code": "GB",
    "currency": "GBP",
    "bank_name": "BARCLAYS BANK PLC",
    "metadata": {},
    "enabled": true,
    "links": {
      "customer": "CU123"
    }
  }
}

GET https://api.gocardless.com/customer_bank_accounts/BA123 HTTP/1.1

HTTP/1.1 410 Gone
Content-Type: application/json
{
  "error": {
    "documentation_url": "https://developer.gocardless.com/api-reference#customer_data_removed",
    "message": "This customer data has been removed",
    "type": "invalid_api_usage",
    "errors": [
      {
        "reason": "customer_removed",
        "message": "This customer data has been removed"
      }
    ],
    "code": 410,
    "request_id": "deadbeef-0000-4000-0000-444400004444"
  }
}

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

$client->customerBankAccounts()->get("BA123");

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

client.customer_bank_accounts.get("BA123")

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

@client.customer_bank_accounts.get("BA123")

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

CustomerBankAccount customerBankAccount = client.customerBankAccounts.get("BA123").execute();

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

const customerBankAccount = await client.customerBankAccounts.find("BA123");

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

var customerBankAccountResponse = await gocardless.CustomerBankAccounts.GetAsync("BA0123");
GoCardless.Resources.CustomerBankAccount customerBankAccount = customerBankAccountResponse.CustomerBankAccount;

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  customerBankAccount, err := client.CustomerBankAccounts.Get(context, "BA123")

}

PUT https://api.gocardless.com/customer_bank_accounts/BA123 HTTP/1.1
Content-Type: application/json
{
  "customer_bank_accounts": {
    "metadata": {
      "key": "value"
    }
  }
}

HTTP/1.1 200 OK
Content-Type: application/json
{
  "customer_bank_accounts": {
    "id": "BA123",
    "created_at": "2014-05-08T17:01:06.000Z",
    "account_number_ending": "11",
    "account_holder_name": "Frank Osborne",
    "account_type": null,
    "country_code": "GB",
    "currency": "GBP",
    "bank_name": "BARCLAYS BANK PLC",
    "metadata": {
      "key": "value"
    },
    "enabled": true,
    "links": {
      "customer": "CU123"
    }
  }
}

PUT https://api.gocardless.com/customer_bank_accounts/BA123 HTTP/1.1

HTTP/1.1 410 Gone
Content-Type: application/json
{
  "error": {
    "documentation_url": "https://developer.gocardless.com/api-reference#customer_data_removed",
    "message": "This customer data has been removed",
    "type": "invalid_api_usage",
    "errors": [
      {
        "reason": "customer_removed",
        "message": "This customer data has been removed"
      }
    ],
    "code": 410,
    "request_id": "deadbeef-0000-4000-0000-444400004444"
  }
}

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

$client->customerBankAccounts()->update("BA123", [
  "params" => ["metadata" => ["key" => "value"]]
]);

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

client.customer_bank_accounts.update("BA123", params={
  "metadata": {"key": "value"}
})

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

@client.customer_bank_accounts.update(
  "BA123",
  params: {
    metadata: { description: "Business account" }
  }
)

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

client.customerBankAccounts().update("BA123")
  .withMetadata("description", "Business account")
  .execute();

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

const customerBankAccount = await client.customerBankAccounts.update(
  "BA123",
  {
    metadata: {
      key: "value"
    }
  }
);

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

var customerBankAccountRequest = new GoCardless.Services.CustomerBankAccountUpdateRequest()
{
    Metadata = new Dictionary<string, string>()
    {
        {"description", "Business account"}
    }
};

var customerBankAccountResponse = await gocardless.CustomerBankAccounts.UpdateAsync("BA0123", customerBankAccountRequest);

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  customerBankAccountUpdateParams := gocardless.CustomerBankAccountUpdateParams{
    Metadata: map[string]interface{}{"key": "value"},
  }
  
  customerBankAccount, err := client.CustomerBankAccounts.Update(context, customerBankAccountUpdateParams)

}

POST https://api.gocardless.com/customer_bank_accounts/BA123/actions/disable HTTP/1.1

HTTP/1.1 200 OK
Content-Type: application/json
{
  "customer_bank_accounts": {
    "id": "BA123",
    "created_at": "2014-05-08T17:01:06.000Z",
    "account_number_ending": "11",
    "account_holder_name": "Frank Osborne",
    "account_type": null,
    "country_code": "GB",
    "currency": "GBP",
    "bank_name": "BARCLAYS BANK PLC",
    "metadata": {},
    "enabled": false,
    "links": {
      "customer": "CU123"
    }
  }
}

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

$client->customerBankAccounts()->disable("BA123");

import gocardless_pro
client = gocardless_pro.Client(access_token="your_access_token_here", environment='sandbox')

client.customer_bank_accounts.disable("BA123")

@client = GoCardlessPro::Client.new(
  access_token: "your_access_token",
  environment: :sandbox
)

@client.customer_bank_accounts.disable("BA123")

import static com.gocardless.GoCardlessClient.Environment.SANDBOX;
String accessToken = "your_access_token_here";
GoCardlessClient client = GoCardlessClient
    .newBuilder(accessToken)
    .withEnvironment(SANDBOX)
    .build();

client.customerBankAccounts.disable("BA123").execute();

const constants = require('gocardless-nodejs/constants');
const gocardless = require('gocardless-nodejs');
const client = gocardless('your_access_token_here', constants.Environments.Sandbox);

const customerBankAccount = await client.customerBankAccounts.disable("BA123");

String accessToken = "your_access_token";
GoCardlessClient gocardless = GoCardlessClient.Create(accessToken, Environment.SANDBOX);

var customerBankAccountResponse = await gocardless.CustomerBankAccounts.DisableAsync("BA0123");

package main

import (
  gocardless "github.com/gocardless/gocardless-pro-go/v2"
)

func main() {
  accessToken := "your_access_token_here"
  config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
  if err != nil {
    fmt.Printf("got err in initialising config: %s", err.Error())
    return
  }
  client, err := gocardless.New(config)
  if err != nil {
    fmt.Println("error in initialisating client: %s", err.Error())
    return
  }

  customerBankAccount, err := client.CustomerBankAccounts.Disable(context, "BA123")

}