Stripe Accept a Payment

https://github.com/stripe-samples/accept-a-payment
Admin
Learn how to securely accept payments online with Stripe, offering examples for Prebuilt Checkout,...
Tokens:39,195
Snippets:541
Trust Score:8.1
License:MIT
Update:5 months ago
Show doc for...
Tokens:
Raw
### Install and Run PHP Server

Source: https://context7.com/stripe-samples/accept-a-payment/llms.txt

Navigate to the PHP server directory, copy the environment example, install Composer dependencies, and start the local PHP server.

```bash
cd elements-with-checkout-sessions/server/php
cp ../../.env.example .env
composer install
php -S localhost:4242 router.php
```

--------------------------------

### Install and Run Node.js Server

Source: https://context7.com/stripe-samples/accept-a-payment/llms.txt

Navigate to the Node.js server directory, copy the environment example, install dependencies, and start the server. The server will listen on port 4242.

```bash
cd prebuilt-checkout-page/server/node
cp ../../.env.example .env
npm install
npm start
```

--------------------------------

### Install and Start Node Server

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/payment-element/README.md

Instructions for installing dependencies and starting the Node.js server for the payment element sample.

```sh
cd server/node # there's a README in this folder with instructions
npm install
npm start
```

--------------------------------

### Install and Run Ruby (Sinatra) Server

Source: https://context7.com/stripe-samples/accept-a-payment/llms.txt

Navigate to the Ruby server directory, copy the environment example, install bundle dependencies, and start the server. It will listen on http://0.0.0.0:4242.

```bash
cd payment-element/server/ruby
cp ../../.env.example .env
bundle install
ruby server.rb
```

--------------------------------

### Install Node.js server dependencies and start

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/README.md

Navigate to the Node.js server directory, install its dependencies, and start the server.

```sh
cd server/node
npm install
npm start
```

--------------------------------

### Install PHP dependencies and start server

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/elements-with-checkout-sessions/README.md

Installs PHP dependencies via Composer and starts a local development server. The .env file should be pre-configured.

```bash
cd server/php
composer install
php -S localhost:4242 router.php
```

--------------------------------

### Install Dependencies and Start Server

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/server/node/README.md

Run these commands in your terminal to install project dependencies and start the Express server.

```bash
npm install
npm start
```

--------------------------------

### Install Ruby dependencies and start server

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/elements-with-checkout-sessions/README.md

Installs Ruby gems using Bundler and then executes the server script. Requires .env to be set up.

```bash
cd server/ruby
bundle install
ruby server.rb
```

--------------------------------

### Install React client dependencies and start

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/elements-with-checkout-sessions/README.md

Installs Node.js dependencies for the React client and starts the Vite development server. Ensure the backend server is running.

```bash
cd client/react-cra
npm install
npm start
```

--------------------------------

### Install Python dependencies and start server

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/elements-with-checkout-sessions/README.md

Installs Python project dependencies using pip and then runs the server script. Assumes .env file is configured.

```bash
cd server/python
pip install -r requirements.txt
python server.py
```

--------------------------------

### Run Go Server

Source: https://context7.com/stripe-samples/accept-a-payment/llms.txt

Change to the Go server directory, copy the environment example, and run the Go application.

```bash
cd elements-with-checkout-sessions/server/go
cp ../../.env.example .env
go run server.go
```

--------------------------------

### Install and Run Python (Flask) Server

Source: https://context7.com/stripe-samples/accept-a-payment/llms.txt

Change to the Python server directory, copy the environment example, install requirements, and run the server. It will be accessible at http://127.0.0.1:4242.

```bash
cd elements-with-checkout-sessions/server/python
cp ../../.env.example .env
pip install -r requirements.txt
python server.py
```

--------------------------------

### Start the HTML client locally

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/client/html/README.md

Run this command in your terminal to start the HTML server on localhost:3000. Ensure you have Node.js and npm installed.

```sh
npx serve -p 3000
```

--------------------------------

### Start Sample App with Docker Compose

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/TESTING.md

Start the sample application using Docker Compose, ensuring the 'frontend' profile is included to run the necessary services.

```bash
docker compose --profile=frontend up
```

--------------------------------

### Run .NET Server

Source: https://context7.com/stripe-samples/accept-a-payment/llms.txt

Change to the .NET server directory, copy the environment example, and run the .NET application.

```bash
cd elements-with-checkout-sessions/server/dotnet
cp ../../.env.example .env
dotnet run
```

--------------------------------

### Install Dependencies

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/server/python/README.md

Install all required Python packages for the project by running this command.

```bash
pip install -r requirements.txt
```

--------------------------------

### Install Stripe Samples with Stripe CLI

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/README.md

Use the Stripe CLI to quickly create and set up the 'accept-a-payment' sample project.

```sh
stripe samples create accept-a-payment
```

--------------------------------

### Start the PHP Server

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/server/php/README.md

Use Composer to start the local development server or manually run PHP's built-in server.

```bash
composer start
```

```bash
cd public
php -S 127.0.0.1:4242
```

--------------------------------

### Start React Development Server

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/client/react-cra/README.md

Execute this command to start the React development server. The UI will be available at localhost:3000.

```sh
npm start
```

--------------------------------

### Install Dependencies with npm

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/client/react-cra/README.md

Run this command in the client directory to install project dependencies.

```sh
npm install
```

--------------------------------

### Run the Go Application

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/server/go/README.md

Execute this command from the server directory to start the Go application.

```sh
go run server.go
```

--------------------------------

### Run the local server

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/prebuilt-checkout-page/server/php/README.md

Start the local development server from the public directory. Navigate to localhost:4242 in your browser to view the demo.

```shell
cd public
php -S localhost:4242
```

--------------------------------

### Install Go Dependencies

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/server/go/README.md

Run these commands from the server directory to manage Go dependencies.

```sh
go mod tidy
go mod vendor
```

--------------------------------

### Install Composer Dependencies

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/server/php/README.md

Run this command to install the necessary PHP dependencies for the project.

```bash
composer install
```

--------------------------------

### Install Dependencies with Yarn

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/client/react-native-expo/README.md

