# Available as a gem
sudo gem install stripe

# If you use bundler, you can add this line to your Gemfile
gem 'stripe'

# Install through pip
pip install --upgrade stripe

# Or find the Stripe package on http://pypi.python.org/pypi/stripe/

# Install the PHP library via Composer
composer require stripe/stripe-php

# Or download the source directly: https://github.com/stripe/stripe-php/releases

/*
 For Gradle, add the following dependency to your build.gradle and replace {VERSION} with
 the version number you want to use from
 - https://mvnrepository.com/artifact/com.stripe/stripe-java or
 - https://github.com/stripe/stripe-java/releases/latest
*/
implementation "com.stripe:stripe-java:{VERSION}"

<!--
  For Maven, add the following dependency to your POM and replace {VERSION} with the
  version number you want to use from
  - https://mvnrepository.com/artifact/com.stripe/stripe-java or
  - https://github.com/stripe/stripe-java/releases/latest
-->
<dependency>
  <groupId>com.stripe</groupId>
  <artifactId>stripe-java</artifactId>
  <version>{VERSION}</version>
</dependency>

# For other environments, manually install the following JARs:
# - The Stripe JAR from https://github.com/stripe/stripe-java/releases/latest
# - Google Gson from https://github.com/google/gson

# Install via npm
npm install --save stripe

# Install stripe-go
go get -u github.com/stripe/stripe-go

// Then import the package
import (
  "github.com/stripe/stripe-go/v71"
)

# Install via dotnet
dotnet add package Stripe.net
dotnet restore

# Or install via NuGet
PM> Install-Package Stripe.net

curl https://connect.stripe.com/oauth/token \
  -u sk_test_4eC39HqLyjWDarjtT1zdp7dc: \
  -d code=ac_123456789 \
  -d grant_type=authorization_code

# Using Sinatra.
require 'sinatra'
require 'stripe'

set :port, 4242

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

get '/' do
  # Display landing page.
  content_type 'text/html'
  send_file File.join('./index.html')
end

get '/connect/oauth' do
  content_type 'application/json'

  # Assert the state matches the state you provided in the OAuth link (optional).
  state = params[:state]
  if !state_matches?(state)
    status 403
    return {error: 'Incorrect state parameter: ' + state}.to_json
  end

  # Send the authorization code to Stripe's API.
  code = params[:code]
  begin
    response = Stripe::OAuth.token({
      grant_type: 'authorization_code',
      code: code,
    })
  rescue Stripe::OAuth::InvalidGrantError
    status 400
    return {error: 'Invalid authorization code: ' + code}.to_json
  rescue Stripe::StripeError
    status 500
    return {error: 'An unknown error occurred.'}.to_json
  end

  connected_account_id = response.stripe_user_id
  save_account_id(connected_account_id)

  # Render some HTML or redirect to a different page.
  status 200
  {success: true}.to_json
end

def state_matches?(state_parameter)
  # Load the same state value that you randomly generated for your OAuth link.
  saved_state = '{{ STATE }}'

  saved_state == state_parameter
end

def save_account_id(id)
  # Save the connected account ID from the response to your database.
  puts 'Connected account ID: ' + id
end

import stripe
import json

# Using Flask.
from flask import (
    Flask,
    render_template,
    request,
)

app = Flask(__name__, static_folder=".",
            static_url_path="", template_folder=".")

@app.route('/', methods=['GET'])
def get_example():
  # Display landing page.
  return render_template('index.html')

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

@app.route("/connect/oauth", methods=["GET"])
def handle_oauth_redirect():
  # Assert the state matches the state you provided in the OAuth link (optional).
  state = request.args.get("state")

  if not state_matches(state):
    return json.dumps({"error": "Incorrect state parameter: " + state}), 403

  # Send the authorization code to Stripe's API.
  code = request.args.get("code")
  try:
    response = stripe.OAuth.token(grant_type="authorization_code", code=code,)
  except stripe.oauth_error.OAuthError as e:
    return json.dumps({"error": "Invalid authorization code: " + code}), 400
  except Exception as e:
    return json.dumps({"error": "An unknown error occurred."}), 500

  connected_account_id = response["stripe_user_id"]
  save_account_id(connected_account_id)

  # Render some HTML or redirect to a different page.
  return json.dumps({"success": True}), 200

def state_matches(state_parameter):
  # Load the same state value that you randomly generated for your OAuth link.
  saved_state = "{{ STATE }}"

  return saved_state == state_parameter

def save_account_id(id):
  # Save the connected account ID from the response to your database.
  print("Connected account ID: ", id)

if __name__ == "__main__":
    app.run(port=4242)

<?php
// Using Slim.
use Slim\Http\Request;
use Slim\Http\Response;
use Stripe\Stripe;

require_once('vendor/autoload.php');

$app = new \Slim\App;

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
\Stripe\Stripe::setApiKey('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

$app->get('/', function (Request $request, Response $response, array $args) {
  // Display landing page.
  return $response->write(file_get_contents('./index.html'));
});

$app->get('/connect/oauth', function ($request, $response, $next) {
  extract($request->getQueryParams());

  // Assert the state matches the state you provided in the OAuth link (optional).
  if (!stateMatches($state))
    return $response->withStatus(403)->withJson(array('error' => 'Incorrect state parameter: ' . $state));

  // Send the authorization code to Stripe's API.
  $code = $request->getQueryParam('code');

  try {
    $stripeResponse = \Stripe\OAuth::token([
      'grant_type' => 'authorization_code',
      'code' => $code,
    ]);
  } catch (\Stripe\Error\OAuth\InvalidGrant $e) {
    return $response->withStatus(400)->withJson(array('error' => 'Invalid authorization code: ' . $code));
  } catch (Exception $e) {
    return $response->withStatus(500)->withJson(array('error' => 'An unknown error occurred.'));
  }

  $connectedAccountId = $stripeResponse->stripe_user_id;
  saveAccountId($connectedAccountId);

  // Render some HTML or redirect to a different page.
  return $response->withStatus(200)->withJson(array('success' => true));
});

function stateMatches($stateParameter) {
  // Load the same state value that you randomly generated for your OAuth link.
  $savedState = '{{ STATE }}';

  return $savedState == $stateParameter;
};

function saveAccountId($id) {
  // Save the connected account ID from the response to your database.
  echo 'Connected account ID: ' . $id;
};

$app->run();

// Using Express
const express = require('express');
const app = express();
app.use(express.json());
const { resolve } = require("path");

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
const stripe = require('stripe')('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

app.get("/", (req, res) => {
  // Display landing page.
  const path = resolve("./index.html");
  res.sendFile(path);
});

app.get("/connect/oauth", async (req, res) => {
  const { code, state } = req.query;

  // Assert the state matches the state you provided in the OAuth link (optional).
  if(!stateMatches(state)) {
    return res.status(403).json({ error: 'Incorrect state parameter: ' + state });
  }

  // Send the authorization code to Stripe's API.
  stripe.oauth.token({
    grant_type: 'authorization_code',
    code
  }).then(
    (response) => {
      var connected_account_id = response.stripe_user_id;
      saveAccountId(connected_account_id);

      // Render some HTML or redirect to a different page.
      return res.status(200).json({success: true});
    },
    (err) => {
      if (err.type === 'StripeInvalidGrantError') {
        return res.status(400).json({error: 'Invalid authorization code: ' + code});
      } else {
        return res.status(500).json({error: 'An unknown error occurred.'});
      }
    }
  );
});

const stateMatches = (state_parameter) => {
  // Load the same state value that you randomly generated for your OAuth link.
  const saved_state = 'sv_53124';

  return saved_state == state_parameter;
}

const saveAccountId = (id) => {
  // Save the connected account ID from the response to your database.
  console.log('Connected account ID: ' + id);
}

app.listen(4242, () => console.log(`Node server listening on port ${4242}!`));

package com.stripe.sample;

import com.google.gson.Gson;
import com.stripe.Stripe;
import com.stripe.net.OAuth;
import com.stripe.model.oauth.TokenResponse;
import com.stripe.exception.StripeException;
import com.stripe.exception.oauth.InvalidGrantException;
import spark.Response;

import java.nio.file.Paths;
import java.util.HashMap;
import java.util.Map;

// Using Spark.
import static spark.Spark.*;

import io.github.cdimascio.dotenv.Dotenv;

public class Server {
  private static Gson gson = new Gson();

  public static void main(String[] args) {
    port(4242);

    // Set your secret key. Remember to switch to your live secret key in production!
    // See your keys here: https://dashboard.stripe.com/account/apikeys
    Stripe.apiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

    staticFiles.externalLocation("../client");

    get("/connect/oauth", (request, response) -> {
      // Assert the state matches the state you provided in the OAuth link (optional).
      String state = request.queryParams("state");
      if (!stateMatches(state)) {
        return buildResponse(
          response, 403, "error", "Incorrect state parameter: " + state
        );
      }

      // Send the authorization code to Stripe's API.
      String code = request.queryParams("code");
      Map<String, Object> params = new HashMap<>();
      params.put("grant_type", "authorization_code");
      params.put("code", code);

      try {
        TokenResponse stripeResponse = OAuth.token(params, null);
        // Save the connected account ID from the response to your database.
        String connectedAccountId = stripeResponse.getStripeUserId();
        saveAccountId(connectedAccountId);

        // Render some HTML or redirect to a different page.
        return buildResponse(response, 200, "success", "Request succeeded.");
      } catch (InvalidGrantException e) {
        // There's a problem with the authorization code.
        return buildResponse(
          response, 400, "error", "Invalid authorization code: " + code
        );
      } catch (StripeException e) {
        // All other errors.
        return buildResponse(
          response, 500, "error", "An unknown error occurred."
        );
      }
    });
  }

  private static boolean stateMatches(String parameterState) {
    // Load the same state value that you randomly generated for your OAuth link.
    String savedState = "{{ STATE }}";

    return savedState.equals(parameterState);
  }

  private static void saveAccountId(String id) {
    System.out.println("Connected account ID: " + id);
  }

  private static String buildResponse(
    Response response, int statusCode, String type, String message
  ) {
    response.status(statusCode);
    Map<String, String> errorResponse = new HashMap<>();
    errorResponse.put(type, message);
    return gson.toJson(errorResponse);
  }
}

package main

import (
  "encoding/json"
  "log"
  "fmt"
  "net/http"

  "github.com/stripe/stripe-go/v71"
  "github.com/stripe/stripe-go/v71/oauth"

  "os"
)

type CreateOAuthResponse struct {
  Success      bool   `json:"success"`
}

func main() {
  // Set your secret key. Remember to switch to your live secret key in production!
  // See your keys here: https://dashboard.stripe.com/account/apikeys
  stripe.Key = "sk_test_4eC39HqLyjWDarjtT1zdp7dc"

  // Display landing page.
  fs := http.FileServer(http.Dir("static"))
  http.Handle("/", fs)

  http.HandleFunc("/connect/oauth", handleOauthRedirect)
  addr := "localhost:4242"

  log.Printf("Listening on %s ...", addr)
  log.Fatal(http.ListenAndServe(addr, nil))
}

func handleOauthRedirect(w http.ResponseWriter, r *http.Request) {
  query := r.URL.Query()

  // Assert the state matches the state you provided in the OAuth link (optional).
  state := query.Get("state")
  if !stateMatches(state, w) {
    http.Error(w, fmt.Sprintf("Invalid state parameter: %s", state), http.StatusForbidden)
    return
  }

  // Send the authorization code to Stripe's API.
  code := query.Get("code")
  params := &stripe.OAuthTokenParams{
    GrantType: stripe.String("authorization_code"),
    Code:      &code,
  }
  token, err := oauth.New(params)

  if  err != nil {
    stripeErr := err.(*stripe.Error)
    if (stripeErr.OAuthError == "invalid_grant") {
      http.Error(w, fmt.Sprintf("Invalid authorization code: %s", code), http.StatusBadRequest)
    } else {
      http.Error(w, "An unknown error occurred.", http.StatusInternalServerError)
    }
    return
  }

  connectedAccountId := token.StripeUserID
  saveAccountId(connectedAccountId)

      // Render some HTML or redirect to a different page.
  json.NewEncoder(w).Encode(CreateOAuthResponse{
    Success:      true,
  })
}

func stateMatches(state_parameter string, w http.ResponseWriter) bool {
  // Load the same state value that you randomly generated for your OAuth link.
  saved_state := "{{ STATE }}"

	return saved_state == state_parameter
}

func saveAccountId(id string) {
  // Save the connected account ID from the response to your database.
  log.Println("Connected account ID: " + id)
}

using System;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using Microsoft.AspNetCore.Http;

using Stripe;
using Newtonsoft.Json;

namespace Controllers
{
  public class ConnectController : Controller
  {
    private readonly StripeClient client;
    private readonly IOptions<StripeOptions> options;
    private readonly ILogger<ConnectController> logger;

    public ConnectController(
      IOptions<StripeOptions> options,
      ILogger<ConnectController> logger,
    ) {
      // Set your secret key: remember to switch to your live secret key in production
      // See your keys here: https://dashboard.stripe.com/account/apikeys
      this.client = new StripeClient("sk_test_4eC39HqLyjWDarjtT1zdp7dc");
      this.options = options;
      this.logger = logger;
    }

    [HttpGet("/connect/oauth")]
    public IActionResult HandleOAuthRedirect(
      [FromQuery] string state,
      [FromQuery] string code
    ) {
      var service = new OAuthTokenService(client);

      // Assert the state matches the state you provided in the OAuth link (optional).
      if (!StateMatches(state))
      {
        return StatusCode(
          StatusCodes.Status403Forbidden,
          Json(new { Error = String.Format("Incorrect state parameter: {0}", state) })
        );
      }

      // Send the authorization code to Stripe's API.
      var options = new OAuthTokenCreateOptions
      {
        GrantType = "authorization_code",
        Code = code,
      };

      OAuthToken response = null;

      try
      {
        response = service.Create(options);
      }
      catch (StripeException e)
      {
        if (e.StripeError != null && e.StripeError.Error == "invalid_grant") {
          return StatusCode(
            StatusCodes.Status400BadRequest,
            Json(new { Error = String.Format("Invalid authorization code: {0}", code) })
          );
        } else {
          return StatusCode(
            StatusCodes.Status500InternalServerError,
            Json(new { Error = "An unknown error occurred." })
          );
        }
      }

      var connectedAccountId = response.StripeUserId;
      SaveAccountId(connectedAccountId);

      // Render some HTML or redirect to a different page.
      return new OkObjectResult(Json(new { Success = true }));
    }

    private bool StateMatches(string stateParameter)
    {
      // Load the same state value that you randomly generated for your OAuth link.
      var savedState = "{{ STATE }}";

      return savedState == stateParameter;
    }

    private void SaveAccountId(string id)
    {
      // Save the connected account ID from the response to your database.
      logger.LogInformation($"Connected account ID: {id}");
    }
  }
}

# Available as a gem
sudo gem install stripe

# If you use bundler, you can add this line to your Gemfile
gem 'stripe'

# Install through pip
pip install --upgrade stripe

# Or find the Stripe package on http://pypi.python.org/pypi/stripe/

# Install the PHP library via Composer
composer require stripe/stripe-php

# Or download the source directly: https://github.com/stripe/stripe-php/releases

/*
 For Gradle, add the following dependency to your build.gradle and replace {VERSION} with
 the version number you want to use from
 - https://mvnrepository.com/artifact/com.stripe/stripe-java or
 - https://github.com/stripe/stripe-java/releases/latest
*/
implementation "com.stripe:stripe-java:{VERSION}"

<!--
  For Maven, add the following dependency to your POM and replace {VERSION} with the
  version number you want to use from
  - https://mvnrepository.com/artifact/com.stripe/stripe-java or
  - https://github.com/stripe/stripe-java/releases/latest
-->
<dependency>
  <groupId>com.stripe</groupId>
  <artifactId>stripe-java</artifactId>
  <version>{VERSION}</version>
</dependency>

# For other environments, manually install the following JARs:
# - The Stripe JAR from https://github.com/stripe/stripe-java/releases/latest
# - Google Gson from https://github.com/google/gson

# Install via npm
npm install --save stripe

# Install stripe-go
go get -u github.com/stripe/stripe-go

// Then import the package
import (
  "github.com/stripe/stripe-go/v71"
)

# Install via dotnet
dotnet add package Stripe.net
dotnet restore

# Or install via NuGet
PM> Install-Package Stripe.net

import UIKit
import Stripe

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
        Stripe.setDefaultPublishableKey("pk_test_TYooMQauvdEDq54NiTphI7jx")
        // do any other necessary launch configuration
        return true
    }
}

