PayPal standard full integration example

curl -X POST https://api-m.sandbox.paypal.com/v2/checkout/orders \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer ACCESS_TOKEN" \
  -d '{
    "intent": "CAPTURE",
    "purchase_units": [
      {
        "reference_id": "d9f80740-38f0-11e8-b467-0ed5f89f718b",
        "amount": {
          "currency_code": "USD",
          "value": "100.00"
        },
        "payee": {
          "email_address": "payee@example.com",
          "merchant_id": "MERCHANT-ID"
        },
        "soft_descriptor": "PAYPAL *TEST STORE",
        "shipping": {
          "name": {
            "full_name": "Firstname Lastname"
          },
          "address": {
            "address_line_1": "123 Main St.",
            "admin_area_1": "CA",
            "admin_area_2": "Anytown",
            "postal_code": "12345",
            "country_code": "US"
          }
        }
      }
    ],
    "payment_source": {
      "paypal": {
        "experience_context": {
          "return_url": "https://example.com/return",
          "cancel_url": "https://example.com/cancel",
          "brand_name": "EXAMPLE INC",
          "locale": "en-US",
          "landing_page": "BILLING",
          "shipping_preference": "SET_PROVIDED_ADDRESS",
          "user_action": "PAY_NOW"
        }
      }
    }
  }'

import { Client, orders } from '@paypal/checkout-server-sdk';

const client = new Client({
  clientId: process.env.PAYPAL_CLIENT_ID,
  clientSecret: process.env.PAYPAL_CLIENT_SECRET,
  environment: 'sandbox'
});

const createOrderRequest = new orders.OrdersCreateRequest();
createOrderRequest.prefer("return=representation");
createOrderRequest.requestBody({
  intent: "CAPTURE",
  purchase_units: [
    {
      reference_id: "d9f80740-38f0-11e8-b467-0ed5f89f718b",
      amount: {
        currency_code: "USD",
        value: "100.00"
      },
      payee: {
        email_address: "payee@example.com",
        merchant_id: "MERCHANT-ID"
      },
      soft_descriptor: "PAYPAL *TEST STORE",
      shipping: {
        name: {
          full_name: "Firstname Lastname"
        },
        address: {
          address_line_1: "123 Main St.",
          admin_area_1: "CA",
          admin_area_2: "Anytown",
          postal_code: "12345",
          country_code: "US"
        }
      }
    }
  ],
  payment_source: {
    paypal: {
      experience_context: {
        return_url: "https://example.com/return",
        cancel_url: "https://example.com/cancel",
        brand_name: "EXAMPLE INC",
        locale: "en-US",
        landing_page: "BILLING",
        shipping_preference: "SET_PROVIDED_ADDRESS",
        user_action: "PAY_NOW"
      }
    }
  }
});

const response = await client.execute(createOrderRequest);
const order = response.result;
console.log(`Order ID: ${order.id}`);
console.log(`Order Status: ${order.status}`);

from paypalrestsdk import Api, Order
import os

api = Api({
  'mode': 'sandbox',
  'client_id': os.environ['PAYPAL_CLIENT_ID'],
  'client_secret': os.environ['PAYPAL_CLIENT_SECRET']
})

order = Order({
  "intent": "CAPTURE",
  "purchase_units": [
    {
      "reference_id": "d9f80740-38f0-11e8-b467-0ed5f89f718b",
      "amount": {
        "currency_code": "USD",
        "value": "100.00"
      },
      "payee": {
        "email_address": "payee@example.com",
        "merchant_id": "MERCHANT-ID"
      },
      "soft_descriptor": "PAYPAL *TEST STORE",
      "shipping": {
        "name": {
          "full_name": "Firstname Lastname"
        },
        "address": {
          "address_line_1": "123 Main St.",
          "admin_area_1": "CA",
          "admin_area_2": "Anytown",
          "postal_code": "12345",
          "country_code": "US"
        }
      }
    }
  ],
  "payment_source": {
    "paypal": {
      "experience_context": {
        "return_url": "https://example.com/return",
        "cancel_url": "https://example.com/cancel",
        "brand_name": "EXAMPLE INC",
        "locale": "en-US",
        "landing_page": "BILLING",
        "shipping_preference": "SET_PROVIDED_ADDRESS",
        "user_action": "PAY_NOW"
      }
    }
  }
})