Run this command in the client directory to install project dependencies using Yarn.

```sh
yarn
```

--------------------------------

### Example .env file configuration

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/README.md

Set your Stripe publishable and secret keys, the static directory for client files, and your local domain.

```sh
STRIPE_PUBLISHABLE_KEY=<replace-with-your-publishable-key>
STRIPE_SECRET_KEY=<replace-with-your-secret-key>
STATIC_DIR=../../client/html
DOMAIN=http://localhost:4242
```

--------------------------------

### Copy .env.example to server directory

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/elements-with-checkout-sessions/README.md

Copies the example environment file to the specific server directory and prompts the user to add their Stripe API keys.

```bash
cp .env.example server/node/.env
# Edit server/node/.env and add your keys
```

```bash
cd server/python
cp ../../.env.example .env  # add your keys
```

```bash
cd server/ruby
cp ../../.env.example .env  # add your keys
```

```bash
cd server/php
cp ../../.env.example .env  # add your keys
```

```bash
cd server/java
cp ../../.env.example .env  # add your keys
```

```bash
cd server/go
cp ../../.env.example .env  # add your keys
```

```bash
cd server/dotnet
cp ../../.env.example .env  # add your keys
```

--------------------------------

### Run the PHP Development Server

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/payment-element/server/php/README.md

Navigate to the public directory and start the local development server using PHP's built-in server.

```bash
cd public
php -S 127.0.0.1:4242
```

--------------------------------

### Copy .env.example to .env

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/prebuilt-checkout-page/server/php/README.md

Copy the example environment file to .env and replace placeholder values with your Stripe API keys.

```shell
cp .env.example .env
```

--------------------------------

### Install Dependencies with Bundler

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/server/ruby/README.md

Use Bundler to install all the required Ruby gems specified in your project's Gemfile.

```bash
bundle install
```

--------------------------------

### Run the .NET Core Application

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/server/dotnet/README.md

Execute this command in your terminal to start the .NET Core server.

```bash
dotnet run 
```

--------------------------------

### Copy Environment File

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/server/php/README.md

Copy the example environment file to .env and replace placeholder values with your actual Stripe API keys.

```bash
cp ../../.env.example .env
```

--------------------------------

### Run the Sinatra Server

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/server/ruby/README.md

Execute the Ruby server script to start the local development server.

```bash
ruby server.rb
```

--------------------------------

### Example Price JSON Response

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/prebuilt-checkout-page/README.md

This is an example JSON response when creating a Price. The 'id' field is used to set the PRICE environment variable.

```json
{
  "id": "price_1Hh1ZeCZ6qsJgndJaX9fauRl",
  "object": "price",
  "active": true,
  "billing_scheme": "per_unit",
  "created": 1603841250,
  "currency": "usd",
  "livemode": false,
  "lookup_key": null,
  "metadata": {
  },
  "nickname": null,
  "product": "prod_IHalmba0p05ZKD",
  "recurring": null,
  "tiers_mode": null,
  "transform_quantity": null,
  "type": "one_time",
  "unit_amount": 500,
  "unit_amount_decimal": "500"
}
```

--------------------------------

### Start the App and Open Expo Dev Tools

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/client/react-native-expo/README.md

Execute this command to start the React Native Expo application and open the Expo development tools.

```sh
yarn start
```

--------------------------------

### Configure Environment Variables

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/payment-element/README.md

Copy the example environment file and replace placeholder values with your Stripe API keys and static directory path.

```sh
cp .env.example custom-payment-flow/server/node/.env
```

```sh
STRIPE_PUBLISHABLE_KEY=<replace-with-your-publishable-key>
STRIPE_SECRET_KEY=<replace-with-your-secret-key>
STATIC_DIR=../../client/html
```

--------------------------------

### Configure environment variables for local development

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/README.md

Copy the example environment file and update it with your Stripe API keys and local development settings.

```sh
cp .env.example custom-payment-flow/server/node/.env
```

--------------------------------

### Configure Environment Variables

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/prebuilt-checkout-page/README.md

Copy the example environment file and update it with your Stripe API keys and a Price ID. The STATIC_DIR and DOMAIN variables should also be configured.

```sh
cp .env.example prebuilt-checkout-page/server/node/.env
```

```sh
STRIPE_PUBLISHABLE_KEY=<replace-with-your-publishable-key>
STRIPE_SECRET_KEY=<replace-with-your-secret-key>
PRICE=<replace-with-a-price-id-from-your-account>
STATIC_DIR=../../client/html
DOMAIN=http://localhost:4242
```

--------------------------------

### Install Playwright Dependencies

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/TESTING.md

Install Node.js dependencies for the Playwright service within the Docker environment. This is typically needed only once.

```bash
docker compose exec playwright npm install
```

--------------------------------

### Initialize Stripe SDK

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/client/VIDEOS.md

Initialize the Stripe SDK in your Activity using the provided context and publishable key. This setup is necessary before making any Stripe-related calls.

```java
stripe = new Stripe(this, PaymentConfiguration.getInstance(this).getPublishableKey());
```

--------------------------------

### Create PaymentIntent using cURL

Source: https://context7.com/stripe-samples/accept-a-payment/llms.txt

Examples of using cURL to create PaymentIntents for different payment methods and currencies. Demonstrates how to send JSON payloads to the /create-payment-intent endpoint.

```bash
# Create a card PaymentIntent
curl -X POST http://localhost:4242/create-payment-intent \
  -H "Content-Type: application/json" \
  -d '{"paymentMethodType": "card", "currency": "usd"}'
# { "clientSecret": "pi_3abc..._secret_xyz..." }

# Create an iDEAL PaymentIntent (EUR)
curl -X POST http://localhost:4242/create-payment-intent \
  -H "Content-Type: application/json" \
  -d '{"paymentMethodType": "ideal", "currency": "eur"}'
# { "clientSecret": "pi_3def..._secret_uvw..." }
```

--------------------------------

### SwiftUI Card Input View Setup

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/client/VIDEOS.md

Set up a SwiftUI view to include Stripe's card input field and a pay button. It manages loading states and payment method parameters, preparing for payment intent creation.