#import "AppDelegate.h"
#import <Stripe/Stripe.h>

@implementation AppDelegate
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
    [Stripe setDefaultPublishableKey:@"pk_test_TYooMQauvdEDq54NiTphI7jx"];
    // do any other necessary launch configuration
    return YES;
}
@end

import UIKit
import SafariServices

class ConnectOnboardViewController: UIViewController {

    let state: String // generate a unique value for this
    let clientID: String // the client ID found in your platform settings

    // ...

    override func viewDidLoad() {
        super.viewDidLoad()

        let connectWithStripeButton = UIButton(type: .system)
        connectWithStripeButton.setTitle("Connect with Stripe", for: .normal)
        connectWithStripeButton.addTarget(self, action: #selector(didSelectConnectWithStripe), for: .touchUpInside)
        view.addSubview(connectWithStripeButton)

        // ...
    }

    @objc
    func didSelectConnectWithStripe() {
        // set the redirect_uri to a deep link back into your app to automatically
        // detect when the user has completed the onboarding flow
        let redirect = "https://www.example.com/connect-onboard-redirect"

        // Construct authorization URL
        guard let authorizationURL = URL(string: "https://connect.stripe.com/oauth/authorize?client_id=\(clientID)&state=\(state)&scope=read_write&response_type=code&redirect_uri=\(redirect)") else {
            return
        }

        let safariViewController = SFSafariViewController(url: authorizationURL)
        safariViewController.delegate = self

        present(safariViewController, animated: true, completion: nil)
    }

    // ...
}

extension ConnectOnboardViewController: SFSafariViewControllerDelegate {
    func safariViewControllerDidFinish(_ controller: SFSafariViewController) {
        // the user may have closed the SFSafirViewController instance before a redirect
        // occurred. Sync with your backend to confirm the correct state
    }
}

#import "ConnectOnboardViewController.h"

#import <SafariServices/SafariServices.h>

@interface ConnectOnboardViewController () <SFSafariViewControllerDelegate>
// ...
@end

@implementation ConnectOnboardViewController {
    NSString *_state; // generate a unique value for this
}

// ...

- (void)viewDidLoad {
    [super viewDidLoad];

    UIButton *connectWithStripeButton = [UIButton buttonWithType:UIButtonTypeSystem];
    [connectWithStripeButton setTitle:@"Connect with Stripe" forState:UIControlStateNormal];
    [connectWithStripeButton addTarget:self action:@selector(_didSelectConnectWithStripe) forControlEvents:UIControlEventTouchUpInside];
    [self.view addSubview:connectWithStripeButton];

    // ...
}

- (void)_didSelectConnectWithStripe {

    // set the redirect_uri to a deep link back into your app to automatically
    // detect when the user has completed the onboarding flow
    NSString *redirect = @"https://www.example.com/connect-onboard-redirect"

    NSString *clientID = @"ca_32D88BD1qLklliziD7gYQvctJIhWBSQ7"; // this is a test ID

    NSString *urlString = [NSString stringWithFormat:@"https://connect.stripe.com/oauth/authorize?client_id=%@&state=%@&scope=read_write&response_type=code&redirect_uri=%@", clientID, _state, redirect];

    NSURL *connectAccountURL = [NSURL URLWithString:urlString];

    if (connectAccountURL != nil) {
        SFSafariViewController *safariViewController = [[SFSafariViewController alloc] initWithURL:connectAccountURL];
        safariViewController.delegate = self;

        [self presentViewController:safariViewController animated:YES completion:nil];
    }
}

// ...

#pragma mark - SFSafariViewControllerDelegate
- (void)safariViewControllerDidFinish:(SFSafariViewController *)controller {
    // The user may have closed the SFSafariViewController instance before a redirect
    // occurred. Sync with your backend to confirm the correct state
}

@end

curl https://connect.stripe.com/oauth/token \
  -u sk_test_4eC39HqLyjWDarjtT1zdp7dc: \
  -d code=ac_123456789 \
  -d grant_type=authorization_code

# Using Sinatra.
require 'sinatra'
require 'stripe'

set :port, 4242

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

get '/' do
  # Display landing page.
  content_type 'text/html'
  send_file File.join('./index.html')
end

get '/connect/oauth' do
  content_type 'application/json'

  # Assert the state matches the state you provided in the OAuth link (optional).
  state = params[:state]
  if !state_matches?(state)
    status 403
    return {error: 'Incorrect state parameter: ' + state}.to_json
  end

  # Send the authorization code to Stripe's API.
  code = params[:code]
  begin
    response = Stripe::OAuth.token({
      grant_type: 'authorization_code',
      code: code,
    })
  rescue Stripe::OAuth::InvalidGrantError
    status 400
    return {error: 'Invalid authorization code: ' + code}.to_json
  rescue Stripe::StripeError
    status 500
    return {error: 'An unknown error occurred.'}.to_json
  end

  connected_account_id = response.stripe_user_id
  save_account_id(connected_account_id)

  # Render some HTML or redirect to a different page.
  status 200
  {success: true}.to_json
end

def state_matches?(state_parameter)
  # Load the same state value that you randomly generated for your OAuth link.
  saved_state = '{{ STATE }}'

  saved_state == state_parameter
end

def save_account_id(id)
  # Save the connected account ID from the response to your database.
  puts 'Connected account ID: ' + id
end

import stripe
import json

# Using Flask.
from flask import (
    Flask,
    render_template,
    request,
)

app = Flask(__name__, static_folder=".",
            static_url_path="", template_folder=".")

@app.route('/', methods=['GET'])
def get_example():
  # Display landing page.
  return render_template('index.html')

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

@app.route("/connect/oauth", methods=["GET"])
def handle_oauth_redirect():
  # Assert the state matches the state you provided in the OAuth link (optional).
  state = request.args.get("state")

  if not state_matches(state):
    return json.dumps({"error": "Incorrect state parameter: " + state}), 403

  # Send the authorization code to Stripe's API.
  code = request.args.get("code")
  try:
    response = stripe.OAuth.token(grant_type="authorization_code", code=code,)
  except stripe.oauth_error.OAuthError as e:
    return json.dumps({"error": "Invalid authorization code: " + code}), 400
  except Exception as e:
    return json.dumps({"error": "An unknown error occurred."}), 500

  connected_account_id = response["stripe_user_id"]
  save_account_id(connected_account_id)

  # Render some HTML or redirect to a different page.
  return json.dumps({"success": True}), 200

def state_matches(state_parameter):
  # Load the same state value that you randomly generated for your OAuth link.
  saved_state = "{{ STATE }}"