if order.create():
  print(f"Order ID: {order.id}")
  print(f"Order Status: {order.status}")
else:
  print(f"Error: {order.error}")

import com.paypal.core.PayPalEnvironment;
import com.paypal.core.PayPalHttpClient;
import com.paypal.orders.*;
import java.util.List;

HttpClient httpClient = new PayPalHttpClient(
  new SandboxEnvironment(
    System.getenv("PAYPAL_CLIENT_ID"),
    System.getenv("PAYPAL_CLIENT_SECRET")
  )
);

OrdersCreateRequest request = new OrdersCreateRequest();
request.header("Prefer", "return=representation");
request.body(new OrderRequest()
  .intent("CAPTURE")
  .purchaseUnits(List.of(
    new PurchaseUnitRequest()
      .referenceId("d9f80740-38f0-11e8-b467-0ed5f89f718b")
      .amount(new Money()
        .currencyCode("USD")
        .value("100.00")
      )
      .payee(new Payee()
        .emailAddress("payee@example.com")
        .merchantId("MERCHANT-ID")
      )
      .softDescriptor("PAYPAL *TEST STORE")
      .shipping(new ShippingDetail()
        .name(new Name().fullName("Firstname Lastname"))
        .address(new AddressPortable()
          .addressLine1("123 Main St.")
          .adminArea1("CA")
          .adminArea2("Anytown")
          .postalCode("12345")
          .countryCode("US")
        )
      )
  ))
  .paymentSource(new PaymentSourceDefinition()
    .paypal(new PayPalWallet()
      .experienceContext(new PayPalExperienceContext()
        .returnUrl("https://example.com/return")
        .cancelUrl("https://example.com/cancel")
        .brandName("EXAMPLE INC")
        .locale("en-US")
        .landingPage("BILLING")
        .shippingPreference("SET_PROVIDED_ADDRESS")
        .userAction("PAY_NOW")
      )
    )
  )
);

HttpResponse<Order> response = httpClient.execute(request);
Order order = response.result();
System.out.println("Order ID: " + order.id());
System.out.println("Order Status: " + order.status());

<?php
use PayPalCheckoutSdk\Core\SandboxEnvironment;
use PayPalCheckoutSdk\Core\PayPalHttpClient;
use PayPalCheckoutSdk\Orders\OrdersCreateRequest;

$environment = new SandboxEnvironment(
  getenv('PAYPAL_CLIENT_ID'),
  getenv('PAYPAL_CLIENT_SECRET')
);
$client = new PayPalHttpClient($environment);

$request = new OrdersCreateRequest();
$request->prefer("return=representation");
$request->body = [
  "intent" => "CAPTURE",
  "purchase_units" => [
    [
      "reference_id" => "d9f80740-38f0-11e8-b467-0ed5f89f718b",
      "amount" => [
        "currency_code" => "USD",
        "value" => "100.00"
      ],
      "payee" => [
        "email_address" => "payee@example.com",
        "merchant_id" => "MERCHANT-ID"
      ],
      "soft_descriptor" => "PAYPAL *TEST STORE",
      "shipping" => [
        "name" => [
          "full_name" => "Firstname Lastname"
        ],
        "address" => [
          "address_line_1" => "123 Main St.",
          "admin_area_1" => "CA",
          "admin_area_2" => "Anytown",
          "postal_code" => "12345",
          "country_code" => "US"
        ]
      ]
    ]
  ],
  "payment_source" => [
    "paypal" => [
      "experience_context" => [
        "return_url" => "https://example.com/return",
        "cancel_url" => "https://example.com/cancel",
        "brand_name" => "EXAMPLE INC",
        "locale" => "en-US",
        "landing_page" => "BILLING",
        "shipping_preference" => "SET_PROVIDED_ADDRESS",
        "user_action" => "PAY_NOW"
      ],
    ]
  ]
];