```swift
import SwiftUI
import Stripe

struct CardInputView: View {
    @ObservedObject var model: BackendModel
    @State private var loading = false
    @State private var paymentMethodParams: STPPaymentMethodParams? = nil

    var body: some View {
        VStack {
            if let paymentIntentParams = model.paymentIntentParams {
                STPPaymentCardTextFieldRepresentable(params: $paymentMethodParams)
                    .padding()

                Button("Buy") {
                    // Action to set payment method params and confirm payment
                }
                .padding()
                .disabled(loading)
            } else {
                Text("Loading")
            }
        }
        .onAppear {
            model.preparePaymentIntent(paymentMethodType: .card, currency: "USD")
        }
    }
}

struct STPPaymentCardTextFieldRepresentable: UIViewRepresentable {
    @Binding var params: STPPaymentMethodParams?

    func makeUIView(context: Context) -> STPPaymentCardTextField {
        let textField = STPPaymentCardTextField()
        return textField
    }

    func updateUIView(_ uiView: STPPaymentCardTextField, context: Context) {
        // Update params binding based on text field changes
        uiView.onDidChange = {\n            var params = STPPaymentMethodParams()
            params.card = STPCardParams()
            params.card?.number = uiView.cardNumber
            params.card?.expMonth = UInt(uiView.expirationMonth)
            params.card?.expYear = UInt(uiView.expirationYear)
            params.card?.cvc = uiView.cvc
            self.params = params
        }
    }
}
```

--------------------------------

### Making a POST request with curl

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/server/ruby/TRANSCRIPTS.md

Example of using curl to make a POST request to the create payment intent endpoint. Demonstrates sending an empty JSON object and then a JSON object with payment method types and currency.

```bash
curl -X POST http://localhost:4242/create_payment_intent \
  -H "Content-Type: application/json" \
  -d '{}'
```

```bash
curl -X POST http://localhost:4242/create_payment_intent \
  -H "Content-Type: application/json" \
  -d '{"payment_method_types": ["card"], "currency": "usd"}'
```

--------------------------------

### Configure Payment Request Details

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/client/VIDEOS.md

Configure the payment request object with details such as currency, country, and whether to request the payer's name and email. This setup determines what information is displayed and collected during the payment process.

```javascript
const paymentRequest = stripe.paymentRequest({
  country: 'US',
  currency: 'usd',
  requestPayerName: true,
  requestPayerEmail: true,
  total: {
    label: 'Demo total',
    amount: 1999,
  },
});
```

--------------------------------

### cURL Request to Retrieve Checkout Session

Source: https://context7.com/stripe-samples/accept-a-payment/llms.txt

Example of how to retrieve a Stripe Checkout Session using cURL, providing the session ID as a query parameter.

```bash
curl "http://localhost:4242/checkout-session?sessionId=cs_test_a1b2c3..."
# Response:
# {
#   "id": "cs_test_a1b2c3...",
#   "object": "checkout.session",
#   "status": "complete",
```

--------------------------------

### GET /checkout-session?sessionId=<id>

Source: https://context7.com/stripe-samples/accept-a-payment/llms.txt

Fetches a completed Checkout Session by its ID. This is used on the success page to retrieve order confirmation details.

```APIDOC
## GET /checkout-session?sessionId=<id>

### Description
Fetches a completed Checkout Session by ID (used on the success page to display order confirmation data).

### Method
GET

### Endpoint
/checkout-session

### Parameters
#### Query Parameters
- **sessionId** (string) - Required - The ID of the Checkout Session to retrieve.

### Request Example
```bash
curl "http://localhost:4242/checkout-session?sessionId=cs_test_a1b2c3..."
```

### Response
#### Success Response (200 OK)
- **id** (string) - The ID of the Checkout Session.
- **object** (string) - The type of object, always "checkout.session".
- **status** (string) - The status of the Checkout Session (e.g., "complete").

### Response Example
```json
{
  "id": "cs_test_a1b2c3...",
  "object": "checkout.session",
  "status": "complete"
}
```
```

--------------------------------

### Create Sample with Stripe CLI

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/payment-element/README.md

Use the Stripe CLI to quickly create and set up the 'accept-a-payment' sample project.

```sh
stripe samples create accept-a-payment
```

```sh
payment-element
```

--------------------------------

### Generate Docker Compose for Sample App

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/TESTING.md

Use the setup_development_environment script to generate Docker Compose settings for a specific sample app, server, and client combination. Provide the sample name, server app directory, client app directory, and optionally the server Docker image.

```bash
./sample-ci/setup_development_environment custom-payment-flow node ../../client/react-cra node:lts
```

```bash
./sample-ci/setup_development_environment custom-payment-flow ruby ../../client/html ruby:3.1
```

--------------------------------

### Create Accept a Payment Sample with Stripe CLI

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/prebuilt-checkout-page/README.md

Use the Stripe CLI to create a local copy of the 'accept-a-payment' sample. This is the recommended approach for setting up the project.

```sh
stripe samples create accept-a-payment
```

```sh
prebuilt-checkout-page
```

--------------------------------

### Create a new Stripe sample project

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/README.md

Use the Stripe CLI to create and configure a new Stripe sample project for accepting payments.

```sh
stripe samples create accept-a-payment
```

```sh
custom-payment-flow
```

--------------------------------

### Initialize Stripe.js with Publishable Key

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/client/VIDEOS.md

Fetches the Stripe publishable key from the server and initializes Stripe.js. Ensure your web server is running to provide the key.

```javascript
fetch('/config').then((res) => {
  return res.json();
}).then((config) => {
  // Initialize Stripe.js with your publishable key
  const stripe = Stripe(config.publishableKey);
});
```

--------------------------------

### Build the Java application

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/server/java/README.md

Use Maven to package the Java application into a JAR file.

```bash
mvn package
```

--------------------------------

### Configure .env for Sample App

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/TESTING.md

Create a .env file in the root of the sample repository with necessary Stripe keys, webhook secret, domain, and price ID. Adjust the DOMAIN based on the client app type (HTML or React/Vue).