  return saved_state == state_parameter

def save_account_id(id):
  # Save the connected account ID from the response to your database.
  print("Connected account ID: ", id)

if __name__ == "__main__":
    app.run(port=4242)

<?php
// Using Slim.
use Slim\Http\Request;
use Slim\Http\Response;
use Stripe\Stripe;

require_once('vendor/autoload.php');

$app = new \Slim\App;

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
\Stripe\Stripe::setApiKey('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

$app->get('/', function (Request $request, Response $response, array $args) {
  // Display landing page.
  return $response->write(file_get_contents('./index.html'));
});

$app->get('/connect/oauth', function ($request, $response, $next) {
  extract($request->getQueryParams());

  // Assert the state matches the state you provided in the OAuth link (optional).
  if (!stateMatches($state))
    return $response->withStatus(403)->withJson(array('error' => 'Incorrect state parameter: ' . $state));

  // Send the authorization code to Stripe's API.
  $code = $request->getQueryParam('code');

  try {
    $stripeResponse = \Stripe\OAuth::token([
      'grant_type' => 'authorization_code',
      'code' => $code,
    ]);
  } catch (\Stripe\Error\OAuth\InvalidGrant $e) {
    return $response->withStatus(400)->withJson(array('error' => 'Invalid authorization code: ' . $code));
  } catch (Exception $e) {
    return $response->withStatus(500)->withJson(array('error' => 'An unknown error occurred.'));
  }

  $connectedAccountId = $stripeResponse->stripe_user_id;
  saveAccountId($connectedAccountId);

  // Render some HTML or redirect to a different page.
  return $response->withStatus(200)->withJson(array('success' => true));
});

function stateMatches($stateParameter) {
  // Load the same state value that you randomly generated for your OAuth link.
  $savedState = '{{ STATE }}';

  return $savedState == $stateParameter;
};

function saveAccountId($id) {
  // Save the connected account ID from the response to your database.
  echo 'Connected account ID: ' . $id;
};

$app->run();

// Using Express
const express = require('express');
const app = express();
app.use(express.json());
const { resolve } = require("path");

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
const stripe = require('stripe')('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

app.get("/", (req, res) => {
  // Display landing page.
  const path = resolve("./index.html");
  res.sendFile(path);
});

app.get("/connect/oauth", async (req, res) => {
  const { code, state } = req.query;

  // Assert the state matches the state you provided in the OAuth link (optional).
  if(!stateMatches(state)) {
    return res.status(403).json({ error: 'Incorrect state parameter: ' + state });
  }

  // Send the authorization code to Stripe's API.
  stripe.oauth.token({
    grant_type: 'authorization_code',
    code
  }).then(
    (response) => {
      var connected_account_id = response.stripe_user_id;
      saveAccountId(connected_account_id);

      // Render some HTML or redirect to a different page.
      return res.status(200).json({success: true});
    },
    (err) => {
      if (err.type === 'StripeInvalidGrantError') {
        return res.status(400).json({error: 'Invalid authorization code: ' + code});
      } else {
        return res.status(500).json({error: 'An unknown error occurred.'});
      }
    }
  );
});

const stateMatches = (state_parameter) => {
  // Load the same state value that you randomly generated for your OAuth link.
  const saved_state = 'sv_53124';

  return saved_state == state_parameter;
}

const saveAccountId = (id) => {
  // Save the connected account ID from the response to your database.
  console.log('Connected account ID: ' + id);
}

app.listen(4242, () => console.log(`Node server listening on port ${4242}!`));

package com.stripe.sample;

import com.google.gson.Gson;
import com.stripe.Stripe;
import com.stripe.net.OAuth;
import com.stripe.model.oauth.TokenResponse;
import com.stripe.exception.StripeException;
import com.stripe.exception.oauth.InvalidGrantException;
import spark.Response;

import java.nio.file.Paths;
import java.util.HashMap;
import java.util.Map;

// Using Spark.
import static spark.Spark.*;

import io.github.cdimascio.dotenv.Dotenv;

public class Server {
  private static Gson gson = new Gson();

  public static void main(String[] args) {
    port(4242);

    // Set your secret key. Remember to switch to your live secret key in production!
    // See your keys here: https://dashboard.stripe.com/account/apikeys
    Stripe.apiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

    staticFiles.externalLocation("../client");

    get("/connect/oauth", (request, response) -> {
      // Assert the state matches the state you provided in the OAuth link (optional).
      String state = request.queryParams("state");
      if (!stateMatches(state)) {
        return buildResponse(
          response, 403, "error", "Incorrect state parameter: " + state
        );
      }

      // Send the authorization code to Stripe's API.
      String code = request.queryParams("code");
      Map<String, Object> params = new HashMap<>();
      params.put("grant_type", "authorization_code");
      params.put("code", code);

      try {
        TokenResponse stripeResponse = OAuth.token(params, null);
        // Save the connected account ID from the response to your database.
        String connectedAccountId = stripeResponse.getStripeUserId();
        saveAccountId(connectedAccountId);

        // Render some HTML or redirect to a different page.
        return buildResponse(response, 200, "success", "Request succeeded.");
      } catch (InvalidGrantException e) {
        // There's a problem with the authorization code.
        return buildResponse(
          response, 400, "error", "Invalid authorization code: " + code
        );
      } catch (StripeException e) {
        // All other errors.
        return buildResponse(
          response, 500, "error", "An unknown error occurred."
        );
      }
    });
  }

  private static boolean stateMatches(String parameterState) {
    // Load the same state value that you randomly generated for your OAuth link.
    String savedState = "{{ STATE }}";

    return savedState.equals(parameterState);
  }

  private static void saveAccountId(String id) {
    System.out.println("Connected account ID: " + id);
  }

  private static String buildResponse(
    Response response, int statusCode, String type, String message
  ) {
    response.status(statusCode);
    Map<String, String> errorResponse = new HashMap<>();
    errorResponse.put(type, message);
    return gson.toJson(errorResponse);
  }
}

package main

import (
  "encoding/json"
  "log"
  "fmt"
  "net/http"

  "github.com/stripe/stripe-go/v71"
  "github.com/stripe/stripe-go/v71/oauth"

  "os"
)

type CreateOAuthResponse struct {
  Success      bool   `json:"success"`
}

func main() {
  // Set your secret key. Remember to switch to your live secret key in production!
  // See your keys here: https://dashboard.stripe.com/account/apikeys
  stripe.Key = "sk_test_4eC39HqLyjWDarjtT1zdp7dc"

  // Display landing page.
  fs := http.FileServer(http.Dir("static"))
  http.Handle("/", fs)

  http.HandleFunc("/connect/oauth", handleOauthRedirect)
  addr := "localhost:4242"

  log.Printf("Listening on %s ...", addr)
  log.Fatal(http.ListenAndServe(addr, nil))
}

func handleOauthRedirect(w http.ResponseWriter, r *http.Request) {
  query := r.URL.Query()

  // Assert the state matches the state you provided in the OAuth link (optional).
  state := query.Get("state")
  if !stateMatches(state, w) {
    http.Error(w, fmt.Sprintf("Invalid state parameter: %s", state), http.StatusForbidden)
    return
  }

  // Send the authorization code to Stripe's API.
  code := query.Get("code")
  params := &stripe.OAuthTokenParams{
    GrantType: stripe.String("authorization_code"),
    Code:      &code,
  }
  token, err := oauth.New(params)

  if  err != nil {
    stripeErr := err.(*stripe.Error)
    if (stripeErr.OAuthError == "invalid_grant") {
      http.Error(w, fmt.Sprintf("Invalid authorization code: %s", code), http.StatusBadRequest)
    } else {
      http.Error(w, "An unknown error occurred.", http.StatusInternalServerError)
    }
    return
  }

  connectedAccountId := token.StripeUserID
  saveAccountId(connectedAccountId)

      // Render some HTML or redirect to a different page.
  json.NewEncoder(w).Encode(CreateOAuthResponse{
    Success:      true,
  })
}

func stateMatches(state_parameter string, w http.ResponseWriter) bool {
  // Load the same state value that you randomly generated for your OAuth link.
  saved_state := "{{ STATE }}"

	return saved_state == state_parameter
}

func saveAccountId(id string) {
  // Save the connected account ID from the response to your database.
  log.Println("Connected account ID: " + id)
}

using System;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using Microsoft.AspNetCore.Http;

using Stripe;
using Newtonsoft.Json;

namespace Controllers
{
  public class ConnectController : Controller
  {
    private readonly StripeClient client;
    private readonly IOptions<StripeOptions> options;
    private readonly ILogger<ConnectController> logger;

    public ConnectController(
      IOptions<StripeOptions> options,
      ILogger<ConnectController> logger,
    ) {
      // Set your secret key: remember to switch to your live secret key in production
      // See your keys here: https://dashboard.stripe.com/account/apikeys
      this.client = new StripeClient("sk_test_4eC39HqLyjWDarjtT1zdp7dc");
      this.options = options;
      this.logger = logger;
    }

    [HttpGet("/connect/oauth")]
    public IActionResult HandleOAuthRedirect(
      [FromQuery] string state,
      [FromQuery] string code
    ) {
      var service = new OAuthTokenService(client);

      // Assert the state matches the state you provided in the OAuth link (optional).
      if (!StateMatches(state))
      {
        return StatusCode(
          StatusCodes.Status403Forbidden,
          Json(new { Error = String.Format("Incorrect state parameter: {0}", state) })
        );
      }

      // Send the authorization code to Stripe's API.
      var options = new OAuthTokenCreateOptions
      {
        GrantType = "authorization_code",
        Code = code,
      };

      OAuthToken response = null;

      try
      {
        response = service.Create(options);
      }
      catch (StripeException e)
      {
        if (e.StripeError != null && e.StripeError.Error == "invalid_grant") {
          return StatusCode(
            StatusCodes.Status400BadRequest,
            Json(new { Error = String.Format("Invalid authorization code: {0}", code) })
          );
        } else {
          return StatusCode(
            StatusCodes.Status500InternalServerError,
            Json(new { Error = "An unknown error occurred." })
          );
        }
      }

      var connectedAccountId = response.StripeUserId;
      SaveAccountId(connectedAccountId);

      // Render some HTML or redirect to a different page.
      return new OkObjectResult(Json(new { Success = true }));
    }

    private bool StateMatches(string stateParameter)
    {
      // Load the same state value that you randomly generated for your OAuth link.
      var savedState = "{{ STATE }}";

      return savedState == stateParameter;
    }

    private void SaveAccountId(string id)
    {
      // Save the connected account ID from the response to your database.
      logger.LogInformation($"Connected account ID: {id}");
    }
  }
}

import UIKit
import Stripe

class CheckoutViewController: UIViewController {

    lazy var cardTextField: STPPaymentCardTextField = {
        let cardTextField = STPPaymentCardTextField()
        return cardTextField
    }()
    lazy var payButton: UIButton = {
        let button = UIButton(type: .custom)
        button.layer.cornerRadius = 5
        button.backgroundColor = .systemBlue
        button.titleLabel?.font = UIFont.systemFont(ofSize: 22)
        button.setTitle("Pay", for: .normal)
        button.addTarget(self, action: #selector(pay), for: .touchUpInside)
        return button
    }()

    override func viewDidLoad() {
        super.viewDidLoad()
        view.backgroundColor = .white
        let stackView = UIStackView(arrangedSubviews: [cardTextField, payButton])
        stackView.axis = .vertical
        stackView.spacing = 20
        stackView.translatesAutoresizingMaskIntoConstraints = false
        view.addSubview(stackView)
        NSLayoutConstraint.activate([
            stackView.leftAnchor.constraint(equalToSystemSpacingAfter: view.leftAnchor, multiplier: 2),
            view.rightAnchor.constraint(equalToSystemSpacingAfter: stackView.rightAnchor, multiplier: 2),
            stackView.topAnchor.constraint(equalToSystemSpacingBelow: view.topAnchor, multiplier: 2),
        ])
    }

    @objc
    func pay() {
        // ...
    }
}

#import "CheckoutViewController.h"
#import <Stripe/Stripe.h>

@interface CheckoutViewController ()

@property (weak) STPPaymentCardTextField *cardTextField;
@property (weak) UIButton *payButton;

@end

@implementation CheckoutViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    self.view.backgroundColor = [UIColor whiteColor];

    STPPaymentCardTextField *cardTextField = [[STPPaymentCardTextField alloc] init];
    self.cardTextField = cardTextField;

    UIButton *button = [UIButton buttonWithType:UIButtonTypeCustom];
    button.layer.cornerRadius = 5;
    button.backgroundColor = [UIColor systemBlueColor];
    button.titleLabel.font = [UIFont systemFontOfSize:22];
    [button setTitle:@"Pay" forState:UIControlStateNormal];
    [button addTarget:self action:@selector(pay) forControlEvents:UIControlEventTouchUpInside];
    self.payButton = button;

    UIStackView *stackView = [[UIStackView alloc] initWithArrangedSubviews:@[cardTextField, button]];
    stackView.axis = UILayoutConstraintAxisVertical;
    stackView.translatesAutoresizingMaskIntoConstraints = NO;
    stackView.spacing = 20;
    [self.view addSubview:stackView];

    [NSLayoutConstraint activateConstraints:@[
        [stackView.leftAnchor constraintEqualToSystemSpacingAfterAnchor:self.view.leftAnchor multiplier:2],
        [self.view.rightAnchor constraintEqualToSystemSpacingAfterAnchor:stackView.rightAnchor multiplier:2],
        [stackView.topAnchor constraintEqualToSystemSpacingBelowAnchor:self.view.topAnchor multiplier:2],
    ]];
}

- (void)pay {
    // ...
}

@end

curl https://api.stripe.com/v1/payment_intents \
  -u sk_test_4eC39HqLyjWDarjtT1zdp7dc: \
  -d "payment_method_types[]"=card \
  -d amount=1000 \
  -d currency=usd \
  -d application_fee_amount=123 \
  -H "Stripe-Account: {{CONNECTED_STRIPE_ACCOUNT_ID}}"

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

payment_intent = Stripe::PaymentIntent.create({
  payment_method_types: ['card'],
  amount: 1000,
  currency: 'usd',
  application_fee_amount: 123,
}, stripe_account: '{{CONNECTED_STRIPE_ACCOUNT_ID}}')
client_secret = payment_intent['client_secret']
# Pass the client secret to the client

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

payment_intent = stripe.PaymentIntent.create(
  payment_method_types=['card'],
  amount=1000,
  currency='usd',
  application_fee_amount=123,
  stripe_account='{{CONNECTED_STRIPE_ACCOUNT_ID}}',
)
client_secret = intent.client_secret
# Pass the client secret to the client

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
\Stripe\Stripe::setApiKey('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

$payment_intent = \Stripe\PaymentIntent::create([
  'payment_method_types' => ['card'],
  'amount' => 1000,
  'currency' => 'usd',
  'application_fee_amount' => 123,
], ['stripe_account' => '{{CONNECTED_STRIPE_ACCOUNT_ID}}']);
$client_secret = $intent->client_secret;
// Pass the client secret to the client

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.apiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

ArrayList paymentMethodTypes = new ArrayList();
paymentMethodTypes.add("card");

Map<String, Object> params = new HashMap<>();
params.put("payment_method_types", paymentMethodTypes);
params.put("amount", 1000);
params.put("currency", "usd");
params.put("application_fee_amount", 123);

RequestOptions requestOptions = RequestOptions.builder().setStripeAccount({{CONNECTED_STRIPE_ACCOUNT_ID}}).build();
PaymentIntent paymentIntent = PaymentIntent.create(params, requestOptions);
PaymentIntent intent = PaymentIntent.create(params);
String clientSecret = intent.getClientSecret();
// Pass the client secret to the client

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
const stripe = require('stripe')('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

const paymentIntent = await stripe.paymentIntents.create({
  payment_method_types: ['card'],
  amount: 1000,
  currency: 'usd',
  application_fee_amount: 123,
}, {
  stripeAccount: '{{CONNECTED_STRIPE_ACCOUNT_ID}}',
});
const clientSecret = paymentIntent.client_secret;

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.Key = "sk_test_4eC39HqLyjWDarjtT1zdp7dc"

params := &stripe.PaymentIntentParams{
  PaymentMethodTypes: stripe.StringSlice([]string{
    "card",
  }),
  Amount: stripe.Int64(1000),
  Currency: stripe.String(string(stripe.CurrencyUSD)),
  ApplicationFeeAmount: stripe.Int64(123),
}
params.SetStripeAccount("{{CONNECTED_STRIPE_ACCOUNT_ID}}")
pi, _ := paymentintent.New(params)
// Pass the client secret to the client

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
StripeConfiguration.ApiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

var service = new PaymentIntentService();
var createOptions = new PaymentIntentCreateOptions
{
  PaymentMethodTypes = new List<string>
  {
    "card",
  },
  Amount = 2000,
  Currency = "usd",
  ApplicationFeeAmount = 123,
};

var requestOptions = new RequestOptions();
requestOptions.StripeAccount = "{{CONNECTED_STRIPE_ACCOUNT_ID}}";
service.Create(createOptions, requestOptions);
// Pass the client secret to the client

import UIKit
import Stripe

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
        Stripe.setDefaultPublishableKey("{{PLATFORM_PUBLISHABLE_KEY}}")
        STPAPIClient.shared().stripeAccount = "{{CONNECTED_STRIPE_ACCOUNT_ID}}"

        // For SDK versions < v19.0.0, set this too:
        STPPaymentConfiguration.shared().stripeAccount = "{{CONNECTED_STRIPE_ACCOUNT_ID}}"
        return true
    }
}

#import "AppDelegate.h"
#import <Stripe/Stripe.h>

@implementation AppDelegate
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
    [Stripe setDefaultPublishableKey:@"{{PLATFORM_PUBLISHABLE_KEY}}"];
    [STPAPIClient sharedClient] setStripeAccount:@"{{CONNECTED_STRIPE_ACCOUNT_ID}}"];

    // For SDK versions < v19.0.0, set this too:
    [[STPPaymentConfiguration sharedConfiguration] setStripeAccount:@"{{CONNECTED_STRIPE_ACCOUNT_ID}}"];
    return YES;
}
@end

class CheckoutViewController: UIViewController {
    var paymentIntentClientSecret: String?