$response = $client->execute($request);
echo "Order ID: " . $response->result->id . "\n";
echo "Order Status: " . $response->result->status . "\n";

require 'paypal-sdk'

PayPal::SDK.configure(
  :mode => "sandbox",
  :app_id => ENV['PAYPAL_APP_ID'],
  :client_id => ENV['PAYPAL_CLIENT_ID'],
  :client_secret => ENV['PAYPAL_CLIENT_SECRET']
)

order = PayPal::SDK::OrdersApi::Order.new(
  intent: "CAPTURE",
  purchase_units: [
    {
      reference_id: "d9f80740-38f0-11e8-b467-0ed5f89f718b",
      amount: {
        currency_code: "USD",
        value: "100.00"
      },
      payee: {
        email_address: "payee@example.com",
        merchant_id: "MERCHANT-ID"
      },
      soft_descriptor: "PAYPAL *TEST STORE",
      shipping: {
        name: {
          full_name: "Firstname Lastname"
        },
        address: {
          address_line_1: "123 Main St.",
          admin_area_1: "CA",
          admin_area_2: "Anytown",
          postal_code: "12345",
          country_code: "US"
        }
      }
    }
  ],
  payment_source: {
    paypal: {
      experience_context: {
        return_url: "https://example.com/return",
        cancel_url: "https://example.com/cancel",
        brand_name: "EXAMPLE INC",
        locale: "en-US",
        landing_page: "BILLING",
        shipping_preference: "SET_PROVIDED_ADDRESS",
        user_action: "PAY_NOW"
      }
    }
  }
)

order.create
puts "Order ID: #{order.id}"
puts "Order Status: #{order.status}"

# Get client token
curl -X POST https://api-m.sandbox.paypal.com/v1/oauth2/token \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -H "Authorization: Basic BASE64_ENCODED_CLIENT_ID_SECRET" \
  -d "grant_type=client_credentials&target_customer_id=CUSTOMER_ID"

# Capture order
curl -X POST https://api-m.sandbox.paypal.com/v2/checkout/orders/ORDER_ID/capture \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer ACCESS_TOKEN" \
  -d '{}'

import { Client, orders } from '@paypal/checkout-server-sdk';

const client = new Client({
  clientId: process.env.PAYPAL_CLIENT_ID,
  clientSecret: process.env.PAYPAL_CLIENT_SECRET,
  environment: 'sandbox'
});

// Generate client token for browser
async function getBrowserSafeClientToken() {
  const tokenResponse = await fetch(
    'https://api-m.sandbox.paypal.com/v1/oauth2/token',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/x-www-form-urlencoded',
        'Authorization': `Basic ${Buffer.from(
          `${process.env.PAYPAL_CLIENT_ID}:${process.env.PAYPAL_CLIENT_SECRET}`
        ).toString('base64')}`
      },
      body: 'grant_type=client_credentials'
    }
  );

  const data = await tokenResponse.json();
  return data.access_token;
}

// Capture order after approval
async function captureOrder({ orderId }) {
  const captureRequest = new orders.OrdersCaptureRequest(orderId);
  captureRequest.prefer("return=representation");

  const response = await client.execute(captureRequest);
  return response.result;
}

from paypalrestsdk import Api, Order
import os
import base64
import requests

api = Api({
  'mode': 'sandbox',
  'client_id': os.environ['PAYPAL_CLIENT_ID'],
  'client_secret': os.environ['PAYPAL_CLIENT_SECRET']
})

def get_browser_safe_client_token():
    """Generate client token for browser"""
    auth = base64.b64encode(
        f"{os.environ['PAYPAL_CLIENT_ID']}:{os.environ['PAYPAL_CLIENT_SECRET']}".encode()
    ).decode()

    response = requests.post(
        'https://api-m.sandbox.paypal.com/v1/oauth2/token',
        headers={
            'Content-Type': 'application/x-www-form-urlencoded',
            'Authorization': f'Basic {auth}'
        },
        data='grant_type=client_credentials'
    )

    return response.json()['access_token']

