composer require adoy/oauth2

pip install oauth2client

echo "gem 'oauth2'" >> Gemfile
bundle install

<-- Add the following to your Maven file --> 
<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>3.4.1</version>
</dependency>

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

// You should store your client ID and secret in environment variables rather than
// committing them with your code
$client = new OAuth2\Client(getenv('GOCARDLESS_CLIENT_ID'), getenv('GOCARDLESS_CLIENT_SECRET'));

$authorizeUrl = $client->getAuthenticationUrl(
    // Once you go live, this should be set to https://connect.gocardless.com. You'll also
    // need to create a live app and update your client ID and secret.
    'https://connect-sandbox.gocardless.com/oauth/authorize',
    'https://acme.enterprises/redirect', // Your redirect URL
    ['scope' => 'read_write',
     'initial_view' => 'login',
     'prefill' => ['email' => 'tim@gocardless.com',
                   'given_name' => 'Tim',
                   'family_name' => 'Rogers',
                   'organisation_name' => 'Tim\'s Fishing Store']]
);

// You'll now want to direct your user to the URL - you could redirect them or display it
// as a link on the page
header("Location: " . $authorizeUrl);

import os
from oauth2client.client import OAuth2WebServerFlow

# You should store your client ID and secret in environment variables rather than
# committing them with your code

flow = OAuth2WebServerFlow(
    client_id=os.environ['GOCARDLESS_CLIENT_ID'],
    client_secret=os.environ['GOCARDLESS_CLIENT_SECRET'],
    scope="read_write",
    redirect_uri="https://acme.enterprises/redirect",
    # Once you go live, this should be set to https://connect.gocardless.com. You'll
    # also need to create a live app and update your client ID and secret.
    auth_uri="https://connect-sandbox.gocardless.com/oauth/authorize",
    token_uri="https://connect-sandbox.gocardless.com/oauth/access_token",
    initial_view="signup",
    prefill={
        "email": "tim@gocardless.com",
        "given_name": "Tim",
        "family_name": "Rogers",
        "organisation_name": "Tim's Fishing Store"
    }
)

authorize_url = flow.step1_get_authorize_url()

# You'll now want to direct your user to the URL - you could redirect them or display it
# as a link on the page
flask.redirect(authorize_url, code=302)

require 'oauth2'

# You should store your client ID and secret in environment variables rather than
# committing them with your code
oauth = OAuth2::Client.new(ENV['GOCARDLESS_CLIENT_ID'],
                           ENV['GOCARDLESS_CLIENT_SECRET'],
                           # Once you go live, this should be set to
                           # https://connect.gocardless.com. You'll also need to create
                           # a live app and update your client ID and secret.
                           site: 'https://connect-sandbox.gocardless.com',
                           authorize_url: '/oauth/authorize',
                           token_url: '/oauth/access_token')

authorize_url = oauth.auth_code.authorize_url(redirect_uri: 'https://acme.enterprises/redirect',
                                              scope: 'read_only',
                                              initial_view: 'signup',
                                              prefill: {
                                                email: "tim@gocardless.com",
                                                given_name: "Tim",
                                                family_name: "Rogers",
                                                organisation_name: "Tim's Fishing Store"
                                              })

redirect_to authorize_url

// See https://raw.githubusercontent.com/gocardless/gocardless-pro-java-maven-example/master/src/main/java/hello/OAuthController.java

import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.http.HttpStatus;
import org.springframework.http.HttpHeaders;
import org.springframework.http.ResponseEntity;
import org.springframework.web.util.UriComponentsBuilder;

@RestController
public class OAuthController {

  private static final String authoriseRedirectUrl =
          "https://connect-sandbox.gocardless.com/oauth/authorize";
  private static final String redirectUrl =
          "https://bb314345.ngrok.io/redirect";
  private static final String clientID =
          System.getenv("GOCARDLESS_CLIENT_ID");
  private static final String clientSecret =
          System.getenv("GOCARDLESS_CLIENT_SECRET");