    // ...continued from previous step

    override func viewDidLoad() {
        // ...continued from previous step
        startCheckout()
    }

    func startCheckout() {
        // Request a PaymentIntent from your server and store its client secret
        // Click Open on GitHub to see a full implementation
    }
}

@interface CheckoutViewController ()

// ...continued from previous step
@property (strong) NSString *paymentIntentClientSecret;

@end

@implementation CheckoutViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    // ...continued from previous step
    [self startCheckout];
}

- (void)startCheckout {
    // Request a PaymentIntent from your server and store its client secret
    // Click Open on GitHub to see a full implementation
}

@end

class CheckoutViewController: UIViewController {

    // ...

    @objc
    func pay() {
        guard let paymentIntentClientSecret = paymentIntentClientSecret else {
            return;
        }
        // Collect card details
        let cardParams = cardTextField.cardParams
        let paymentMethodParams = STPPaymentMethodParams(card: cardParams, billingDetails: nil, metadata: nil)
        let paymentIntentParams = STPPaymentIntentParams(clientSecret: paymentIntentClientSecret)
        paymentIntentParams.paymentMethodParams = paymentMethodParams

        // Submit the payment
        let paymentHandler = STPPaymentHandler.shared()
        paymentHandler.confirmPayment(withParams: paymentIntentParams, authenticationContext: self) { (status, paymentIntent, error) in
            switch (status) {
            case .failed:
                self.displayAlert(title: "Payment failed", message: error?.localizedDescription ?? "")
                break
            case .canceled:
                self.displayAlert(title: "Payment canceled", message: error?.localizedDescription ?? "")
                break
            case .succeeded:
                self.displayAlert(title: "Payment succeeded", message: paymentIntent?.description ?? "", restartDemo: true)
                break
            @unknown default:
                fatalError()
                break
            }
        }
    }
}

extension CheckoutViewController: STPAuthenticationContext {
    func authenticationPresentingViewController() -> UIViewController {
        return self
    }
}

@interface CheckoutViewController ()  <STPAuthenticationContext>

// ...

@end

@implementation CheckoutViewController

// ...

- (void)pay {
    if (!self.paymentIntentClientSecret) {
        NSLog(@"PaymentIntent hasn't been created");
        return;
    }

    // Collect card details
    STPPaymentMethodCardParams *cardParams = self.cardTextField.cardParams;
    STPPaymentMethodParams *paymentMethodParams = [STPPaymentMethodParams paramsWithCard:cardParams billingDetails:nil metadata:nil];
    STPPaymentIntentParams *paymentIntentParams = [[STPPaymentIntentParams alloc] initWithClientSecret:self.paymentIntentClientSecret];
    paymentIntentParams.paymentMethodParams = paymentMethodParams;

    // Submit the payment
    STPPaymentHandler *paymentHandler = [STPPaymentHandler sharedHandler];
    [paymentHandler confirmPayment:paymentIntentParams withAuthenticationContext:self completion:^(STPPaymentHandlerActionStatus status, STPPaymentIntent *paymentIntent, NSError *error) {
        dispatch_async(dispatch_get_main_queue(), ^{
            switch (status) {
                case STPPaymentHandlerActionStatusFailed: {
                    [self displayAlertWithTitle:@"Payment failed" message:error.localizedDescription ?: @"" restartDemo:NO];
                    break;
                }
                case STPPaymentHandlerActionStatusCanceled: {
                    [self displayAlertWithTitle:@"Payment canceled" message:error.localizedDescription ?: @"" restartDemo:NO];
                    break;
                }
                case STPPaymentHandlerActionStatusSucceeded: {
                    [self displayAlertWithTitle:@"Payment succeeded" message:paymentIntent.description ?: @"" restartDemo:YES];
                    break;
                }
                default:
                    break;
            }
        });
    }];
}

# pragma mark STPAuthenticationContext
- (UIViewController *)authenticationPresentingViewController {
    return self;
}

@end

# Using Sinatra.
require 'sinatra'
require 'stripe'

set :port, 4242

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

# Uncomment and replace with a real secret. You can find your endpoint's
# secret in your webhook settings.
# webhook_secret = 'whsec_...'

post '/webhook' do
  payload = request.body.read
  sig_header = request.env['HTTP_STRIPE_SIGNATURE']

  event = nil

  # Verify webhook signature and extract the event.
  # See https://stripe.com/docs/webhooks/signatures for more information.
  begin
    event = Stripe::Webhook.construct_event(
      payload, sig_header, webhook_secret
    )
  rescue JSON::ParserError => e
    # Invalid payload.
    status 400
    return
  rescue Stripe::SignatureVerificationError => e
    # Invalid Signature.
    status 400
    return
  end

  if event['type'] == 'payment_intent.succeeded'
    payment_intent = event['data']['object']
    connected_account_id = event['account']
    handle_successful_payment_intent(connected_account_id, payment_intent)
  end

  status 200
end

def handle_successful_payment_intent(connected_account_id, payment_intent)
  # Fulfill the purchase.
  puts 'Connected account ID: ' + connected_account_id
  puts 'PaymentIntent: ' + payment_intent.to_s
end

import stripe
import json

# Using Flask.
from flask import (
    Flask,
    render_template,
    request,
    Response,
)

app = Flask(__name__, static_folder=".",
            static_url_path="", template_folder=".")

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

# Uncomment and replace with a real secret. You can find your endpoint's
# secret in your webhook settings.
# webhook_secret = 'whsec_...'

@app.route("/webhook", methods=["POST"])
def webhook_received():
  request_data = json.loads(request.data)
  signature = request.headers.get("stripe-signature")

  # Verify webhook signature and extract the event.
  # See https://stripe.com/docs/webhooks/signatures for more information.
  try:
    event = stripe.Webhook.construct_event(
        payload=request.data, sig_header=signature, secret=webhook_secret
    )
  except ValueError as e:
    # Invalid payload.
    return Response(status=400)
  except stripe.error.SignatureVerificationError as e:
    # Invalid Signature.
    return Response(status=400)

  if event["type"] == "payment_intent.succeeded":
    payment_intent = event["data"]["object"]
    connected_account_id = event["account"]
    handle_successful_payment_intent(connected_account_id, payment_intent)

  return json.dumps({"success": True}), 200

def handle_successful_payment_intent(connected_account_id, payment_intent):
  # Fulfill the purchase.
  print('Connected account ID: ' + connected_account_id)
  print('PaymentIntent: ' + str(payment_intent))

if __name__ == "__main__":
  app.run(port=4242)

<?php
// Using Slim.
use Slim\Http\Request;
use Slim\Http\Response;
use Stripe\Stripe;

require_once('vendor/autoload.php');