```dotenv
STRIPE_PUBLISHABLE_KEY
STRIPE_SECRET_KEY
STRIPE_WEBHOOK_SECRET # docker compose run --rm stripe will display an available webhook secret
DOMAIN=http://frontend:3000 # or http://web:4242 for clients/html
PRICE=price_xxxx # the price ID you have
```

--------------------------------

### Compile and run Java server

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/elements-with-checkout-sessions/README.md

Compiles the Java project using Maven and then executes the main server class. Ensure .env is configured.

```bash
cd server/java
mvn compile exec:java
```

--------------------------------

### Run .NET server

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/elements-with-checkout-sessions/README.md

Executes the .NET project using the 'dotnet run' command. The .env file should be set up with required keys.

```bash
cd server/dotnet
dotnet run
```

--------------------------------

### Initialize Stripe SDK and Payment Configuration

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/client/VIDEOS.md

Set up the Stripe SDK instance and retrieve the publishable key from payment configuration. This is typically done during application startup or in an activity's initialization.

```java
private Stripe stripe;
...
stripe = new Stripe(this, "pk_test_...");
PaymentConfiguration.init(this, "pk_test_...");
```

--------------------------------

### Run Go server

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/elements-with-checkout-sessions/README.md

Executes the Go server file directly. The .env file must contain the necessary Stripe API keys.

```bash
cd server/go
go run server.go
```

--------------------------------

### Navigate to Server Directory

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/prebuilt-checkout-page/README.md

Change the current directory to the specific server implementation you wish to run.

```sh
cd server/node
```

--------------------------------

### Create and Activate Virtual Environment (Windows)

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/payment-element/server/python/README.md

Set up a Python virtual environment for your project on Windows using PowerShell.

```powershell
python3 -m venv env
.\env\Scripts\activate.bat
```

--------------------------------

### Run the Java application

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/server/java/README.md

Execute the packaged JAR file using the Java command.

```bash
java -cp target/sample-jar-with-dependencies.jar com.stripe.sample.Server
```

--------------------------------

### Create and Activate Virtual Environment (MacOS/Unix)

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/server/python/README.md

Use these commands to create a new virtual environment named 'env' and activate it for managing project dependencies.

```bash
python3 -m venv env
source env/bin/activate
```

--------------------------------

### Backend Model Preparation

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/client/VIDEOS.md

Prepare a payment intent on the server by calling the `preparePaymentIntent` method. This is typically done when the view appears.

```swift
model.preparePaymentIntent(paymentMethodType: .card, currency: "USD")
```

--------------------------------

### Client: Initialize Stripe Checkout Elements SDK

Source: https://context7.com/stripe-samples/accept-a-payment/llms.txt

Initializes Stripe.js with a publishable key, fetches a client secret, and mounts Payment, Billing Address, and Currency Selector elements. Handles session changes and payment confirmation.

```javascript
// elements-with-checkout-sessions/client/html/index.js
let checkout, actions;

async function initialize() {
  const { publishableKey } = await fetch('/config').then(r => r.json());
  const stripe = Stripe(publishableKey);

  // Fetch the client_secret from the server (returns a Promise)
  const clientSecretPromise = fetch('/create-checkout-session', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
  }).then(r => r.json()).then(r => r.clientSecret);

  checkout = stripe.initCheckoutElementsSdk({
    clientSecret: clientSecretPromise,
    elementsOptions: { appearance: {} },
    adaptivePricing: { allowed: true },
  });

  checkout.on('change', session => {
    document.getElementById('submit').disabled = !session.canConfirm;
  });

  const result = await checkout.loadActions();
  if (result.type === 'success') {
    actions = result.actions;
    const session = actions.getSession();
    document.querySelector('#button-text').textContent =
      `Pay ${session.total.total.amount} now`;
  }

  // Mount UI elements
  checkout.createBillingAddressElement().mount('#address-element');
  checkout.createPaymentElement().mount('#payment-element');
  checkout.createCurrencySelectorElement().mount('#currency-selector');
}

async function handleSubmit(e) {
  e.preventDefault();
  const confirmResult = await actions.confirm();
  if (confirmResult.type === 'error') {
    console.error(confirmResult.error.message);
  }
  // On success, Stripe redirects to the return_url automatically
}

```

--------------------------------

### Initialize Stripe and Create Payment Request

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/client/VIDEOS.md

Initialize Stripe with your publishable key and create a payment request object. Configure the payment request with currency, country, and total amount details. This object is essential for setting up the payment flow.

```javascript
const stripe = Stripe('pk_test_12345'); // Replace with your publishable key

const elements = stripe.elements();
const paymentRequest = stripe.paymentRequest({
  country: 'US',
  currency: 'usd',
  total: {
    label: 'Demo total',
    amount: 1999,
  },
});
```

--------------------------------

### Initialize Stripe with Publishable Key

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/client/VIDEOS.md

Initialize the Stripe object with your publishable key. This should be done after the DOM is fully loaded.

```javascript
const stripe = Stripe('pk_test_1234');
const elements = stripe.elements();
```

--------------------------------

### Configure Environment Variables for Stripe Integration

Source: https://context7.com/stripe-samples/accept-a-payment/llms.txt

Sets up essential Stripe API keys, webhook secrets, static directory paths, domain URLs, and payment-specific configurations like price IDs or payment method types.

```bash
# .env (place in e.g. prebuilt-checkout-page/server/node/.env)
STRIPE_PUBLISHABLE_KEY=pk_test_...
STRIPE_SECRET_KEY=sk_test_...
STRIPE_WEBHOOK_SECRET=whsec_...       # optional — for webhook signature verification
STATIC_DIR=../../client/html          # path from the server dir to the HTML client
DOMAIN=http://localhost:4242          # base URL for redirect/return URLs
PRICE=price_1Hh1ZeCZ6qsJgndJaX9fauRl # required only for prebuilt-checkout-page
PAYMENT_METHOD_TYPES="card"           # for custom-payment-flow
```

--------------------------------

### Run the .NET Core Application

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/prebuilt-checkout-page/server/dotnet/README.md

