Connect your merchants#

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',
  auth_scheme: :request_body
)

authorize_url = oauth.auth_code.authorize_url(
  redirect_uri: 'https://acme.enterprises/redirect',
  scope: 'read_write',
  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);
    }
}

// This is example code and must be inserted into your application structure

private readonly string authoriseRedirectUrl = "https://connect-sandbox.gocardless.com/oauth/authorize";
private readonly string redirectUrl = "https://acme.enterprises/redirect";
private readonly string clientID = Environment.GetEnvironmentVariable("GOCARDLESS_CLIENT_ID");
private readonly string clientSecret = Environment.GetEnvironmentVariable("GOCARDLESS_CLIENT_SECRET");

public static void redirect()
{
    var uriBuilder = new UriBuilder(authoriseRedirectUrl);

    uriBuilder.Query = "?client_id=" + clientID;
    uriBuilder.Query += "&redirect_uri=" + redirectUrl;
    uriBuilder.Query += "&scope=read_write";
    uriBuilder.Query += "&response_type=code";
    uriBuilder.Query += "&prefill[email]=tim@gocardless.com";
    uriBuilder.Query += "&prefill[given_name]=Tim";
    uriBuilder.Query += "&prefill[family_name]=Rogers";
    uriBuilder.Query += "&prefill[organisation_name]=Fishing%20Store";
    uriBuilder.Query += "&prefill[country_code]=GB";

    Response.Redirect(uriBuilder.ToString());
}

<?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 requests_oauthlib import OAuth2Session
from oauthlib.oauth2 import WebApplicationClient

# Configuration
client_id = os.environ['GOCARDLESS_CLIENT_ID']
client_secret = os.environ['GOCARDLESS_CLIENT_SECRET']
redirect_uri = "https://acme.enterprises/redirect"

# Authorization endpoint and token endpoint for GoCardless (sandbox in this case)
auth_base_url = "https://connect-sandbox.gocardless.com/oauth/authorize"
token_url = "https://connect-sandbox.gocardless.com/oauth/access_token"
scope = ["read_write"]

# Create OAuth2 client
oauth_client = OAuth2Session(client_id=client_id, redirect_uri=redirect_uri, scope=scope)

# Step 1: Redirect user to GoCardless for authorization
authorization_url, state = oauth_client.authorization_url(auth_base_url)
print(f"Visit this URL to authorize the app: {authorization_url}")

# After the user authorizes the app, they will be redirected to your redirect_uri with a code parameter.
# You will retrieve the code parameter in your web app after redirection.
# For example, assuming you're in a web framework like Flask:
# code = request.args.get('code')

# Step 2: Exchange the authorization code for an access token
# Replace 'code' with the authorization code obtained from the redirect
code = 'authorization_code_from_redirect'
token = oauth_client.fetch_token(
    token_url=token_url,
    code=code,
    client_id=client_id,
    client_secret=client_secret,
    include_client_id=True  # Ensure the client_id is included in the request body
)

# Step 3: Store the access token and organization ID
access_token = token.get('access_token')
organisation_id = token.get('organisation_id')

# Now, you can store these tokens for later use:
current_user.update(
    gocardless_access_token=access_token,
    gocardless_organisation_id=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',
  auth_scheme: :request_body
)

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!";
    }
}

// This is example code and must be inserted into your application structure

private readonly string accessTokenUrl = "https://connect-sandbox.gocardless.com/oauth/access_token";
private readonly string redirectUrl = "https://acme.enterprises/redirect";
private readonly string clientID = Environment.GetEnvironmentVariable("GOCARDLESS_CLIENT_ID");
private readonly string clientSecret = Environment.GetEnvironmentVariable("GOCARDLESS_CLIENT_SECRET");

public Task<string> RedirectHandler(request Request) {
    var oauthCode = request.Query["code"].ToString();

    using (HttpClient client = new HttpClient()) {
        using (MultipartFormDataContent data = new MultipartFormDataContent())
        {
            data.Add(new StringContent(clientID), "client_id");
            data.Add(new StringContent(clientSecret), "client_secret");
            data.Add(new StringContent(redirectUrl), "redirect_uri");
            data.Add(new StringContent("authorization_code"), "grant_type");
            data.Add(new StringContent(redirectUrl), "redirect_uri");
            data.Add(new StringContent(oauthCode), "code");

            var response = await client.PostAsync(accessTokenUrl, data);
            var accessToken = response.Content

            return accessToken;
        }
    }
}

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

$client = new \GoCardlessPro\Client([
    // You'll need to identify the user that the customer is paying
    // and fetch their access token
    'access_token' => $user->gocardlessAccessToken,
    // Change me to LIVE when you're ready to go live
    'environment' => \GoCardlessPro\Environment::SANDBOX
]);

import os
import gocardless_pro

client = gocardless_pro.Client(
    # You'll need to identify the user that the customer is paying
    # and fetch their access token
    access_token=user.gocardless_access_token,
    # Change this to 'live' when you are ready to go live.
    environment='sandbox'
)

require 'gocardless_pro'

client = GoCardlessPro::Client.new(
  # You'll need to identify the user that the customer is paying
  # and fetch their access token
  access_token: user.gocardless_access_token,
  # Remove the following line when you're ready to go live
  environment: :sandbox
)

package com.gcintegration;

import com.gocardless.GoCardlessClient;
import com.gocardless.resources.RedirectFlow;

GoCardlessClient client = GoCardlessClient
    // You'll need to identify the user that the customer is paying
    // and fetch their access token
    .newBuilder(CurrentUser.gocardlessAccessToken)
    // Change me to LIVE when you're ready to go live
    .withEnvironment(GoCardlessClient.Environment.SANDBOX)
    .build();

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

const client = gocardless(
  // We recommend storing your access token in an environment
  // variable for security
  user.GoCardlessAccessToken,
  // Change this to constants.Environments.Live when you're ready to go live
  constants.Environments.Sandbox,
);

using GoCardless;

GoCardlessClient client = GoCardlessClient.Create(
    // We recommend storing your access token in an
    // configuration setting for security
    User["GoCardlessAccessToken"],
    // Change me to LIVE when you're ready to go live
    GoCardlessClient.Environment.SANDBOX
);

package main

import (
	"fmt"

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

func main() {
	accessToken := user.accessToken
	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
	}
}