$app = new \Slim\App;

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
\Stripe\Stripe::setApiKey('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

// Uncomment and replace with a real secret. You can find your endpoint's
// secret in your webhook settings.
// $webhook_secret = 'whsec_...';

$app->post('/webhook', function ($request, $response, $next) {
  $payload = $request->getBody();
  $sig_header = $request->getHeaderLine('stripe-signature');

  $event = null;

  // Verify webhook signature and extract the event.
  // See https://stripe.com/docs/webhooks/signatures for more information.
  try {
    $event = \Stripe\Webhook::constructEvent(
      $payload, $sig_header, $webhook_secret
    );
  } catch(\UnexpectedValueException $e) {
    // Invalid payload.
    return $response->withStatus(400);
  } catch(\Stripe\Exception\SignatureVerificationException $e) {
    // Invalid Signature.
    return $response->withStatus(400);
  }

  if ($event->type == 'payment_intent.succeeded') {
    $paymentIntent = $event->data->object;
    $connectedAccountId = $event->account;
    handleSuccessfulPaymentIntent($connectedAccountId, $paymentIntent);
  }

  return $response->withStatus(200);
});

function handleSuccessfulPaymentIntent($connectedAccountId, $paymentIntent) {
  // Fulfill the purchase.
  echo 'Connected account ID: ' . $connectedAccountId;
  echo 'PaymentIntent: ' . $paymentIntent;
};

$app->run();

// Using Express
const express = require('express');
const bodyParser = require("body-parser");
const app = express();
app.use(express.json());

// Use JSON parser for all non-webhook routes
app.use((req, res, next) => {
  if (req.originalUrl === "/webhook") {
    next();
  } else {
    bodyParser.json()(req, res, next);
  }
});

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
const stripe = require('stripe')('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

// Uncomment and replace with a real secret. You can find your endpoint's
// secret in your webhook settings.
// const webhook_secret = 'whsec_...''

app.post('/webhook', bodyParser.raw({type: 'application/json'}), (request, response) => {
  const sig = request.headers['stripe-signature'];

  let event;

  // Verify webhook signature and extract the event.
  // See https://stripe.com/docs/webhooks/signatures for more information.
  try {
    event = stripe.webhooks.constructEvent(request.body, sig, webhook_secret);
  } catch (err) {
    return response.status(400).send(`Webhook Error: ${err.message}`);
  }

  if (event.type === 'payment_intent.succeeded') {
    const paymentIntent = event.data.object;
    const connectedAccountId = event.account;
    handleSuccessfulPaymentIntent(connectedAccountId, paymentIntent);
  }

  response.json({received: true});
});

const handleSuccessfulPaymentIntent = (connectedAccountId, paymentIntent) => {
    // Fulfill the purchase.
  console.log('Connected account ID: ' + connectedAccountId);
  console.log('PaymentIntent: ' + JSON.stringify(paymentIntent));
}

app.listen(4242, () => console.log(`Node server listening on port ${4242}!`));

package com.stripe.sample;

import com.stripe.Stripe;
import com.stripe.model.PaymentIntent;
import com.stripe.model.Event;
import com.stripe.model.EventDataObjectDeserializer;
import com.stripe.exception.SignatureVerificationException;
import com.stripe.net.Webhook;
import com.google.gson.JsonSyntaxException;
import spark.Response;

// Using Spark.
import static spark.Spark.*;

public class Server {
  public static void main(String[] args) {
    port(4242);

    // Set your secret key. Remember to switch to your live secret key in production!
    // See your keys here: https://dashboard.stripe.com/account/apikeys
    Stripe.apiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";
    post("/webhook", (request, response) -> {
      String payload = request.body();
      String sigHeader = request.headers("Stripe-Signature");

      // Uncomment and replace with a real secret. You can find your endpoint's
      // secret in your webhook settings.
      // String webhookSecret = "whsec_..."

      Event event = null;

      // Verify webhook signature and extract the event.
      // See https://stripe.com/docs/webhooks/signatures for more information.
      try {
        event = Webhook.constructEvent(
          payload, sigHeader, webhookSecret
        );
      } catch (JsonSyntaxException e) {
      // Invalid payload.
        response.status(400);
        return "";
      } catch (SignatureVerificationException e) {
      // Invalid Signature.
        response.status(400);
        return "";
      }

      if ("payment_intent.succeeded".equals(event.getType())) {
        // Deserialize the nested object inside the event
        EventDataObjectDeserializer dataObjectDeserializer = event.getDataObjectDeserializer();
        PaymentIntent paymentIntent = null;
        if (dataObjectDeserializer.getObject().isPresent()) {
          paymentIntent = (PaymentIntent) dataObjectDeserializer.getObject().get();
          String connectedAccountId = event.getAccount();
          handleSuccessfulPaymentIntent(connectedAccountId, paymentIntent);
        } else {
          // Deserialization failed, probably due to an API version mismatch.
          // Refer to the Javadoc documentation on `EventDataObjectDeserializer` for
          // instructions on how to handle this case, or return an error here.
        }
      }

      response.status(200);
      return "";
    });
  }

  private static void handleSuccessfulPaymentIntent(String connectedAccountId, PaymentIntent paymentIntent) {
    // Fulfill the purchase.
    System.out.println("Connected account ID: " + connectedAccountId);
    System.out.println("PaymentIntent ID: " + paymentIntent.getId());
  }
}

package main

import (
  "encoding/json"
  "log"
  "fmt"
  "net/http"
  "io/ioutil"

  "github.com/stripe/stripe-go/v71"
  "github.com/stripe/stripe-go/v71/webhook"

  "os"
)

func main() {
  // Set your secret key. Remember to switch to your live secret key in production!
  // See your keys here: https://dashboard.stripe.com/account/apikeys
  stripe.Key = "sk_test_4eC39HqLyjWDarjtT1zdp7dc"

  http.HandleFunc("/webhook", handleWebhook)
  addr := "localhost:4242"

  log.Printf("Listening on %s ...", addr)
  log.Fatal(http.ListenAndServe(addr, nil))
}

func handleWebhook(w http.ResponseWriter, req *http.Request) {
  const MaxBodyBytes = int64(65536)
  req.Body = http.MaxBytesReader(w, req.Body, MaxBodyBytes)
  body, err := ioutil.ReadAll(req.Body)
  if err != nil {
      fmt.Fprintf(os.Stderr, "Error reading request body: %v\n", err)
      w.WriteHeader(http.StatusServiceUnavailable)
      return
  }

  // Uncomment and replace with a real secret. You can find your endpoint's
  // secret in your webhook settings.
  // webhookSecret := "whsec_..."

  // Verify webhook signature and extract the event.
  // See https://stripe.com/docs/webhooks/signatures for more information.
  event, err := webhook.ConstructEvent(body, req.Header.Get("Stripe-Signature"), webhookSecret)

  if err != nil {
      fmt.Fprintf(os.Stderr, "Error verifying webhook signature: %v\n", err)
      w.WriteHeader(http.StatusBadRequest) // Return a 400 error on a bad signature.
      return
  }

  if event.Type == "payment_intent.succeeded" {
      var paymentIntent stripe.PaymentIntent
      err := json.Unmarshal(event.Data.Raw, &paymentIntent)
      if err != nil {
          fmt.Fprintf(os.Stderr, "Error parsing webhook JSON: %v\n", err)
          w.WriteHeader(http.StatusBadRequest)
          return
      }
      var connectedAccountId = event.Account;
      handleSuccessfulPaymentIntent(connectedAccountId, paymentIntent)
  }

  w.WriteHeader(http.StatusOK)
}

func handleSuccessfulPaymentIntent(connectedAccountId string, paymentIntent stripe.PaymentIntent) {
  // Fulfill the purchase.
  log.Println("Connected account ID: " + connectedAccountId)
  log.Println("PaymentIntent ID: " + paymentIntent.ID)
}

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
StripeConfiguration.ApiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

using System;
using System.IO;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;

using Stripe;

namespace Controllers
{
  public class ConnectController : Controller
  {
    private readonly ILogger<ConnectController> logger;

    public ConnectController(
      ILogger<ConnectController> logger,
    ) {
      this.logger = logger;
    }

    [HttpPost("webhook")]
    public async Task<IActionResult> ProcessWebhookEvent()
    {
      var json = await new StreamReader(HttpContext.Request.Body).ReadToEndAsync();

      // Uncomment and replace with a real secret. You can find your endpoint's
      // secret in your webhook settings.
      // const string webhookSecret = "whsec_..."

      // Verify webhook signature and extract the event.
      // See https://stripe.com/docs/webhooks/signatures for more information.
      try
      {
        var stripeEvent = EventUtility.ConstructEvent(json, Request.Headers["Stripe-Signature"], webhookSecret);

        if (stripeEvent.Type == Events.PaymentIntentSucceeded) {
          var paymentIntent = stripeEvent.Data.Object as PaymentIntent;
          var connectedAccountId = stripeEvent.Account;
          handleSuccessfulPaymentIntent(connectedAccountId, paymentIntent);
        }

        return Ok();
      }
      catch (Exception e)
      {
        logger.LogInformation(e.ToString());
        return BadRequest();
      }
    }

    private void handleSuccessfulPaymentIntent(string connectedAccountId, PaymentIntent paymentIntent) {
      // Fulfill the purchase.
      logger.LogInformation($"Connected account ID: {connectedAccountId}");
      logger.LogInformation($"PaymentIntent: {paymentIntent}");
    }
  }
}

# Available as a gem
sudo gem install stripe

# If you use bundler, you can add this line to your Gemfile
gem 'stripe'

# Install through pip
pip install --upgrade stripe

# Or find the Stripe package on http://pypi.python.org/pypi/stripe/

# Install the PHP library via Composer
composer require stripe/stripe-php

# Or download the source directly: https://github.com/stripe/stripe-php/releases

/*
 For Gradle, add the following dependency to your build.gradle and replace {VERSION} with
 the version number you want to use from
 - https://mvnrepository.com/artifact/com.stripe/stripe-java or
 - https://github.com/stripe/stripe-java/releases/latest
*/
implementation "com.stripe:stripe-java:{VERSION}"

<!--
  For Maven, add the following dependency to your POM and replace {VERSION} with the
  version number you want to use from
  - https://mvnrepository.com/artifact/com.stripe/stripe-java or
  - https://github.com/stripe/stripe-java/releases/latest
-->
<dependency>
  <groupId>com.stripe</groupId>
  <artifactId>stripe-java</artifactId>
  <version>{VERSION}</version>
</dependency>

# For other environments, manually install the following JARs:
# - The Stripe JAR from https://github.com/stripe/stripe-java/releases/latest
# - Google Gson from https://github.com/google/gson

# Install via npm
npm install --save stripe

# Install stripe-go
go get -u github.com/stripe/stripe-go

// Then import the package
import (
  "github.com/stripe/stripe-go/v71"
)

# Install via dotnet
dotnet add package Stripe.net
dotnet restore

# Or install via NuGet
PM> Install-Package Stripe.net

import com.stripe.android.PaymentConfiguration

class MyApp : Application() {
    override fun onCreate() {
        super.onCreate()
        PaymentConfiguration.init(
            applicationContext,
            "pk_test_TYooMQauvdEDq54NiTphI7jx"
        )
    }
}

import com.stripe.android.PaymentConfiguration;

public class MyApp extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        PaymentConfiguration.init(
            getApplicationContext(),
            "pk_test_TYooMQauvdEDq54NiTphI7jx"
        );
    }
}

class ConnectWithStripeActivity : AppCompatActivity() {
    private val viewBinding: ActivityConnectWithStripeBinding by lazy {
        ActivityConnectWithStripeBinding.inflate(layoutInflater)
    }

    private val state: String // generate a unique value for this
    private val clientId: String // the client ID found in your platform settings

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(viewBinding.root)