Execute this command in your terminal to run the .NET Core application. Ensure your .env file is correctly configured.

```bash
dotnet run
```

--------------------------------

### Add Alipay SDK to build.gradle

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/client/VIDEOS.md

Specify the Alipay SDK in your app's build.gradle file to include it as a dependency. Ensure the path to the SDK in the 'libs' folder is correct.

```gradle
implementation files('libs/alipaySdk-20230301.aar')
```

--------------------------------

### Clone Sample CI Repository for Playwright

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/TESTING.md

Clone the sample-ci repository, specifically checking out the 'playwright' branch for testing purposes.

```bash
git clone --branch playwright ssh://git@github.com/stripe-samples/sample-ci
```

--------------------------------

### Stop Sample App

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/TESTING.md

Stop all running services associated with the sample application using Docker Compose.

```bash
docker compose stop
```

--------------------------------

### Create and Activate Virtual Environment (Windows PowerShell)

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/server/python/README.md

Use these commands to create a new virtual environment named 'env' and activate it for managing project dependencies on Windows.

```powershell
python3 -m venv env
.
env
Scripts
activate.bat
```

--------------------------------

### Create Alipay Payment Parameters

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/client/VIDEOS.md

Constructs the necessary parameters for creating an Alipay payment method and options using the Stripe SDK. Requires importing the Stripe library.

```swift
let paymentIntentParams = StripePaymentMethodParams.AlipayParams(
    // Add billing details if needed
    billingDetails: nil,
    // Add metadata if needed
    metadata: nil
)

let paymentMethodOptions = StripeConfirmPaymentMethodOptions.init()
```

--------------------------------

### Create a Price with Stripe CLI

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/prebuilt-checkout-page/README.md

Create a Price for your product using the Stripe CLI. This Price ID is required for the `.env` file.

```sh
stripe prices create --unit-amount 500 --currency usd -d "product_data[name]=demo"
```

--------------------------------

### Enable Stripe Tax in server.rb

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/prebuilt-checkout-page/server/ruby/README.md

Uncomment the `automatic_tax` configuration in `server.rb` to enable automatic sales tax calculation during checkout. Ensure Stripe Tax is set up and products/prices are configured accordingly.

```ruby
# automatic_tax: { enabled: true },
```

--------------------------------

### Add Stripe.js to your page

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/client/VIDEOS.md

Load Stripe.js directly from js.stripe.com. This is a best practice for all pages.

```html
<script src="https://js.stripe.com/v3/"></script>
```

--------------------------------

### Prepare Payment Intent for Alipay

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/client/VIDEOS.md

Initiates the payment intent preparation by calling the backend model's method. Requires an instance of the backend model and a loading state variable.

```swift
struct AliPayView: View {
    @ObservedObject var backendModel: BackendModel
    @State private var loading = false

    var body: some View {
        VStack {
            if let paymentIntent = backendModel.paymentIntent {
                Button { 
                    // Add logic here
                } label: {
                    Text("Pay with AliPay")
                }
            } else {
                Text("Loading")
            }
        }
        .onAppear {
            backendModel.preparePaymentIntent(currency: "usd")
        }
    }
}
```

--------------------------------

### Fetch Publishable Key in Node.js

Source: https://context7.com/stripe-samples/accept-a-payment/llms.txt

Returns the Stripe publishable key for initializing Stripe.js in the browser. Ensure the `STRIPE_PUBLISHABLE_KEY` is set in your environment variables.

```javascript
// elements-with-checkout-sessions/server/node/server.js
app.get('/config', (req, res) => {
  res.send({ publishableKey: process.env.STRIPE_PUBLISHABLE_KEY });
});
```

```bash
curl http://localhost:4242/config
# { "publishableKey": "pk_test_..." }
```

--------------------------------

### Initialize Stripe and Elements Hooks

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/client/VIDEOS.md

Initialize Stripe and Elements instances using their respective hooks. These instances are crucial for creating payment requests and managing payment elements.

```javascript
const stripe = useStripe();
const elements = useElements();
```

--------------------------------

### Clone the Stripe sample project manually

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/README.md

Manually clone the Stripe sample project from GitHub if you prefer not to use the Stripe CLI.

```sh
git clone https://github.com/stripe-samples/accept-a-payment
```

--------------------------------

### Set up local webhook forwarding with Stripe CLI

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/README.md

Use the Stripe CLI to forward events from Stripe to your local development server for webhook testing.

```sh
stripe listen --forward-to localhost:4242/webhook
```

--------------------------------

### Button Action for Payment

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/client/VIDEOS.md

Handle the button click event to set payment method parameters and initiate the payment confirmation process. This includes updating the loading state.

```swift
Button("Buy") {
    // Action to set payment method params and confirm payment
    self.paymentMethodParams = paymentMethodParams // Assuming paymentMethodParams is bound from the text field
    loading = true
    // Trigger payment confirmation using paymentMethodParams and paymentIntent
}
.padding()
.disabled(loading)
```

--------------------------------

### Enable Stripe Tax in Program.cs

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/prebuilt-checkout-page/server/dotnet/README.md

Uncomment the AutomaticTax configuration in Program.cs to enable Stripe Tax for automatic sales tax calculation during checkout. Ensure your products and prices are set up for tax.

```csharp
AutomaticTax = new SessionAutomaticTaxOptions { Enabled = true },
```

--------------------------------

### Export and Run Flask Application (MacOS/Unix)

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/server/python/README.md

Set the Flask application environment variable and run the Flask development server on port 4242.

```bash
export FLASK_APP=server.py
python3 -m flask run --port=4242
```

--------------------------------

### Enable Stripe Tax in Server.java

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/prebuilt-checkout-page/server/java/README.md

Uncomment the .setAutomaticTax line in Server.java to enable automatic tax calculation during checkout. Ensure Stripe Tax is set up and products/prices are configured.

```java
// .setAutomaticTax(SessionCreateParams.AutomaticTax.builder().setEnabled(true).build())
```

--------------------------------

### cURL Equivalent for Creating Checkout Session

Source: https://context7.com/stripe-samples/accept-a-payment/llms.txt