  @GetMapping("/")
  public ResponseEntity<String> index() {
      String oauthUrl = UriComponentsBuilder
        .fromUriString(authoriseRedirectUrl)
        .queryParam("client_id", clientID)
        .queryParam("redirect_uri", redirectUrl)
        .queryParam("scope", "read_write")
        .queryParam("response_type", "code")
        .queryParam("initial_view", "signup")
        .queryParam("prefill[email]", "tim@gocardless.com")
        .queryParam("prefill[given_name]", "Tim")
        .queryParam("prefill[family_name]", "Rogers")
        .queryParam("prefill[organisation_name]", "Tim's Fishing Store")
        .queryParam("prefill[country_code]", "GB")
        .toUriString();
      HttpHeaders headers = new HttpHeaders();
      headers.add("Location", oauthUrl);
      return new ResponseEntity<String>(oauthUrl, headers, HttpStatus.FOUND);
  }
}  

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

$client = new OAuth2\Client(getenv('GOCARDLESS_CLIENT_ID'),
                            getenv('GOCARDLESS_CLIENT_SECRET'));

// You'll need to use exactly the same redirect URI as in the last step
$response = $client->getAccessToken(
    'https://connect-sandbox.gocardless.com/oauth/access_token',
    'authorization_code',
    ['code' => $_GET['code'], 'redirect_uri' => 'https://acme.enterprises/redirect']
);

$payload = ['gocardless_access_token' => $response['result']['access_token'],
            'gocardless_organisation_id' => $response['result']['organisation_id']];

$currentUser->update($payload);

import os
from oauth2client.client import OAuth2WebServerFlow

# You should store your client ID and secret in environment variables rather than
# committing them with your code
flow = OAuth2WebServerFlow(
        client_id=os.environ['GOCARDLESS_CLIENT_ID'],
        client_secret=os.environ['GOCARDLESS_CLIENT_SECRET'],
        scope="read_write",
        # You'll need to use exactly the same redirect URI as in the last step
        redirect_uri="https://acme.enterprises/redirect",
        # Once you go live, this should be set to https://connect.gocardless.com. You'll
        # also need to create a live app and update your client ID and secret.
        auth_uri="https://connect-sandbox.gocardless.com/oauth/authorize",
        token_uri="https://connect-sandbox.gocardless.com/oauth/access_token",
        initial_view="signup"
)

access_token = flow.step2_exchange(request.args.get('code'))

# You should store the user's access token - you'll need it to make API requests on their
# behalf in future. If you want to handle webhooks for your users, you should also store
# their organisation ID which will allow you to identify webhooks belonging to them.
current_user.update(
    gocardless_access_token=access_token.access_token,
    gocardless_organisation_id=access_token.token_response['organisation_id']
)

require 'oauth2'

# You should store your client ID and secret in environment variables rather than
# committing them with your code
oauth = OAuth2::Client.new(ENV['GOCARDLESS_CLIENT_ID'],
                           ENV['GOCARDLESS_CLIENT_SECRET'],
                           # Once you go live, this should be set to
                           # https://connect.gocardless.com. You'll also need to create
                           # a live app and update your client ID and secret.
                           site: 'https://connect-sandbox.gocardless.com',
                           authorize_url: '/oauth/authorize',
                           token_url: '/oauth/access_token')

access_token = oauth.auth_code.get_token(
  params[:code],
  # You'll need to use exactly the same access token as you did in the last step
  redirect_uri: 'https://acme.enterprises/redirect'
)

# You should store the user's access token - you'll need it to make API requests on their
# behalf in future. If you want to handle webhooks for your users, you should also store
# their organisation ID which will allow you to identify webhooks belonging to them.
current_user.update!(gocardless_access_token: access_token.token,
                     gocardless_organisation_id: access_token['organisation_id'])

// See https://raw.githubusercontent.com/gocardless/gocardless-pro-java-maven-example/master/src/main/java/hello/OAuthController.java

import okhttp3.FormBody;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.io.IOException;