        viewBinding.connectWithStripe.setOnClickListener {
            // set the redirect_uri to a deep link back into your app to automatically
            // detect when the user has completed the onboarding flow
            val redirect = "https://www.example.com/connect-onboard-redirect"

            val url = "https://connect.stripe.com/oauth/authorize" +
                "?client_id=$clientId" +
                "&state=$state" +
                "&scope=read_write" +
                "&response_type=code" +
                "&redirect_uri=$redirect"
            val builder: CustomTabsIntent.Builder = CustomTabsIntent.Builder()
            val customTabsIntent = builder.build()
            customTabsIntent.launchUrl(this, Uri.parse(url))
        }
    }
}

public class ConnectWithStripeActivity extends AppCompatActivity {
    private ActivityConnectWithStripeBinding viewBinding;


    private String state = "asdflkj"; // generate a unique value for this
    private String clientId = "ca_32D88BD1qLklliziD7gYQvctJIhWBSQ7"; // the client ID found in your platform settings

    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        viewBinding = ActivityConnectWithStripeBinding.inflate(getLayoutInflater());

        viewBinding.connectWithStripe.setOnClickListener(view -> {
            // set the redirect_uri to a deep link back into your app to automatically
            // detect when the user has completed the onboarding flow
            String redirect = "https://www.example.com/connect-onboard-redirect";

            String url = "https://connect.stripe.com/oauth/authorize" +
                    "?client_id=" + clientId +
                    "&state=" + state +
                    "&scope=read_write" +
                    "&response_type=code" +
                    "&redirect_uri=" + redirect;
            CustomTabsIntent.Builder builder = new CustomTabsIntent.Builder();
            CustomTabsIntent customTabsIntent = builder.build();
            customTabsIntent.launchUrl(view.getContext(), Uri.parse(url));
        });
    }
}

curl https://connect.stripe.com/oauth/token \
  -u sk_test_4eC39HqLyjWDarjtT1zdp7dc: \
  -d code=ac_123456789 \
  -d grant_type=authorization_code

# Using Sinatra.
require 'sinatra'
require 'stripe'

set :port, 4242

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

get '/' do
  # Display landing page.
  content_type 'text/html'
  send_file File.join('./index.html')
end

get '/connect/oauth' do
  content_type 'application/json'

  # Assert the state matches the state you provided in the OAuth link (optional).
  state = params[:state]
  if !state_matches?(state)
    status 403
    return {error: 'Incorrect state parameter: ' + state}.to_json
  end

  # Send the authorization code to Stripe's API.
  code = params[:code]
  begin
    response = Stripe::OAuth.token({
      grant_type: 'authorization_code',
      code: code,
    })
  rescue Stripe::OAuth::InvalidGrantError
    status 400
    return {error: 'Invalid authorization code: ' + code}.to_json
  rescue Stripe::StripeError
    status 500
    return {error: 'An unknown error occurred.'}.to_json
  end

  connected_account_id = response.stripe_user_id
  save_account_id(connected_account_id)

  # Render some HTML or redirect to a different page.
  status 200
  {success: true}.to_json
end

def state_matches?(state_parameter)
  # Load the same state value that you randomly generated for your OAuth link.
  saved_state = '{{ STATE }}'

  saved_state == state_parameter
end

def save_account_id(id)
  # Save the connected account ID from the response to your database.
  puts 'Connected account ID: ' + id
end

import stripe
import json

# Using Flask.
from flask import (
    Flask,
    render_template,
    request,
)

app = Flask(__name__, static_folder=".",
            static_url_path="", template_folder=".")

@app.route('/', methods=['GET'])
def get_example():
  # Display landing page.
  return render_template('index.html')

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

@app.route("/connect/oauth", methods=["GET"])
def handle_oauth_redirect():
  # Assert the state matches the state you provided in the OAuth link (optional).
  state = request.args.get("state")

  if not state_matches(state):
    return json.dumps({"error": "Incorrect state parameter: " + state}), 403

  # Send the authorization code to Stripe's API.
  code = request.args.get("code")
  try:
    response = stripe.OAuth.token(grant_type="authorization_code", code=code,)
  except stripe.oauth_error.OAuthError as e:
    return json.dumps({"error": "Invalid authorization code: " + code}), 400
  except Exception as e:
    return json.dumps({"error": "An unknown error occurred."}), 500

  connected_account_id = response["stripe_user_id"]
  save_account_id(connected_account_id)

  # Render some HTML or redirect to a different page.
  return json.dumps({"success": True}), 200

def state_matches(state_parameter):
  # Load the same state value that you randomly generated for your OAuth link.
  saved_state = "{{ STATE }}"

  return saved_state == state_parameter

def save_account_id(id):
  # Save the connected account ID from the response to your database.
  print("Connected account ID: ", id)

if __name__ == "__main__":
    app.run(port=4242)

<?php
// Using Slim.
use Slim\Http\Request;
use Slim\Http\Response;
use Stripe\Stripe;

require_once('vendor/autoload.php');