Demonstrates how to simulate the creation of a Stripe Checkout Session using cURL, showing the expected HTTP status code and redirect URL.

```bash
# curl equivalent
curl -X POST http://localhost:4242/create-checkout-session \
  -w "\nHTTP Status: %{http_code}\nRedirect: %{redirect_url}\n"
# HTTP Status: 303
# Redirect: https://checkout.stripe.com/pay/cs_test_a1b2c3...
```

--------------------------------

### Create Payment Intent Endpoint in Go

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/server/go/TRANSCRIPTS.md

This Go endpoint handles POST requests to create a PaymentIntent. It requires the amount and currency, and returns the client secret of the created PaymentIntent.

```go
http.HandleFunc("/create-payment-intent", func(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
		return
	}

	params := &stripe.PaymentIntentParams{
		Amount:   stripe.Int64(2000), // amount in cents
		Currency: stripe.String("usd"),
	}

	pi, err := paymentintent.New(params)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	response := map[string]interface{}{
		"client_secret": pi.ClientSecret,
	}

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(response)
})
```

--------------------------------

### Create Payment Intent Endpoint (.NET)

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/server/dotnet/TRANSCRIPTS.md

This endpoint creates a PaymentIntent using the Stripe .NET client library. It requires the amount and currency, denoted in the smallest currency denomination. Initialize the PaymentIntentService with your client instance and call CreateAsync.

```csharp
var paymentIntentService = new PaymentIntentService();
var paymentIntent = await paymentIntentService.CreateAsync(
  new PaymentIntentCreateOptions
  {
    Amount = 1000,
    Currency = "usd",
    AutomaticPaymentMethods = new PaymentIntentAutomaticPaymentMethodsOptions
    {
      Enabled = true,
    },
  }
);

return Results.Ok(new {
  ClientSecret = paymentIntent.ClientSecret
});
```

--------------------------------

### Making a POST request to create a PaymentIntent using curl

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/server/python/TRANSCRIPTS.md

This curl command demonstrates how to make a POST request to the '/create-payment-intent' endpoint. It sends an empty JSON object as the request body, which will result in a PaymentIntent being created with default parameters.

```bash
curl -X POST http://localhost:4242/create-payment-intent \
  -H "Content-Type: application/json" \
  -d '{}'
```

--------------------------------

### Enable Stripe Tax in server.py

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/prebuilt-checkout-page/server/python/README.md

Uncomment the 'automatic_tax' line in server.py to enable automatic tax calculation during checkout. Ensure Stripe Tax is set up and products/prices are configured accordingly.

```python
# automatic_tax={'enabled': True},
```

--------------------------------

### Enable Stripe Tax - Go

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/prebuilt-checkout-page/server/go/README.md

Uncomment the AutomaticTax parameter in the Checkout session creation to enable automatic sales tax calculation. Ensure Stripe Tax is set up and products/prices are configured accordingly.

```go
// AutomaticTax: &stripe.CheckoutSessionAutomaticTaxParams{Enabled: stripe.Bool(true)},
```

--------------------------------

### Configure .env File for Stripe API Keys

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/server/python/README.md

Ensure your API keys and other necessary configurations are set in the .env file. This includes Stripe publishable and secret keys, webhook secret, static directory path, and the domain.

```yaml
STRIPE_PUBLISHABLE_KEY=pk_test...
STRIPE_SECRET_KEY=sk_test...

# Required to verify signatures in the webhook handler.
# See README on how to use the Stripe CLI to test webhooks
STRIPE_WEBHOOK_SECRET=whsec_...

# Path to front-end implementation. Note: PHP has it's own front end implementation.
STATIC_DIR=../../client/html
DOMAIN=http://localhost:4242
```

--------------------------------

### Create Checkout Session in Ruby

Source: https://context7.com/stripe-samples/accept-a-payment/llms.txt

Implement the `POST /create-checkout-session` route using Sinatra and the Ruby Stripe SDK. Ensure your Stripe API key and domain are set in your environment variables.

```ruby
# prebuilt-checkout-page/server/ruby/server.rb
require 'stripe'
require 'sinatra'
require 'dotenv'

Dotenv.load
Stripe.api_key = ENV['STRIPE_SECRET_KEY']
Stripe.api_version = '2020-08-27'

post '/create-checkout-session' do
  session = Stripe::Checkout::Session.create(
    success_url: ENV['DOMAIN'] + '/success.html?session_id={CHECKOUT_SESSION_ID}',
    cancel_url:  ENV['DOMAIN'] + '/canceled.html',
    mode: 'payment',
    line_items: [{ quantity: 1, price: ENV['PRICE'] }]
  )
  redirect session.url, 303
end
```

--------------------------------

### Making a POST request with payment method type and currency using curl

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/server/python/TRANSCRIPTS.md

This curl command shows how to send specific payment method types and currency in the request body when creating a PaymentIntent. This allows for more customized payment flows.

```bash
curl -X POST http://localhost:4242/create-payment-intent \
  -H "Content-Type: application/json" \
  -d '{"payment_method_types": ["card"], "currency": "usd"}'
```

--------------------------------

### Create Price with Tax Behavior

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/prebuilt-checkout-page/README.md

Create a price with a specified tax behavior (inclusive or exclusive) after creating a product with a tax code. Use the product ID obtained from the previous step.

```sh
stripe prices create \
  --unit-amount=500 \
  --currency=usd \
  --tax-behavior=exclusive \
  --product=<INSERT_ID, like prod_ABC123>
```

--------------------------------

### Create Checkout Session with Elements in Node.js

Source: https://context7.com/stripe-samples/accept-a-payment/llms.txt

Creates a Checkout Session with `ui_mode: "elements"` for on-site rendering. Returns the session's `client_secret` to the browser. Ensure `YOUR_DOMAIN` is set and Stripe API key is configured.