@RestController
public class OAuthController {
  private static final String accessTokenUrl =
          "https://connect-sandbox.gocardless.com/oauth/access_token";
  private static final String redirectUri =
          "https://bb314345.ngrok.io/redirect";
  private static final String clientID =
          System.getenv("GOCARDLESS_CLIENT_ID");
  private static final String clientSecret =
          System.getenv("GOCARDLESS_CLIENT_SECRET");

  private static final OkHttpClient client =
          new OkHttpClient();

  private String getAccessToken(String oauthCode) throws IOException {
      RequestBody body = new FormBody.Builder()
        .add("client_id", clientID)
        .add("client_secret", clientSecret)
        .add("redirect_uri", redirectUri)
        .add("grant_type", "authorization_code")
        .add("code", oauthCode)
        .build();

      Request request = new Request.Builder()
        .url(accessTokenUrl)
        .post(body)
        .build();
      try (Response response = client.newCall(request).execute()) {
          return response.body().string();
      }
  }

  @GetMapping("/redirect")
  public String loggedIn(@RequestParam("code") String oauthCode) throws IOException {
      String accessToken = getAccessToken(oauthCode);
      System.out.println("Save the access token " +
              accessToken + " to your database.");
      return "Greetings!";
  }
}

<?php
function process_organisation_event($event)
{
    switch ($event->action) {
        case "disconnected":
            print("Organisation " . $event->links->organisation . " has been disconnected!\n");
            MarkOrganisationAsDisconnected($event->links->organisation);
            break;
        default:
            print("Don't know how to process an organisation " . $event->action . " event\n");
            break;
    }
}

$webhook_endpoint_secret = getenv("GOCARDLESS_WEBHOOK_ENDPOINT_SECRET");
$request_body = file_get_contents('php://input');

$headers = getallheaders();
$signature_header = $headers["Webhook-Signature"];

try {
    $events = \GoCardlessPro\Webhook::parse($request_body,
                                            $signature_header,
                                            $webhook_endpoint_secret);

    foreach ($events as $event) {
        print("Processing event " . $event->id . "\n");

        switch ($event->resource_type) {
            case "organisations":
                process_organisation_event($event);
                break;
            default:
                print("Don't know how to process an event with resource_type " . $event->resource_type . "\n");
                break;
        }
    }

    header("HTTP/1.1 200 OK");
} catch(\GoCardlessPro\Core\Exception\InvalidSignatureException $e) {
    header("HTTP/1.1 498 Invalid Token");
}

# Here, we're using a Django view, but essentially the same code will work in
# other Python web frameworks (e.g. Flask) with minimal changes
import os
import logging

from django.views.generic import View
from django.views.decorators.csrf import csrf_exempt
from django.utils.decorators import method_decorator
from django.http import HttpResponse

from gocardless_pro import webhooks, Client
from gocardless_pro.errors import InvalidSignatureError

from myinvoicingapp.models import GoCardlessEvent

# Handle the incoming Webhook and perform an action with the  Webhook data.
class Webhook(View):
    logger = logging.getLogger(__name__)

    @method_decorator(csrf_exempt)
    def dispatch(self, *args, **kwargs):
        return super(Webhook, self).dispatch(*args, **kwargs)

    def post(self, request, *args, **kwargs):
        try:
            for event in self._get_events(request):
                self.process(event)
            return HttpResponse(204)
        except InvalidSignatureError:
            return HttpResponse(498)

    def process(self, event):
        self.logger.info("Processing event {}\n".format(event.id))

        if event.resource_type == 'organisations':
            return self.process_organisation_event(event)
        # ... Handle other resource types
        else:
            self.logger.info("Don't know how to process an event with \
                resource_type {}\n".format(event.resource_type))

    def process_organisation_event(self, event):
        if event.action == 'disconnected':
            self.logger.info(
                "Organisation {} has been disconnected\n".
                format(event.links.organisation)
            )
        else:
            self.logger.info("Don't know how to process an event with \
                resource_type {}\n".format(event.resource_type))

    def _get_events(self, request):
        secret = os.environ['GC_WEBHOOK_SECRET']
        signature = request.META["HTTP_WEBHOOK_SIGNATURE"]
        body = request.body.strip()
        return webhooks.parse(body, secret, signature)