$app = new \Slim\App;

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
\Stripe\Stripe::setApiKey('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

$app->get('/', function (Request $request, Response $response, array $args) {
  // Display landing page.
  return $response->write(file_get_contents('./index.html'));
});

$app->get('/connect/oauth', function ($request, $response, $next) {
  extract($request->getQueryParams());

  // Assert the state matches the state you provided in the OAuth link (optional).
  if (!stateMatches($state))
    return $response->withStatus(403)->withJson(array('error' => 'Incorrect state parameter: ' . $state));

  // Send the authorization code to Stripe's API.
  $code = $request->getQueryParam('code');

  try {
    $stripeResponse = \Stripe\OAuth::token([
      'grant_type' => 'authorization_code',
      'code' => $code,
    ]);
  } catch (\Stripe\Error\OAuth\InvalidGrant $e) {
    return $response->withStatus(400)->withJson(array('error' => 'Invalid authorization code: ' . $code));
  } catch (Exception $e) {
    return $response->withStatus(500)->withJson(array('error' => 'An unknown error occurred.'));
  }

  $connectedAccountId = $stripeResponse->stripe_user_id;
  saveAccountId($connectedAccountId);

  // Render some HTML or redirect to a different page.
  return $response->withStatus(200)->withJson(array('success' => true));
});

function stateMatches($stateParameter) {
  // Load the same state value that you randomly generated for your OAuth link.
  $savedState = '{{ STATE }}';

  return $savedState == $stateParameter;
};

function saveAccountId($id) {
  // Save the connected account ID from the response to your database.
  echo 'Connected account ID: ' . $id;
};

$app->run();

// Using Express
const express = require('express');
const app = express();
app.use(express.json());
const { resolve } = require("path");

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
const stripe = require('stripe')('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

app.get("/", (req, res) => {
  // Display landing page.
  const path = resolve("./index.html");
  res.sendFile(path);
});

app.get("/connect/oauth", async (req, res) => {
  const { code, state } = req.query;

  // Assert the state matches the state you provided in the OAuth link (optional).
  if(!stateMatches(state)) {
    return res.status(403).json({ error: 'Incorrect state parameter: ' + state });
  }

  // Send the authorization code to Stripe's API.
  stripe.oauth.token({
    grant_type: 'authorization_code',
    code
  }).then(
    (response) => {
      var connected_account_id = response.stripe_user_id;
      saveAccountId(connected_account_id);

      // Render some HTML or redirect to a different page.
      return res.status(200).json({success: true});
    },
    (err) => {
      if (err.type === 'StripeInvalidGrantError') {
        return res.status(400).json({error: 'Invalid authorization code: ' + code});
      } else {
        return res.status(500).json({error: 'An unknown error occurred.'});
      }
    }
  );
});

const stateMatches = (state_parameter) => {
  // Load the same state value that you randomly generated for your OAuth link.
  const saved_state = 'sv_53124';

  return saved_state == state_parameter;
}

const saveAccountId = (id) => {
  // Save the connected account ID from the response to your database.
  console.log('Connected account ID: ' + id);
}

app.listen(4242, () => console.log(`Node server listening on port ${4242}!`));

package com.stripe.sample;

import com.google.gson.Gson;
import com.stripe.Stripe;
import com.stripe.net.OAuth;
import com.stripe.model.oauth.TokenResponse;
import com.stripe.exception.StripeException;
import com.stripe.exception.oauth.InvalidGrantException;
import spark.Response;

import java.nio.file.Paths;
import java.util.HashMap;
import java.util.Map;

// Using Spark.
import static spark.Spark.*;

import io.github.cdimascio.dotenv.Dotenv;

public class Server {
  private static Gson gson = new Gson();

  public static void main(String[] args) {
    port(4242);

    // Set your secret key. Remember to switch to your live secret key in production!
    // See your keys here: https://dashboard.stripe.com/account/apikeys
    Stripe.apiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

    staticFiles.externalLocation("../client");

    get("/connect/oauth", (request, response) -> {
      // Assert the state matches the state you provided in the OAuth link (optional).
      String state = request.queryParams("state");
      if (!stateMatches(state)) {
        return buildResponse(
          response, 403, "error", "Incorrect state parameter: " + state
        );
      }

      // Send the authorization code to Stripe's API.
      String code = request.queryParams("code");
      Map<String, Object> params = new HashMap<>();
      params.put("grant_type", "authorization_code");
      params.put("code", code);

      try {
        TokenResponse stripeResponse = OAuth.token(params, null);
        // Save the connected account ID from the response to your database.
        String connectedAccountId = stripeResponse.getStripeUserId();
        saveAccountId(connectedAccountId);

        // Render some HTML or redirect to a different page.
        return buildResponse(response, 200, "success", "Request succeeded.");
      } catch (InvalidGrantException e) {
        // There's a problem with the authorization code.
        return buildResponse(
          response, 400, "error", "Invalid authorization code: " + code
        );
      } catch (StripeException e) {
        // All other errors.
        return buildResponse(
          response, 500, "error", "An unknown error occurred."
        );
      }
    });
  }

  private static boolean stateMatches(String parameterState) {
    // Load the same state value that you randomly generated for your OAuth link.
    String savedState = "{{ STATE }}";

    return savedState.equals(parameterState);
  }

  private static void saveAccountId(String id) {
    System.out.println("Connected account ID: " + id);
  }

  private static String buildResponse(
    Response response, int statusCode, String type, String message
  ) {
    response.status(statusCode);
    Map<String, String> errorResponse = new HashMap<>();
    errorResponse.put(type, message);
    return gson.toJson(errorResponse);
  }
}

package main

import (
  "encoding/json"
  "log"
  "fmt"
  "net/http"

  "github.com/stripe/stripe-go/v71"
  "github.com/stripe/stripe-go/v71/oauth"

  "os"
)

type CreateOAuthResponse struct {
  Success      bool   `json:"success"`
}

func main() {
  // Set your secret key. Remember to switch to your live secret key in production!
  // See your keys here: https://dashboard.stripe.com/account/apikeys
  stripe.Key = "sk_test_4eC39HqLyjWDarjtT1zdp7dc"

  // Display landing page.
  fs := http.FileServer(http.Dir("static"))
  http.Handle("/", fs)

  http.HandleFunc("/connect/oauth", handleOauthRedirect)
  addr := "localhost:4242"

  log.Printf("Listening on %s ...", addr)
  log.Fatal(http.ListenAndServe(addr, nil))
}

func handleOauthRedirect(w http.ResponseWriter, r *http.Request) {
  query := r.URL.Query()

  // Assert the state matches the state you provided in the OAuth link (optional).
  state := query.Get("state")
  if !stateMatches(state, w) {
    http.Error(w, fmt.Sprintf("Invalid state parameter: %s", state), http.StatusForbidden)
    return
  }

  // Send the authorization code to Stripe's API.
  code := query.Get("code")
  params := &stripe.OAuthTokenParams{
    GrantType: stripe.String("authorization_code"),
    Code:      &code,
  }
  token, err := oauth.New(params)

  if  err != nil {
    stripeErr := err.(*stripe.Error)
    if (stripeErr.OAuthError == "invalid_grant") {
      http.Error(w, fmt.Sprintf("Invalid authorization code: %s", code), http.StatusBadRequest)
    } else {
      http.Error(w, "An unknown error occurred.", http.StatusInternalServerError)
    }
    return
  }

  connectedAccountId := token.StripeUserID
  saveAccountId(connectedAccountId)

      // Render some HTML or redirect to a different page.
  json.NewEncoder(w).Encode(CreateOAuthResponse{
    Success:      true,
  })
}

func stateMatches(state_parameter string, w http.ResponseWriter) bool {
  // Load the same state value that you randomly generated for your OAuth link.
  saved_state := "{{ STATE }}"

	return saved_state == state_parameter
}

func saveAccountId(id string) {
  // Save the connected account ID from the response to your database.
  log.Println("Connected account ID: " + id)
}

using System;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using Microsoft.AspNetCore.Http;

using Stripe;
using Newtonsoft.Json;

namespace Controllers
{
  public class ConnectController : Controller
  {
    private readonly StripeClient client;
    private readonly IOptions<StripeOptions> options;
    private readonly ILogger<ConnectController> logger;

    public ConnectController(
      IOptions<StripeOptions> options,
      ILogger<ConnectController> logger,
    ) {
      // Set your secret key: remember to switch to your live secret key in production
      // See your keys here: https://dashboard.stripe.com/account/apikeys
      this.client = new StripeClient("sk_test_4eC39HqLyjWDarjtT1zdp7dc");
      this.options = options;
      this.logger = logger;
    }

    [HttpGet("/connect/oauth")]
    public IActionResult HandleOAuthRedirect(
      [FromQuery] string state,
      [FromQuery] string code
    ) {
      var service = new OAuthTokenService(client);

      // Assert the state matches the state you provided in the OAuth link (optional).
      if (!StateMatches(state))
      {
        return StatusCode(
          StatusCodes.Status403Forbidden,
          Json(new { Error = String.Format("Incorrect state parameter: {0}", state) })
        );
      }

      // Send the authorization code to Stripe's API.
      var options = new OAuthTokenCreateOptions
      {
        GrantType = "authorization_code",
        Code = code,
      };

      OAuthToken response = null;

      try
      {
        response = service.Create(options);
      }
      catch (StripeException e)
      {
        if (e.StripeError != null && e.StripeError.Error == "invalid_grant") {
          return StatusCode(
            StatusCodes.Status400BadRequest,
            Json(new { Error = String.Format("Invalid authorization code: {0}", code) })
          );
        } else {
          return StatusCode(
            StatusCodes.Status500InternalServerError,
            Json(new { Error = "An unknown error occurred." })
          );
        }
      }

      var connectedAccountId = response.StripeUserId;
      SaveAccountId(connectedAccountId);

      // Render some HTML or redirect to a different page.
      return new OkObjectResult(Json(new { Success = true }));
    }

    private bool StateMatches(string stateParameter)
    {
      // Load the same state value that you randomly generated for your OAuth link.
      var savedState = "{{ STATE }}";

      return savedState == stateParameter;
    }

    private void SaveAccountId(string id)
    {
      // Save the connected account ID from the response to your database.
      logger.LogInformation($"Connected account ID: {id}");
    }
  }
}

curl https://api.stripe.com/v1/payment_intents \
  -u sk_test_4eC39HqLyjWDarjtT1zdp7dc: \
  -d "payment_method_types[]"=card \
  -d amount=1000 \
  -d currency=usd \
  -d application_fee_amount=123 \
  -H "Stripe-Account: {{CONNECTED_STRIPE_ACCOUNT_ID}}"

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

payment_intent = Stripe::PaymentIntent.create({
  payment_method_types: ['card'],
  amount: 1000,
  currency: 'usd',
  application_fee_amount: 123,
}, stripe_account: '{{CONNECTED_STRIPE_ACCOUNT_ID}}')
client_secret = payment_intent['client_secret']
# Pass the client secret to the client

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

payment_intent = stripe.PaymentIntent.create(
  payment_method_types=['card'],
  amount=1000,
  currency='usd',
  application_fee_amount=123,
  stripe_account='{{CONNECTED_STRIPE_ACCOUNT_ID}}',
)
client_secret = intent.client_secret
# Pass the client secret to the client

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
\Stripe\Stripe::setApiKey('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

$payment_intent = \Stripe\PaymentIntent::create([
  'payment_method_types' => ['card'],
  'amount' => 1000,
  'currency' => 'usd',
  'application_fee_amount' => 123,
], ['stripe_account' => '{{CONNECTED_STRIPE_ACCOUNT_ID}}']);
$client_secret = $intent->client_secret;
// Pass the client secret to the client

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.apiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

ArrayList paymentMethodTypes = new ArrayList();
paymentMethodTypes.add("card");

Map<String, Object> params = new HashMap<>();
params.put("payment_method_types", paymentMethodTypes);
params.put("amount", 1000);
params.put("currency", "usd");
params.put("application_fee_amount", 123);

RequestOptions requestOptions = RequestOptions.builder().setStripeAccount({{CONNECTED_STRIPE_ACCOUNT_ID}}).build();
PaymentIntent paymentIntent = PaymentIntent.create(params, requestOptions);
PaymentIntent intent = PaymentIntent.create(params);
String clientSecret = intent.getClientSecret();
// Pass the client secret to the client

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
const stripe = require('stripe')('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

const paymentIntent = await stripe.paymentIntents.create({
  payment_method_types: ['card'],
  amount: 1000,
  currency: 'usd',
  application_fee_amount: 123,
}, {
  stripeAccount: '{{CONNECTED_STRIPE_ACCOUNT_ID}}',
});
const clientSecret = paymentIntent.client_secret;

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.Key = "sk_test_4eC39HqLyjWDarjtT1zdp7dc"

params := &stripe.PaymentIntentParams{
  PaymentMethodTypes: stripe.StringSlice([]string{
    "card",
  }),
  Amount: stripe.Int64(1000),
  Currency: stripe.String(string(stripe.CurrencyUSD)),
  ApplicationFeeAmount: stripe.Int64(123),
}
params.SetStripeAccount("{{CONNECTED_STRIPE_ACCOUNT_ID}}")
pi, _ := paymentintent.New(params)
// Pass the client secret to the client

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
StripeConfiguration.ApiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

var service = new PaymentIntentService();
var createOptions = new PaymentIntentCreateOptions
{
  PaymentMethodTypes = new List<string>
  {
    "card",
  },
  Amount = 2000,
  Currency = "usd",
  ApplicationFeeAmount = 123,
};

var requestOptions = new RequestOptions();
requestOptions.StripeAccount = "{{CONNECTED_STRIPE_ACCOUNT_ID}}";
service.Create(createOptions, requestOptions);
// Pass the client secret to the client

import com.stripe.android.PaymentConfiguration

class MyActivity: Activity() {
    private lateinit var stripe: Stripe

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        stripe = Stripe(
            this,
            PaymentConfiguration.getInstance(this).publishableKey,
            "{{CONNECTED_STRIPE_ACCOUNT_ID}}"
        )
    }
}

import com.stripe.android.PaymentConfiguration;

public class MyActivity extends Activity {
    private Stripe stripe;

    @Override
    public void onCreate(@Nullable Bundle savedInstancedState) {
        super.onCreate(savedInstancedState);
        stripe = new Stripe(
            this,
            PaymentConfiguration.getInstance(this).getPublishableKey(),
            "{{CONNECTED_STRIPE_ACCOUNT_ID}}"
        );
    }
}

class CheckoutActivity : AppCompatActivity() {

  private lateinit var paymentIntentClientSecret: String

  override fun onCreate(savedInstanceState: Bundle?) {
      super.onCreate(savedInstanceState)
      // ...
      startCheckout()
  }

  private fun startCheckout() {
      // Request a PaymentIntent from your server and store its client secret in paymentIntentClientSecret
      // Click Open on GitHub to see a full implementation
  }
}

public class CheckoutActivity extends AppCompatActivity {

    private String paymentIntentClientSecret;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        // ...
        startCheckout();
    }

    private void startCheckout() {
        // Request a PaymentIntent from your server and store its client secret in paymentIntentClientSecret
        // Click Open on GitHub to see a full implementation
    }
}

class CheckoutActivity : AppCompatActivity() {
    // ...
    private lateinit var paymentIntentClientSecret: String
    private lateinit var stripe: Stripe

    private fun startCheckout() {
        // ...

        // Hook up the pay button to the card widget and stripe instance
        val payButton: Button = findViewById(R.id.payButton)
        payButton.setOnClickListener {
            val params = cardInputWidget.paymentMethodCreateParams
            if (params != null) {
                val confirmParams = ConfirmPaymentIntentParams
                    .createWithPaymentMethodCreateParams(params, paymentIntentClientSecret)
                stripe = Stripe(applicationContext, PaymentConfiguration.getInstance(applicationContext).publishableKey)
                stripe.confirmPayment(this, confirmParams)
            }
        }
    }

    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)
        val weakActivity = WeakReference<Activity>(this)

        // Handle the result of stripe.confirmPayment
        stripe.onPaymentResult(requestCode, data, object : ApiResultCallback<PaymentIntentResult> {
            override fun onSuccess(result: PaymentIntentResult) {
                val paymentIntent = result.intent
                val status = paymentIntent.status
                if (status == StripeIntent.Status.Succeeded) {
                    val gson = GsonBuilder().setPrettyPrinting().create()
                    displayAlert(weakActivity.get(), "Payment succeeded", gson.toJson(paymentIntent), restartDemo = true)
                } else {
                    displayAlert(weakActivity.get(), "Payment failed", paymentIntent.lastPaymentError?.message ?: "")
                }
            }

            override fun onError(e: Exception) {
                displayAlert(weakActivity.get(), "Payment failed", e.toString())
            }
        })
    }
}

public class CheckoutActivity extends AppCompatActivity {
    // ...
    private String paymentIntentClientSecret;
    private Stripe stripe;

    private void startCheckout() {
        // ...

        // Hook up the pay button to the card widget and stripe instance
        Button payButton = findViewById(R.id.payButton);
        payButton.setOnClickListener((View view) -> {
            PaymentMethodCreateParams params = cardInputWidget.getPaymentMethodCreateParams();
            if (params != null) {
                ConfirmPaymentIntentParams confirmParams = ConfirmPaymentIntentParams
                        .createWithPaymentMethodCreateParams(params, paymentIntentClientSecret);
                final Context context = getApplicationContext();
                stripe = new Stripe(
                        context,
                        PaymentConfiguration.getInstance(context).getPublishableKey()
                );
                stripe.confirmPayment(this, confirmParams);
            }
        });
    }

    // ...

    @Override
    protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
        super.onActivityResult(requestCode, resultCode, data);

        // Handle the result of stripe.confirmPayment
        stripe.onPaymentResult(requestCode, data, new PaymentResultCallback(this));
    }

    // ...

    private static final class PaymentResultCallback
            implements ApiResultCallback<PaymentIntentResult> {
        @NonNull private final WeakReference<CheckoutActivity> activityRef;

        PaymentResultCallback(@NonNull CheckoutActivity activity) {
            activityRef = new WeakReference<>(activity);
        }

        @Override
        public void onSuccess(@NonNull PaymentIntentResult result) {
            final CheckoutActivity activity = activityRef.get();
            if (activity == null) {
                return;
            }

            PaymentIntent paymentIntent = result.getIntent();
            PaymentIntent.Status status = paymentIntent.getStatus();
            if (status == PaymentIntent.Status.Succeeded) {
                // Payment completed successfully
                Gson gson = new GsonBuilder().setPrettyPrinting().create();
                activity.displayAlert(
                        "Payment completed",
                        gson.toJson(paymentIntent),
                        true
                );
            } else if (status == PaymentIntent.Status.RequiresPaymentMethod) {
                // Payment failed
                activity.displayAlert(
                        "Payment failed",
                        Objects.requireNonNull(paymentIntent.getLastPaymentError()).getMessage(),
                        false
                );
            }
        }

        @Override
        public void onError(@NonNull Exception e) {
            final CheckoutActivity activity = activityRef.get();
            if (activity == null) {
                return;
            }

            // Payment request failed – allow retrying using the same payment method
            activity.displayAlert("Error", e.toString(), false);
        }
    }
}

# Using Sinatra.
require 'sinatra'
require 'stripe'

set :port, 4242

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