```javascript
// elements-with-checkout-sessions/server/node/server.js
const client = require('stripe')(process.env.STRIPE_SECRET_KEY);

app.post('/create-checkout-session', async (req, res) => {
  try {
    const session = await client.checkout.sessions.create({
      ui_mode: 'elements',                   // render on-site, not Stripe-hosted
      mode: 'payment',
      line_items: [{
        price_data: {
          product_data: { name: 'T-shirt' },
          currency: 'usd',
          unit_amount: 2000,                 // $20.00
        },
        quantity: 1,
      }],
      adaptive_pricing: { enabled: true },   // localized currency for global customers
      customer_email: 'test+location_FR@example.com',
      return_url: `${YOUR_DOMAIN}/complete?session_id={CHECKOUT_SESSION_ID}`,
    });

    res.send({ clientSecret: session.client_secret });
    // Response: { "clientSecret": "cs_test_...secret..." }
  } catch (e) {
    res.status(400).send({ error: { message: e.message } });
  }
});
```

--------------------------------

### Create and Mount Stripe Card Element

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/client/VIDEOS.md

Create a Stripe card element and mount it to a specified div. This is for collecting card details.

```javascript
const cardElement = elements.create('card');
cardElement.mount('#card-element');
```

--------------------------------

### Create PaymentIntent with payment method types and currency

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/server/python/TRANSCRIPTS.md

This refactored endpoint allows specifying 'payment_method_types' and 'currency' from the request body. This enables flexibility in accepting various payment methods and currencies.

```python
from flask import Flask, request, jsonify
import stripe

# Set your secret key: remember to switch to your live secret key in production
# See https://stripe.com/docs/development for more information.
stripe.api_key = 'sk_test_...';

app = Flask(__name__)

@app.route('/create-payment-intent', methods=['POST'])
def create_payment_intent():
    try:
        data = request.get_json()
        amount = data.get('amount')
        currency = data.get('currency')
        payment_method_types = data.get('payment_method_types')

        if not amount or not currency:
            return jsonify({'error': 'Missing amount or currency'})

        # Create a PaymentIntent with the order amount and currency
        intent = stripe.PaymentIntent.create(
            amount=amount,
            currency=currency,
            payment_method_types=payment_method_types if payment_method_types else ['card'],
        )

        return jsonify({
            'clientSecret': intent['client_secret'],
        })
    except Exception as e:
        return jsonify({'error': str(e)})

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

--------------------------------

### Making a POST Request with Curl

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/server/go/TRANSCRIPTS.md

This command demonstrates how to make a POST request to the /create-payment-intent endpoint using curl. It sends an empty JSON object in the request body.

```bash
curl -X POST http://localhost:4242 \
  -d '{}'
```

--------------------------------

### Create Apple Pay Component Structure

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/client/VIDEOS.md

Set up a basic functional React component for Apple Pay. This includes importing necessary hooks and libraries, and defining the component's structure.

```javascript
import React from "react";
import { withRouter } from "react-router-dom";

const ApplePay = (props) => {
  // Component logic will go here
  return (
    <div>
      <h1>Apple Pay</h1>
    </div>
  );
};

export default withRouter(ApplePay);
```

--------------------------------

### Enable Stripe Tax in create-checkout-session.php

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/prebuilt-checkout-page/server/php/README.md

Uncomment the 'automatic_tax' line in the create-checkout-session.php file to enable automatic sales tax calculation during checkout. Ensure Stripe Tax is set up and products/prices are configured accordingly.

```php
// 'automatic_tax' => ['enabled' => true],
```

--------------------------------

### Configure DOMAIN for React client

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/elements-with-checkout-sessions/README.md

Sets the DOMAIN environment variable in the server's .env file to the React development server's URL. This ensures Stripe redirects correctly after payment.

```bash
# In your server's .env
DOMAIN=http://localhost:3000
```

--------------------------------

### Stripe API Keys Configuration

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/server/go/README.md

Configure your Stripe API keys and webhook secret in the .env file. Ensure STATIC_DIR and DOMAIN are also set correctly.

```yaml
# Stripe API keys - see https://stripe.com/docs/development/quickstart#api-keys
STRIPE_PUBLISHABLE_KEY=pk_test...
STRIPE_SECRET_KEY=sk_test...

# Required to verify signatures in the webhook handler.
# See README on how to use the Stripe CLI to test webhooks
STRIPE_WEBHOOK_SECRET=whsec_...

# Path to front-end implementation. Note: PHP has it's own front end implementation.
STATIC_DIR=../../client/html
DOMAIN=http://localhost:4242
```

--------------------------------

### Node.js - Fetch Publishable Key

Source: https://context7.com/stripe-samples/accept-a-payment/llms.txt

This endpoint retrieves the Stripe publishable key, which is necessary for initializing Stripe.js in the browser without hard-coding it.

```APIDOC
## GET /config

### Description
Fetches the Stripe publishable key. This key is required for initializing Stripe.js on the client side.

### Method
GET

### Endpoint
/config

### Response
#### Success Response (200)
- **publishableKey** (string) - The Stripe publishable key.

### Request Example
```bash
curl http://localhost:4242/config
```

### Response Example
```json
{
  "publishableKey": "pk_test_..."
}
```
```

--------------------------------

### Create Checkout Session in Python

Source: https://context7.com/stripe-samples/accept-a-payment/llms.txt

Implement the `POST /create-checkout-session` route using Flask and the Python Stripe SDK. Ensure your Stripe API key and domain are set in your environment variables.

```python
# prebuilt-checkout-page/server/python/server.py
import stripe, os
from flask import Flask, redirect, request, jsonify
from dotenv import load_dotenv

load_dotenv()
stripe.api_key = os.getenv('STRIPE_SECRET_KEY')
stripe.api_version = '2020-08-27'

@app.route('/create-checkout-session', methods=['POST'])
def create_checkout_session():
    domain_url = os.getenv('DOMAIN')
    try:
        checkout_session = stripe.checkout.Session.create(
            success_url=domain_url + '/success.html?session_id={CHECKOUT_SESSION_ID}',
            cancel_url=domain_url + '/canceled.html',
            mode='payment',
            line_items=[{'price': os.getenv('PRICE'), 'quantity': 1}]
        )
        return redirect(checkout_session.url, code=303)
    except Exception as e:
        return jsonify(error=str(e)), 403