require 'gocardless_pro'

class OrganisationEventProcessor
  def self.process(event, response)
    case event.action
    when 'disconnected'
      response.stream.write("Organisation #{event.links.organisation} has been disconnected\n")

      DisconnectOrganisation.enqueue(event['links']['organisation'])

    else
      response.stream.write(
        "Don't know how to process a organisation #{event.action} event\n"
        )
    end
  end
end

def create
  # We recommend storing your webhook endpoint secret in an environment variable
  # for security
  webhook_endpoint_secret = ENV['GOCARDLESS_WEBHOOK_ENDPOINT_SECRET']

  # In a Rack app (e.g. Sinatra), access the POST body with
  # `request.body.tap(&:rewind).read`
  request_body = request.raw_post

  # In a Rack app (e.g. Sinatra), the header is available as
  # `request.env['HTTP_WEBHOOK_SIGNATURE']`
  signature_header = request.headers['Webhook-Signature']

  begin
    events = GoCardlessPro::Webhook.parse(request_body: request_body,
                                          signature_header: signature_header,
                                          webhook_endpoint_secret: webhook_endpoint_secret)

    events.each do |event|
      # We're using Rails's streaming functionality here to write directly to the
      # response rather than using views, as one would usually.
      response.stream.write("Processing event #{event.id}\n")

      case event.resource_type
      when 'organisations'
        OrganisationEventProcessor.process(event, response)
      else
        response.stream.write(
          "Don't know how to process an event with resource_type #{event.resource_type}\n"
          )
      end
    end

    response.stream.close
    render status: 200
  rescue GoCardlessPro::Webhook::InvalidSignatureError
    render status: 498
  end
end

package hello;

// Use the POM file at
// https://raw.githubusercontent.com/gocardless/gocardless-pro-java-maven-example/master/pom.xml

import com.gocardless.errors.InvalidSignatureException;
import com.gocardless.resources.Event;
import com.gocardless.Webhook;
import java.util.List;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.http.ResponseEntity;

@RestController
public class HelloController {
    private String processDisconnections(Event event) {
        switch (event.getAction()) {
            case "disconnected":
            // here, you probably want to mark the organisation as disconnected 
            // and stop sending any requests on their behalf
                return "Organisation " + event.getLinks().getOrganisation() +
                    " has been cancelled.\n";
            default:
                return "Do not know how to process an event with action " +
                    event.getAction() + ".\n";
        }
    }

    private String processEvent(Event event) {
        switch (event.getResourceType()) {
            case ORGANISATIONS:
                return processDisconnections(event);
            default:
                return "Don't know how to process an event of resource_type " +
                    event.getResourceType().toString() + ".\n";
        }
    }

    @PostMapping("/")
    public ResponseEntity<String> handlePost(
            @RequestHeader("Webhook-Signature") String signatureHeader,
            @RequestBody String requestBody) {
        String webhookEndpointSecret = System.getenv("GOCARDLESS_WEBHOOK_ENDPOINT_SECRET");

        try {
            List<Event> events = Webhook.parse(requestBody, signatureHeader, webhookEndpointSecret);

            String responseBody = "";

            for (Event event : events) {
                responseBody += processEvent(event);
            }

            return new ResponseEntity<String>(responseBody, HttpStatus.OK);
        } catch(InvalidSignatureException e) {
            return new ResponseEntity<String>("Incorrect Signature", HttpStatus.BAD_REQUEST);
        }
    }
}

POST https://example.com/webhooks HTTP/1.1
Content-Type: application/json
{
  "events": [
    {
      "id": null,
      "created_at": "2018-08-03T12:00:00.000Z",
      "action": "disconnected",
      "resource_type": "organisations",
      "links": {
        "organisation": "OR123"
      },
      "details": {
        "cause": "app_disconnected",
        "origin": "gocardless",
        "description": "Your app has been has disconnected from this organisation"
      },
      "metadata": {}
    }
  ]
}