# Uncomment and replace with a real secret. You can find your endpoint's
# secret in your webhook settings.
# webhook_secret = 'whsec_...'

post '/webhook' do
  payload = request.body.read
  sig_header = request.env['HTTP_STRIPE_SIGNATURE']

  event = nil

  # Verify webhook signature and extract the event.
  # See https://stripe.com/docs/webhooks/signatures for more information.
  begin
    event = Stripe::Webhook.construct_event(
      payload, sig_header, webhook_secret
    )
  rescue JSON::ParserError => e
    # Invalid payload.
    status 400
    return
  rescue Stripe::SignatureVerificationError => e
    # Invalid Signature.
    status 400
    return
  end

  if event['type'] == 'payment_intent.succeeded'
    payment_intent = event['data']['object']
    connected_account_id = event['account']
    handle_successful_payment_intent(connected_account_id, payment_intent)
  end

  status 200
end

def handle_successful_payment_intent(connected_account_id, payment_intent)
  # Fulfill the purchase.
  puts 'Connected account ID: ' + connected_account_id
  puts 'PaymentIntent: ' + payment_intent.to_s
end

import stripe
import json

# Using Flask.
from flask import (
    Flask,
    render_template,
    request,
    Response,
)

app = Flask(__name__, static_folder=".",
            static_url_path="", template_folder=".")

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

# Uncomment and replace with a real secret. You can find your endpoint's
# secret in your webhook settings.
# webhook_secret = 'whsec_...'

@app.route("/webhook", methods=["POST"])
def webhook_received():
  request_data = json.loads(request.data)
  signature = request.headers.get("stripe-signature")

  # Verify webhook signature and extract the event.
  # See https://stripe.com/docs/webhooks/signatures for more information.
  try:
    event = stripe.Webhook.construct_event(
        payload=request.data, sig_header=signature, secret=webhook_secret
    )
  except ValueError as e:
    # Invalid payload.
    return Response(status=400)
  except stripe.error.SignatureVerificationError as e:
    # Invalid Signature.
    return Response(status=400)

  if event["type"] == "payment_intent.succeeded":
    payment_intent = event["data"]["object"]
    connected_account_id = event["account"]
    handle_successful_payment_intent(connected_account_id, payment_intent)

  return json.dumps({"success": True}), 200

def handle_successful_payment_intent(connected_account_id, payment_intent):
  # Fulfill the purchase.
  print('Connected account ID: ' + connected_account_id)
  print('PaymentIntent: ' + str(payment_intent))

if __name__ == "__main__":
  app.run(port=4242)

<?php
// Using Slim.
use Slim\Http\Request;
use Slim\Http\Response;
use Stripe\Stripe;

require_once('vendor/autoload.php');

$app = new \Slim\App;

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
\Stripe\Stripe::setApiKey('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

// Uncomment and replace with a real secret. You can find your endpoint's
// secret in your webhook settings.
// $webhook_secret = 'whsec_...';

$app->post('/webhook', function ($request, $response, $next) {
  $payload = $request->getBody();
  $sig_header = $request->getHeaderLine('stripe-signature');

  $event = null;

  // Verify webhook signature and extract the event.
  // See https://stripe.com/docs/webhooks/signatures for more information.
  try {
    $event = \Stripe\Webhook::constructEvent(
      $payload, $sig_header, $webhook_secret
    );
  } catch(\UnexpectedValueException $e) {
    // Invalid payload.
    return $response->withStatus(400);
  } catch(\Stripe\Exception\SignatureVerificationException $e) {
    // Invalid Signature.
    return $response->withStatus(400);
  }

  if ($event->type == 'payment_intent.succeeded') {
    $paymentIntent = $event->data->object;
    $connectedAccountId = $event->account;
    handleSuccessfulPaymentIntent($connectedAccountId, $paymentIntent);
  }

  return $response->withStatus(200);
});

function handleSuccessfulPaymentIntent($connectedAccountId, $paymentIntent) {
  // Fulfill the purchase.
  echo 'Connected account ID: ' . $connectedAccountId;
  echo 'PaymentIntent: ' . $paymentIntent;
};

$app->run();

// Using Express
const express = require('express');
const bodyParser = require("body-parser");
const app = express();
app.use(express.json());

// Use JSON parser for all non-webhook routes
app.use((req, res, next) => {
  if (req.originalUrl === "/webhook") {
    next();
  } else {
    bodyParser.json()(req, res, next);
  }
});

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
const stripe = require('stripe')('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

// Uncomment and replace with a real secret. You can find your endpoint's
// secret in your webhook settings.
// const webhook_secret = 'whsec_...''

app.post('/webhook', bodyParser.raw({type: 'application/json'}), (request, response) => {
  const sig = request.headers['stripe-signature'];

  let event;

  // Verify webhook signature and extract the event.
  // See https://stripe.com/docs/webhooks/signatures for more information.
  try {
    event = stripe.webhooks.constructEvent(request.body, sig, webhook_secret);
  } catch (err) {
    return response.status(400).send(`Webhook Error: ${err.message}`);
  }

  if (event.type === 'payment_intent.succeeded') {
    const paymentIntent = event.data.object;
    const connectedAccountId = event.account;
    handleSuccessfulPaymentIntent(connectedAccountId, paymentIntent);
  }

  response.json({received: true});
});

const handleSuccessfulPaymentIntent = (connectedAccountId, paymentIntent) => {
    // Fulfill the purchase.
  console.log('Connected account ID: ' + connectedAccountId);
  console.log('PaymentIntent: ' + JSON.stringify(paymentIntent));
}

app.listen(4242, () => console.log(`Node server listening on port ${4242}!`));

package com.stripe.sample;

import com.stripe.Stripe;
import com.stripe.model.PaymentIntent;
import com.stripe.model.Event;
import com.stripe.model.EventDataObjectDeserializer;
import com.stripe.exception.SignatureVerificationException;
import com.stripe.net.Webhook;
import com.google.gson.JsonSyntaxException;
import spark.Response;

// Using Spark.
import static spark.Spark.*;

public class Server {
  public static void main(String[] args) {
    port(4242);

    // Set your secret key. Remember to switch to your live secret key in production!
    // See your keys here: https://dashboard.stripe.com/account/apikeys
    Stripe.apiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";
    post("/webhook", (request, response) -> {
      String payload = request.body();
      String sigHeader = request.headers("Stripe-Signature");

      // Uncomment and replace with a real secret. You can find your endpoint's
      // secret in your webhook settings.
      // String webhookSecret = "whsec_..."

      Event event = null;

      // Verify webhook signature and extract the event.
      // See https://stripe.com/docs/webhooks/signatures for more information.
      try {
        event = Webhook.constructEvent(
          payload, sigHeader, webhookSecret
        );
      } catch (JsonSyntaxException e) {
      // Invalid payload.
        response.status(400);
        return "";
      } catch (SignatureVerificationException e) {
      // Invalid Signature.
        response.status(400);
        return "";
      }

      if ("payment_intent.succeeded".equals(event.getType())) {
        // Deserialize the nested object inside the event
        EventDataObjectDeserializer dataObjectDeserializer = event.getDataObjectDeserializer();
        PaymentIntent paymentIntent = null;
        if (dataObjectDeserializer.getObject().isPresent()) {
          paymentIntent = (PaymentIntent) dataObjectDeserializer.getObject().get();
          String connectedAccountId = event.getAccount();
          handleSuccessfulPaymentIntent(connectedAccountId, paymentIntent);
        } else {
          // Deserialization failed, probably due to an API version mismatch.
          // Refer to the Javadoc documentation on `EventDataObjectDeserializer` for
          // instructions on how to handle this case, or return an error here.
        }
      }

      response.status(200);
      return "";
    });
  }

  private static void handleSuccessfulPaymentIntent(String connectedAccountId, PaymentIntent paymentIntent) {
    // Fulfill the purchase.
    System.out.println("Connected account ID: " + connectedAccountId);
    System.out.println("PaymentIntent ID: " + paymentIntent.getId());
  }
}

package main

import (
  "encoding/json"
  "log"
  "fmt"
  "net/http"
  "io/ioutil"

  "github.com/stripe/stripe-go/v71"
  "github.com/stripe/stripe-go/v71/webhook"

  "os"
)

func main() {
  // Set your secret key. Remember to switch to your live secret key in production!
  // See your keys here: https://dashboard.stripe.com/account/apikeys
  stripe.Key = "sk_test_4eC39HqLyjWDarjtT1zdp7dc"

  http.HandleFunc("/webhook", handleWebhook)
  addr := "localhost:4242"

  log.Printf("Listening on %s ...", addr)
  log.Fatal(http.ListenAndServe(addr, nil))
}

func handleWebhook(w http.ResponseWriter, req *http.Request) {
  const MaxBodyBytes = int64(65536)
  req.Body = http.MaxBytesReader(w, req.Body, MaxBodyBytes)
  body, err := ioutil.ReadAll(req.Body)
  if err != nil {
      fmt.Fprintf(os.Stderr, "Error reading request body: %v\n", err)
      w.WriteHeader(http.StatusServiceUnavailable)
      return
  }

  // Uncomment and replace with a real secret. You can find your endpoint's
  // secret in your webhook settings.
  // webhookSecret := "whsec_..."

  // Verify webhook signature and extract the event.
  // See https://stripe.com/docs/webhooks/signatures for more information.
  event, err := webhook.ConstructEvent(body, req.Header.Get("Stripe-Signature"), webhookSecret)

  if err != nil {
      fmt.Fprintf(os.Stderr, "Error verifying webhook signature: %v\n", err)
      w.WriteHeader(http.StatusBadRequest) // Return a 400 error on a bad signature.
      return
  }

  if event.Type == "payment_intent.succeeded" {
      var paymentIntent stripe.PaymentIntent
      err := json.Unmarshal(event.Data.Raw, &paymentIntent)
      if err != nil {
          fmt.Fprintf(os.Stderr, "Error parsing webhook JSON: %v\n", err)
          w.WriteHeader(http.StatusBadRequest)
          return
      }
      var connectedAccountId = event.Account;
      handleSuccessfulPaymentIntent(connectedAccountId, paymentIntent)
  }

  w.WriteHeader(http.StatusOK)
}

func handleSuccessfulPaymentIntent(connectedAccountId string, paymentIntent stripe.PaymentIntent) {
  // Fulfill the purchase.
  log.Println("Connected account ID: " + connectedAccountId)
  log.Println("PaymentIntent ID: " + paymentIntent.ID)
}

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
StripeConfiguration.ApiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

using System;
using System.IO;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;

using Stripe;

namespace Controllers
{
  public class ConnectController : Controller
  {
    private readonly ILogger<ConnectController> logger;

    public ConnectController(
      ILogger<ConnectController> logger,
    ) {
      this.logger = logger;
    }

    [HttpPost("webhook")]
    public async Task<IActionResult> ProcessWebhookEvent()
    {
      var json = await new StreamReader(HttpContext.Request.Body).ReadToEndAsync();

      // Uncomment and replace with a real secret. You can find your endpoint's
      // secret in your webhook settings.
      // const string webhookSecret = "whsec_..."

      // Verify webhook signature and extract the event.
      // See https://stripe.com/docs/webhooks/signatures for more information.
      try
      {
        var stripeEvent = EventUtility.ConstructEvent(json, Request.Headers["Stripe-Signature"], webhookSecret);

        if (stripeEvent.Type == Events.PaymentIntentSucceeded) {
          var paymentIntent = stripeEvent.Data.Object as PaymentIntent;
          var connectedAccountId = stripeEvent.Account;
          handleSuccessfulPaymentIntent(connectedAccountId, paymentIntent);
        }

        return Ok();
      }
      catch (Exception e)
      {
        logger.LogInformation(e.ToString());
        return BadRequest();
      }
    }

    private void handleSuccessfulPaymentIntent(string connectedAccountId, PaymentIntent paymentIntent) {
      // Fulfill the purchase.
      logger.LogInformation($"Connected account ID: {connectedAccountId}");
      logger.LogInformation($"PaymentIntent: {paymentIntent}");
    }
  }
}