```

--------------------------------

### Stripe API Keys Configuration

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/server/node/README.md

Configure your Stripe API keys and webhook secret in the .env file. Ensure DOMAIN and STATIC_DIR are also set correctly.

```yaml
STRIPE_PUBLISHABLE_KEY=pk_test...
STRIPE_SECRET_KEY=sk_test...

STRIPE_WEBHOOK_SECRET=whsec_...

STATIC_DIR=../../client/html
DOMAIN=http://localhost:4242
```

--------------------------------

### Create PaymentIntent with Custom Options (Node.js)

Source: https://context7.com/stripe-samples/accept-a-payment/llms.txt

Handles POST requests to create a PaymentIntent with specific payment method types, currency, and optional payment method configurations. Supports special handling for ACSS debit, Konbini, and customer balance payments.

```javascript
// custom-payment-flow/server/node/server.js
app.post('/create-payment-intent', async (req, res) => {
  const { paymentMethodType, currency, paymentMethodOptions } = req.body;
  let orderAmount = 5999;  // $59.99
  let params = {
    payment_method_types: paymentMethodType === 'link'
      ? ['link', 'card']
      : [paymentMethodType],
    amount: orderAmount,
    currency: currency,
  };

  // Special handling for ACSS debit — requires a mandate
  if (paymentMethodType === 'acss_debit') {
    params.payment_method_options = {
      acss_debit: {
        mandate_options: {
          payment_schedule: 'sporadic',
          transaction_type: 'personal',
        },
      },
    };
  }

  // Special handling for Konbini (Japanese convenience store payment)
  if (paymentMethodType === 'konbini') {
    params.payment_method_options = {
      konbini: { product_description: 'Tシャツ', expires_after_days: 3 },
    };
  }

  // Customer balance — confirm immediately with a customer object
  if (paymentMethodType === 'customer_balance') {
    params.payment_method_data = { type: 'customer_balance' };
    params.confirm = true;
    params.customer = req.body.customerId
      || await stripe.customers.create().then(d => d.id);
  }

  try {
    const paymentIntent = await stripe.paymentIntents.create(params);
    res.send({
      clientSecret: paymentIntent.client_secret,
      nextAction: paymentIntent.next_action,
    });
    // Response: { "clientSecret": "pi_3..._secret_...", "nextAction": null }
  } catch (e) {
    res.status(400).send({ error: { message: e.message } });
  }
});
```

--------------------------------

### Create PaymentIntent endpoint in Python Flask

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/server/python/TRANSCRIPTS.md

This route handles POST requests to create a PaymentIntent. It requires 'amount' and 'currency' as minimum arguments. The amount should be in the smallest currency denomination (e.g., cents).

```python
from flask import Flask, request, jsonify
import stripe

# Set your secret key: remember to switch to your live secret key in production
# See https://stripe.com/docs/development for more information.
stripe.api_key = 'sk_test_...';

app = Flask(__name__)

@app.route('/create-payment-intent', methods=['POST'])
def create_payment_intent():
    try:
        data = request.get_json()
        amount = data.get('amount')
        currency = data.get('currency')

        if not amount or not currency:
            return jsonify({'error': 'Missing amount or currency'})

        # Create a PaymentIntent with the order amount and currency
        intent = stripe.PaymentIntent.create(
            amount=amount,
            currency=currency,
            # In the latest version of the API, specifying the `automatic_payment_methods` parameter
            # is optional because Stripe enables its functionality by default. However, it's recommended
            # to still include it for forward compatibility in case backward compatibility
            # is removed in future versions. 
            automatic_payment_methods={
                'enabled': True,
            },
        )

        return jsonify({
            'clientSecret': intent['client_secret'],
        })
    except Exception as e:
        return jsonify({'error': str(e)})

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

--------------------------------

### Create Payment Intent with Payment Method Types (Ruby)

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/server/ruby/TRANSCRIPTS.md

Refactors the PaymentIntent creation endpoint to accept payment method types and currency from the request body. This allows for more flexible payment configurations.

```ruby
post "/create_payment_intent" do
  content_type :json
  begin
    request_json = JSON.parse(request.body.read)
    payment_method_types = request_json['payment_method_types']
    currency = request_json['currency']

    # Create a PaymentIntent with the order amount and currency
    payment_intent = Stripe::PaymentIntent.create({
      amount: 1999, # $19.99
      currency: currency,
      payment_method_types: payment_method_types
    })

    # Return the client secret to the front end
    json({ clientSecret: payment_intent['client_secret'] })
  rescue Stripe::StripeError => e
    status 500
    return { error: e.message }.to_json
  rescue JSON::ParserError => e
    status 400
    return { error: "Invalid JSON" }.to_json
  end
end
```

--------------------------------

### Run Server API Tests

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/TESTING.md

Execute server API tests using the 'runner' service and RSpec.

```bash
docker compose exec runner bundle exec rspec spec/custom_payment_flow_server_spec.rb
```

--------------------------------

### Ruby - Create Checkout Session

Source: https://context7.com/stripe-samples/accept-a-payment/llms.txt

This snippet demonstrates creating a Stripe Checkout Session using Sinatra and the Ruby Stripe SDK. It redirects the user to Stripe's hosted checkout page.

```APIDOC
## POST /create-checkout-session

### Description
Creates a Stripe Checkout Session using Sinatra and the Ruby Stripe SDK. The user is redirected to Stripe's hosted checkout page upon successful session creation.

### Method
POST

### Endpoint
/create-checkout-session

### Request Body
(Implicitly defined by environment variables: STRIPE_SECRET_KEY, DOMAIN, PRICE)

### Response
- Redirects to the success or cancel URL.
```

--------------------------------

### Create Payment Intent on Server

Source: https://github.com/stripe-samples/accept-a-payment/blob/main/custom-payment-flow/client/VIDEOS.md

Makes a POST request to the server to create a PaymentIntent, expecting a client secret in the response. Matches the 'create-payment-intent' endpoint.

```javascript
const response = await fetch('/create-payment-intent', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    paymentMethodType: 'card',
    currency: 'eur',
  }),
});
const { clientSecret } = await response.json();
```
Tokens:
Raw