def capture_order(order_id):
    """Capture order after approval"""
    order = Order.find(order_id)

    if order.execute():
        return order.to_dict()
    else:
        raise Exception(order.error)

import com.paypal.core.PayPalEnvironment;
import com.paypal.core.PayPalHttpClient;
import com.paypal.orders.*;
import java.util.Base64;
import java.net.http.*;
import java.net.URI;

public class PayPalHelpers {
    private static HttpClient httpClient = new PayPalHttpClient(
        new SandboxEnvironment(
            System.getenv("PAYPAL_CLIENT_ID"),
            System.getenv("PAYPAL_CLIENT_SECRET")
        )
    );

    public static String getBrowserSafeClientToken() throws Exception {
        String auth = Base64.getEncoder().encodeToString(
            (System.getenv("PAYPAL_CLIENT_ID") + ":" +
             System.getenv("PAYPAL_CLIENT_SECRET")).getBytes()
        );

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api-m.sandbox.paypal.com/v1/oauth2/token"))
            .header("Content-Type", "application/x-www-form-urlencoded")
            .header("Authorization", "Basic " + auth)
            .POST(HttpRequest.BodyPublishers.ofString("grant_type=client_credentials"))
            .build();

        HttpResponse<String> response = HttpClient.newHttpClient()
            .send(request, HttpResponse.BodyHandlers.ofString());

        // Parse JSON and return access_token
        return parseAccessToken(response.body());
    }

    public static Order captureOrder(String orderId) throws Exception {
        OrdersCaptureRequest request = new OrdersCaptureRequest(orderId);
        request.prefer("return=representation");

        HttpResponse<Order> response = httpClient.execute(request);
        return response.result();
    }
}

<?php
use PayPalCheckoutSdk\Core\SandboxEnvironment;
use PayPalCheckoutSdk\Core\PayPalHttpClient;
use PayPalCheckoutSdk\Orders\OrdersCaptureRequest;

$environment = new SandboxEnvironment(
  getenv('PAYPAL_CLIENT_ID'),
  getenv('PAYPAL_CLIENT_SECRET')
);
$client = new PayPalHttpClient($environment);

function getBrowserSafeClientToken() {
  $auth = base64_encode(
    getenv('PAYPAL_CLIENT_ID') . ':' . getenv('PAYPAL_CLIENT_SECRET')
  );

  $ch = curl_init('https://api-m.sandbox.paypal.com/v1/oauth2/token');
  curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  curl_setopt($ch, CURLOPT_POST, true);
  curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/x-www-form-urlencoded',
    'Authorization: Basic ' . $auth
  ]);
  curl_setopt($ch, CURLOPT_POSTFIELDS, 'grant_type=client_credentials');

  $response = curl_exec($ch);
  curl_close($ch);

  $data = json_decode($response, true);
  return $data['access_token'];
}

function captureOrder($orderId) {
  global $client;

  $request = new OrdersCaptureRequest($orderId);
  $request->prefer("return=representation");

  $response = $client->execute($request);
  return $response->result;
}

require 'paypal-sdk'
require 'base64'
require 'net/http'
require 'json'

PayPal::SDK.configure(
  :mode => "sandbox",
  :app_id => ENV['PAYPAL_APP_ID'],
  :client_id => ENV['PAYPAL_CLIENT_ID'],
  :client_secret => ENV['PAYPAL_CLIENT_SECRET']
)

def get_browser_safe_client_token
  auth = Base64.strict_encode64(
    "#{ENV['PAYPAL_CLIENT_ID']}:#{ENV['PAYPAL_CLIENT_SECRET']}"
  )

  uri = URI('https://api-m.sandbox.paypal.com/v1/oauth2/token')
  request = Net::HTTP::Post.new(uri)
  request['Content-Type'] = 'application/x-www-form-urlencoded'
  request['Authorization'] = "Basic #{auth}"
  request.body = 'grant_type=client_credentials'

  response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
    http.request(request)
  end

  data = JSON.parse(response.body)
  data['access_token']
end

def capture_order(order_id)
  order = PayPal::SDK::OrdersApi::Order.new(id: order_id)
  order.capture
  order
end