iOS basic integration

# Available as a gem
gem install stripe
# Available as a gem
gem install stripe

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

# Install through pip
pip install --upgrade stripe
# Install through pip
pip install --upgrade stripe

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

# Find the version you want to pin:
# https://github.com/stripe/stripe-python/blob/master/CHANGELOG.md
# Specify that version in your requirements.txt file
stripe>=2.48.0,<3.0
# Find the version you want to pin:
# https://github.com/stripe/stripe-python/blob/master/CHANGELOG.md
# Specify that version in your requirements.txt file
stripe>=2.48.0,<3.0

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

# Or download the source directly: https://github.com/stripe/stripe-php/releases
# 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 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 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
# 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 via npm
npm install --save stripe

# Make sure your project is using Go Modules
go mod init
# Install stripe-go
go get -u github.com/stripe/stripe-go/v71
# Make sure your project is using Go Modules
go mod init
# Install stripe-go
go get -u github.com/stripe/stripe-go/v71

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

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

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

import UIKit
import Stripe

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {

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

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: 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 "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

curl https://api.stripe.com/v1/ephemeral_keys \
-u sk_test_4eC39HqLyjWDarjtT1zdp7dc: \
-d customer="{{CUSTOMER_ID}}" \
-H "Stripe-Version: {{API_VERSION}}"
curl https://api.stripe.com/v1/ephemeral_keys \
-u sk_test_4eC39HqLyjWDarjtT1zdp7dc: \
-d customer="{{CUSTOMER_ID}}" \
-H "Stripe-Version: {{API_VERSION}}"

key = Stripe::EphemeralKey.create(
  {customer: '{{CUSTOMER_ID}}'},
  {stripe_version: '{{API_VERSION}}'}
)
key = Stripe::EphemeralKey.create(
  {customer: '{{CUSTOMER_ID}}'},
  {stripe_version: '{{API_VERSION}}'}
)

key = stripe.EphemeralKey.create(customer='{{CUSTOMER_ID}}', stripe_version='{{API_VERSION}}')
key = stripe.EphemeralKey.create(customer='{{CUSTOMER_ID}}', stripe_version='{{API_VERSION}}')

$key = \Stripe\EphemeralKey::create(
  ['customer' => '{{CUSTOMER_ID}}'],
  ['stripe_version' => '{{API_VERSION}}']
);
$key = \Stripe\EphemeralKey::create(
  ['customer' => '{{CUSTOMER_ID}}'],
  ['stripe_version' => '{{API_VERSION}}']
);

let key = await stripe.ephemeralKeys.create(
  {customer: '{{CUSTOMER_ID}}'},
  {stripe_version: '{{API_VERSION}}'}
);
let key = await stripe.ephemeralKeys.create(
  {customer: '{{CUSTOMER_ID}}'},
  {stripe_version: '{{API_VERSION}}'}
);

RequestOptions requestOptions = (new RequestOptions.RequestOptionsBuilder())
  .setStripeVersion("{{API_VERSION}}")
  .build();
Map<String, Object> options = new HashMap<String, Object>();
options.put("customer", "{{CUSTOMER_ID}}");
EphemeralKey key = EphemeralKey.create(options, requestOptions);
RequestOptions requestOptions = (new RequestOptions.RequestOptionsBuilder())
  .setStripeVersion("{{API_VERSION}}")
  .build();
Map<String, Object> options = new HashMap<String, Object>();
options.put("customer", "{{CUSTOMER_ID}}");
EphemeralKey key = EphemeralKey.create(options, requestOptions);

params := &stripe.EphemeralKeyParams{
  Customer: stripe.String("{{CUSTOMER_ID}}"),
  StripeVersion: stripe.String("{{API_VERSION}}"),
}
key, _ := ephemeralkey.New(params)
params := &stripe.EphemeralKeyParams{
  Customer: stripe.String("{{CUSTOMER_ID}}"),
  StripeVersion: stripe.String("{{API_VERSION}}"),
}
key, _ := ephemeralkey.New(params)

var options = new EphemeralKeyCreateOptions
{
  Customer = "{{CUSTOMER_ID}}",
  StripeVersion = "{{API_VERSION}}"
};
var service = new EphemeralKeyService();
service.Create(options);
var options = new EphemeralKeyCreateOptions
{
  Customer = "{{CUSTOMER_ID}}",
  StripeVersion = "{{API_VERSION}}"
};
var service = new EphemeralKeyService();
service.Create(options);

import Stripe

class MyAPIClient: NSObject, STPCustomerEphemeralKeyProvider {

    func createCustomerKey(withAPIVersion apiVersion: String, completion: @escaping STPJSONResponseCompletionBlock) {
        let url = self.baseURL.appendingPathComponent("ephemeral_keys")
        var urlComponents = URLComponents(url: url, resolvingAgainstBaseURL: false)!
        urlComponents.queryItems = [URLQueryItem(name: "api_version", value: apiVersion)]
        var request = URLRequest(url: urlComponents.url!)
        request.httpMethod = "POST"
        let task = URLSession.shared.dataTask(with: request, completionHandler: { (data, response, error) in
            guard let response = response as? HTTPURLResponse,
                response.statusCode == 200,
                let data = data,
                let json = ((try? JSONSerialization.jsonObject(with: data, options: []) as? [String : Any]) as [String : Any]??) else {
                completion(nil, error)
                return
            }
            completion(json, nil)
        })
        task.resume()
    }
}
import Stripe

class MyAPIClient: NSObject, STPCustomerEphemeralKeyProvider {

    func createCustomerKey(withAPIVersion apiVersion: String, completion: @escaping STPJSONResponseCompletionBlock) {
        let url = self.baseURL.appendingPathComponent("ephemeral_keys")
        var urlComponents = URLComponents(url: url, resolvingAgainstBaseURL: false)!
        urlComponents.queryItems = [URLQueryItem(name: "api_version", value: apiVersion)]
        var request = URLRequest(url: urlComponents.url!)
        request.httpMethod = "POST"
        let task = URLSession.shared.dataTask(with: request, completionHandler: { (data, response, error) in
            guard let response = response as? HTTPURLResponse,
                response.statusCode == 200,
                let data = data,
                let json = ((try? JSONSerialization.jsonObject(with: data, options: []) as? [String : Any]) as [String : Any]??) else {
                completion(nil, error)
                return
            }
            completion(json, nil)
        })
        task.resume()
    }
}

// In MyApiClient.h, declare conformance to STPCustomerEphemeralKeyProvider:
// @interface MyAPIClient : NSObject <STPCustomerEphemeralKeyProvider>

@implementation MyAPIClient

- (void)createCustomerKeyWithAPIVersion:(NSString *)apiVersion completion:(STPJSONResponseCompletionBlock)completion {
    NSURL *url = [self.baseURL URLByAppendingPathComponent:@"ephemeral_keys"];
    NSURLComponents *urlComponents = [NSURLComponents componentsWithURL:url resolvingAgainstBaseURL:NO];
    urlComponents.queryItems = @[[[NSURLQueryItem alloc] initWithName:@"api_version" value:apiVersion]];
    NSURLRequest *request = [[NSURLRequest alloc] initWithURL:urlComponents.URL];
    NSURLSessionDataTask *task = [[NSURLSession sharedSession] dataTaskWithRequest:request completionHandler:^(NSData * _Nullable data, NSURLResponse * _Nullable response, NSError * _Nullable error) {
        if (data != nil && [response isKindOfClass:[NSHTTPURLResponse class]] && ((NSHTTPURLResponse *)response).statusCode == 200) {
            NSDictionary *json = [NSJSONSerialization JSONObjectWithData:data options:0 error:nil];
            completion(json, nil);
        } else {
            completion(nil, error);
        }
    }];
    [task resume];
}

@end
// In MyApiClient.h, declare conformance to STPCustomerEphemeralKeyProvider:
// @interface MyAPIClient : NSObject <STPCustomerEphemeralKeyProvider>

@implementation MyAPIClient

- (void)createCustomerKeyWithAPIVersion:(NSString *)apiVersion completion:(STPJSONResponseCompletionBlock)completion {
    NSURL *url = [self.baseURL URLByAppendingPathComponent:@"ephemeral_keys"];
    NSURLComponents *urlComponents = [NSURLComponents componentsWithURL:url resolvingAgainstBaseURL:NO];
    urlComponents.queryItems = @[[[NSURLQueryItem alloc] initWithName:@"api_version" value:apiVersion]];
    NSURLRequest *request = [[NSURLRequest alloc] initWithURL:urlComponents.URL];
    NSURLSessionDataTask *task = [[NSURLSession sharedSession] dataTaskWithRequest:request completionHandler:^(NSData * _Nullable data, NSURLResponse * _Nullable response, NSError * _Nullable error) {
        if (data != nil && [response isKindOfClass:[NSHTTPURLResponse class]] && ((NSHTTPURLResponse *)response).statusCode == 200) {
            NSDictionary *json = [NSJSONSerialization JSONObjectWithData:data options:0 error:nil];
            completion(json, nil);
        } else {
            completion(nil, error);
        }
    }];
    [task resume];
}

@end

// MyAPIClient implements STPCustomerEphemeralKeyProvider (see above)
let customerContext = STPCustomerContext(keyProvider: MyAPIClient())
// MyAPIClient implements STPCustomerEphemeralKeyProvider (see above)
let customerContext = STPCustomerContext(keyProvider: MyAPIClient())

// MyAPIClient implements STPCustomerEphemeralKeyProvider (see above)
STPCustomerContext *customerContext = [[STPCustomerContext alloc] initWithKeyProvider:[MyAPIClient new]];
// MyAPIClient implements STPCustomerEphemeralKeyProvider (see above)
STPCustomerContext *customerContext = [[STPCustomerContext alloc] initWithKeyProvider:[MyAPIClient new]];

init() {
    self.paymentContext = STPPaymentContext(customerContext: customerContext)
    super.init(nibName: nil, bundle: nil)
    self.paymentContext.delegate = self
    self.paymentContext.hostViewController = self
    self.paymentContext.paymentAmount = 5000 // This is in cents, i.e. $50 USD
}
init() {
    self.paymentContext = STPPaymentContext(customerContext: customerContext)
    super.init(nibName: nil, bundle: nil)
    self.paymentContext.delegate = self
    self.paymentContext.hostViewController = self
    self.paymentContext.paymentAmount = 5000 // This is in cents, i.e. $50 USD
}

- (instancetype)init {
    self = [super initWithNibName:nil bundle:nil];
    if (self) {
       self.paymentContext = [[STPPaymentContext alloc] initWithCustomerContext:customerContext];
       self.paymentContext.delegate = self;
       self.paymentContext.hostViewController = self;
       self.paymentContext.paymentAmount = 5000; // This in cents, i.e. $50 USD
    }
    return self;
}
- (instancetype)init {
    self = [super initWithNibName:nil bundle:nil];
    if (self) {
       self.paymentContext = [[STPPaymentContext alloc] initWithCustomerContext:customerContext];
       self.paymentContext.delegate = self;
       self.paymentContext.hostViewController = self;
       self.paymentContext.paymentAmount = 5000; // This in cents, i.e. $50 USD
    }
    return self;
}

// If you prefer a modal presentation
func choosePaymentButtonTapped() {
    self.paymentContext.presentPaymentOptionsViewController()
}

// If you prefer a navigation transition
func choosePaymentButtonTapped() {
    self.paymentContext.pushPaymentOptionsViewController()
}
// If you prefer a modal presentation
func choosePaymentButtonTapped() {
    self.paymentContext.presentPaymentOptionsViewController()
}

// If you prefer a navigation transition
func choosePaymentButtonTapped() {
    self.paymentContext.pushPaymentOptionsViewController()
}

// If you prefer a modal presentation
- (void)choosePaymentButtonTapped {
    [self.paymentContext presentPaymentOptionsViewController];
}

// If you prefer a navigation transition
- (void)choosePaymentButtonTapped {
    [self.paymentContext pushPaymentOptionsViewController];
}
// If you prefer a modal presentation
- (void)choosePaymentButtonTapped {
    [self.paymentContext presentPaymentOptionsViewController];
}

// If you prefer a navigation transition
- (void)choosePaymentButtonTapped {
    [self.paymentContext pushPaymentOptionsViewController];
}

func paymentContextDidChange(_ paymentContext: STPPaymentContext) {
    self.activityIndicator.animating = paymentContext.loading
    self.paymentButton.enabled = paymentContext.selectedPaymentOption != nil
    self.paymentLabel.text = paymentContext.selectedPaymentOption?.label
    self.paymentIcon.image = paymentContext.selectedPaymentOption?.image
}
func paymentContextDidChange(_ paymentContext: STPPaymentContext) {
    self.activityIndicator.animating = paymentContext.loading
    self.paymentButton.enabled = paymentContext.selectedPaymentOption != nil
    self.paymentLabel.text = paymentContext.selectedPaymentOption?.label
    self.paymentIcon.image = paymentContext.selectedPaymentOption?.image
}

- (void)paymentContextDidChange:(STPPaymentContext *)paymentContext {
    self.activityIndicator.animating = paymentContext.loading;
    self.paymentButton.enabled = paymentContext.selectedPaymentOption != nil;
    self.paymentLabel.text = paymentContext.selectedPaymentOption.label;
    self.paymentIcon.image = paymentContext.selectedPaymentOption.image;
}
- (void)paymentContextDidChange:(STPPaymentContext *)paymentContext {
    self.activityIndicator.animating = paymentContext.loading;
    self.paymentButton.enabled = paymentContext.selectedPaymentOption != nil;
    self.paymentLabel.text = paymentContext.selectedPaymentOption.label;
    self.paymentIcon.image = paymentContext.selectedPaymentOption.image;
}

// If you prefer a modal presentation
func shippingButtonTapped() {
    self.paymentContext.presentShippingViewController()
}

// If you prefer a navigation transition
func shippingButtonTapped() {
    self.paymentContext.pushShippingViewController()
}
// If you prefer a modal presentation
func shippingButtonTapped() {
    self.paymentContext.presentShippingViewController()
}

// If you prefer a navigation transition
func shippingButtonTapped() {
    self.paymentContext.pushShippingViewController()
}

// If you prefer a modal presentation
- (void)shippingButtonTapped {
    [self.paymentContext presentShippingViewController];
}

// If you prefer a navigation transition
- (void)shippingButtonTapped {
    [self.paymentContext pushShippingViewController];
}
// If you prefer a modal presentation
- (void)shippingButtonTapped {
    [self.paymentContext presentShippingViewController];
}

// If you prefer a navigation transition
- (void)shippingButtonTapped {
    [self.paymentContext pushShippingViewController];
}

func paymentContext(_ paymentContext: STPPaymentContext, didUpdateShippingAddress address: STPAddress, completion: @escaping STPShippingMethodsCompletionBlock) {
    let upsGround = PKShippingMethod()
    upsGround.amount = 0
    upsGround.label = "UPS Ground"
    upsGround.detail = "Arrives in 3-5 days"
    upsGround.identifier = "ups_ground"
    let fedEx = PKShippingMethod()
    fedEx.amount = 5.99
    fedEx.label = "FedEx"
    fedEx.detail = "Arrives tomorrow"
    fedEx.identifier = "fedex"

    if address.country == "US" {
        completion(.valid, nil, [upsGround, fedEx], upsGround)
    }
    else {
        completion(.invalid, nil, nil, nil)
    }
}
func paymentContext(_ paymentContext: STPPaymentContext, didUpdateShippingAddress address: STPAddress, completion: @escaping STPShippingMethodsCompletionBlock) {
    let upsGround = PKShippingMethod()
    upsGround.amount = 0
    upsGround.label = "UPS Ground"
    upsGround.detail = "Arrives in 3-5 days"
    upsGround.identifier = "ups_ground"
    let fedEx = PKShippingMethod()
    fedEx.amount = 5.99
    fedEx.label = "FedEx"
    fedEx.detail = "Arrives tomorrow"
    fedEx.identifier = "fedex"

    if address.country == "US" {
        completion(.valid, nil, [upsGround, fedEx], upsGround)
    }
    else {
        completion(.invalid, nil, nil, nil)
    }
}

- (void)paymentContext:(STPPaymentContext *)paymentContext didUpdateShippingAddress:(STPAddress *)address completion:(STPShippingMethodsCompletionBlock)completion {
    PKShippingMethod *upsGround = [PKShippingMethod new];
    upsGround.amount = [NSDecimalNumber decimalNumberWithString:@"0"];
    upsGround.label = @"UPS Ground";
    upsGround.detail = @"Arrives in 3-5 days";
    upsGround.identifier = @"ups_ground";
    PKShippingMethod *fedEx = [PKShippingMethod new];
    fedEx.amount = [NSDecimalNumber decimalNumberWithString:@"5.99"];
    fedEx.label = @"FedEx";
    fedEx.detail = @"Arrives tomorrow";
    fedEx.identifier = @"fedex";
    if ([address.country isEqualToString:@"US"]) {
        completion(STPShippingStatusValid, nil, @[upsGround, fedEx], upsGround);
    }
    else {
        completion(STPShippingStatusInvalid, nil, nil, nil);
    }
}
- (void)paymentContext:(STPPaymentContext *)paymentContext didUpdateShippingAddress:(STPAddress *)address completion:(STPShippingMethodsCompletionBlock)completion {
    PKShippingMethod *upsGround = [PKShippingMethod new];
    upsGround.amount = [NSDecimalNumber decimalNumberWithString:@"0"];
    upsGround.label = @"UPS Ground";
    upsGround.detail = @"Arrives in 3-5 days";
    upsGround.identifier = @"ups_ground";
    PKShippingMethod *fedEx = [PKShippingMethod new];
    fedEx.amount = [NSDecimalNumber decimalNumberWithString:@"5.99"];
    fedEx.label = @"FedEx";
    fedEx.detail = @"Arrives tomorrow";
    fedEx.identifier = @"fedex";
    if ([address.country isEqualToString:@"US"]) {
        completion(STPShippingStatusValid, nil, @[upsGround, fedEx], upsGround);
    }
    else {
        completion(STPShippingStatusInvalid, nil, nil, nil);
    }
}

func payButtonTapped() {
    self.paymentContext.requestPayment()
}
func payButtonTapped() {
    self.paymentContext.requestPayment()
}

- (void)payButtonTapped {
    [self.paymentContext requestPayment];
}
- (void)payButtonTapped {
    [self.paymentContext requestPayment];
}

curl https://api.stripe.com/v1/payment_intents \
  -u sk_test_4eC39HqLyjWDarjtT1zdp7dc: \
  -d amount=1099 \
  -d currency=usd
curl https://api.stripe.com/v1/payment_intents \
  -u sk_test_4eC39HqLyjWDarjtT1zdp7dc: \
  -d amount=1099 \
  -d currency=usd

# 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'

intent = Stripe::PaymentIntent.create({
  amount: 1099,
  currency: 'usd',
})
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'

intent = Stripe::PaymentIntent.create({
  amount: 1099,
  currency: 'usd',
})
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'

intent = stripe.PaymentIntent.create(
  amount=1099,
  currency='usd',
)
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.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

intent = stripe.PaymentIntent.create(
  amount=1099,
  currency='usd',
)
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');

$intent = \Stripe\PaymentIntent::create([
  'amount' => 1099,
  'currency' => 'usd',
]);
$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');

$intent = \Stripe\PaymentIntent::create([
  'amount' => 1099,
  'currency' => 'usd',
]);
$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";

PaymentIntentCreateParams params =
  PaymentIntentCreateParams.builder()
    .setAmount(1099L)
    .setCurrency("usd")
    .build();

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
Stripe.apiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

PaymentIntentCreateParams params =
  PaymentIntentCreateParams.builder()
    .setAmount(1099L)
    .setCurrency("usd")
    .build();

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({
  amount: 1099,
  currency: 'usd',
});
const clientSecret = paymentIntent.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
const stripe = require('stripe')('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

const paymentIntent = await stripe.paymentIntents.create({
  amount: 1099,
  currency: 'usd',
});
const clientSecret = paymentIntent.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.Key = "sk_test_4eC39HqLyjWDarjtT1zdp7dc"

params := &stripe.PaymentIntentParams{
  Amount: stripe.Int64(1099),
  Currency: stripe.String(string(stripe.CurrencyUSD)),
}
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
stripe.Key = "sk_test_4eC39HqLyjWDarjtT1zdp7dc"

params := &stripe.PaymentIntentParams{
  Amount: stripe.Int64(1099),
  Currency: stripe.String(string(stripe.CurrencyUSD)),
}
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 options = new PaymentIntentCreateOptions
{
    Amount = 1099,
    Currency = "usd",
};

var service = new PaymentIntentService();
var paymentIntent = service.Create(options);
// 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 options = new PaymentIntentCreateOptions
{
    Amount = 1099,
    Currency = "usd",
};

var service = new PaymentIntentService();
var paymentIntent = service.Create(options);
// Pass the client secret to the client

func paymentContext(_ paymentContext: STPPaymentContext,
  didCreatePaymentResult paymentResult: STPPaymentResult,
  completion: @escaping STPErrorBlock) {
    // Request a PaymentIntent from your backend
    MyAPIClient.sharedClient.createPaymentIntent(products: self.products, shippingMethod: paymentContext.selectedShippingMethod) { result in
        switch result {
        case .success(let clientSecret):
            // Assemble the PaymentIntent parameters
            let paymentIntentParams = STPPaymentIntentParams(clientSecret: clientSecret)
            paymentIntentParams.paymentMethodId = paymentResult.paymentMethod.stripeId

            // Confirm the PaymentIntent
            STPPaymentHandler.shared().confirmPayment(withParams: paymentIntentParams, authenticationContext: paymentContext) { status, paymentIntent, error in
                switch status {
                case .succeeded:
                    // Your backend asynchronously fulfills the customer's order, e.g. via webhook
                    completion(.success, nil)
                case .failed:
                    completion(.error, error) // Report error
                case .canceled:
                    completion(.userCancellation, nil) // Customer cancelled
                @unknown default:
                    completion(.error, nil)
                }
            }
        case .failure(let error):
            completion(.error, error) // Report error from your API
            break
        }
    }
}
func paymentContext(_ paymentContext: STPPaymentContext,
  didCreatePaymentResult paymentResult: STPPaymentResult,
  completion: @escaping STPErrorBlock) {
    // Request a PaymentIntent from your backend
    MyAPIClient.sharedClient.createPaymentIntent(products: self.products, shippingMethod: paymentContext.selectedShippingMethod) { result in
        switch result {
        case .success(let clientSecret):
            // Assemble the PaymentIntent parameters
            let paymentIntentParams = STPPaymentIntentParams(clientSecret: clientSecret)
            paymentIntentParams.paymentMethodId = paymentResult.paymentMethod.stripeId

            // Confirm the PaymentIntent
            STPPaymentHandler.shared().confirmPayment(withParams: paymentIntentParams, authenticationContext: paymentContext) { status, paymentIntent, error in
                switch status {
                case .succeeded:
                    // Your backend asynchronously fulfills the customer's order, e.g. via webhook
                    completion(.success, nil)
                case .failed:
                    completion(.error, error) // Report error
                case .canceled:
                    completion(.userCancellation, nil) // Customer cancelled
                @unknown default:
                    completion(.error, nil)
                }
            }
        case .failure(let error):
            completion(.error, error) // Report error from your API
            break
        }
    }
}

- (void)paymentContext:(STPPaymentContext *)paymentContext
didCreatePaymentResult:(STPPaymentResult *)paymentResult
            completion:(STPErrorBlock)completion {
    // Request a PaymentIntent from your backend
    [[MyAPIClient sharedClient] createPaymentIntentWithCompletion:^(MyAPIClientResult status, NSString * _Nullable paymentIntentClientSecret, NSError * _Nullable error) {
        if (paymentIntentClientSecret == nil || error != nil) {
            completion(STPPaymentStatusError, error); // Report error from your API
            return;
        }
        // Assemble the PaymentIntent parameters
        STPPaymentIntentParams *paymentIntentParams = [[STPPaymentIntentParams alloc] initWithClientSecret: paymentIntentClientSecret];
        paymentIntentParams.paymentMethodId = paymentResult.paymentMethod.stripeId;

        // Confirm the PaymentIntent
        [[STPPaymentHandler sharedHandler] confirmPayment:paymentIntentParams withAuthenticationContext:paymentContext completion:^(STPPaymentHandlerActionStatus status, STPPaymentIntent * _Nullable paymentIntent, NSError * _Nullable error) {
            switch (status) {
                case STPPaymentHandlerActionStatusSucceeded:
                    // Your backend asynchronously fulfills the customer's order, e.g. via webhook
                    completion(STPPaymentStatusSuccess, nil);
                    break;
                case STPPaymentHandlerActionStatusFailed:
                    completion(STPPaymentStatusError, error);
                    break;
                case STPPaymentHandlerActionStatusCanceled:
                    completion(STPPaymentStatusUserCancellation, nil);
                    break;
            }
        }];
    }];
}
- (void)paymentContext:(STPPaymentContext *)paymentContext
didCreatePaymentResult:(STPPaymentResult *)paymentResult
            completion:(STPErrorBlock)completion {
    // Request a PaymentIntent from your backend
    [[MyAPIClient sharedClient] createPaymentIntentWithCompletion:^(MyAPIClientResult status, NSString * _Nullable paymentIntentClientSecret, NSError * _Nullable error) {
        if (paymentIntentClientSecret == nil || error != nil) {
            completion(STPPaymentStatusError, error); // Report error from your API
            return;
        }
        // Assemble the PaymentIntent parameters
        STPPaymentIntentParams *paymentIntentParams = [[STPPaymentIntentParams alloc] initWithClientSecret: paymentIntentClientSecret];
        paymentIntentParams.paymentMethodId = paymentResult.paymentMethod.stripeId;

        // Confirm the PaymentIntent
        [[STPPaymentHandler sharedHandler] confirmPayment:paymentIntentParams withAuthenticationContext:paymentContext completion:^(STPPaymentHandlerActionStatus status, STPPaymentIntent * _Nullable paymentIntent, NSError * _Nullable error) {
            switch (status) {
                case STPPaymentHandlerActionStatusSucceeded:
                    // Your backend asynchronously fulfills the customer's order, e.g. via webhook
                    completion(STPPaymentStatusSuccess, nil);
                    break;
                case STPPaymentHandlerActionStatusFailed:
                    completion(STPPaymentStatusError, error);
                    break;
                case STPPaymentHandlerActionStatusCanceled:
                    completion(STPPaymentStatusUserCancellation, nil);
                    break;
            }
        }];
    }];
}

func paymentContext(_ paymentContext: STPPaymentContext,
  didFinishWithStatus status: STPPaymentStatus,
  error: Error?) {

    switch status {
    case .error:
        self.showError(error)
    case .success:
        self.showReceipt()
    case .userCancellation:
        return // Do nothing
    }
}
func paymentContext(_ paymentContext: STPPaymentContext,
  didFinishWithStatus status: STPPaymentStatus,
  error: Error?) {

    switch status {
    case .error:
        self.showError(error)
    case .success:
        self.showReceipt()
    case .userCancellation:
        return // Do nothing
    }
}

- (void)paymentContext:(STPPaymentContext *)paymentContext
   didFinishWithStatus:(STPPaymentStatus)status
                 error:(NSError *)error {
    switch (status) {
        case STPPaymentStatusSuccess:
            [self showReceipt];
            break;
        case STPPaymentStatusError:
            [self showError:error];
            break;
        case STPPaymentStatusUserCancellation:
            return; // Do nothing
    }
}
- (void)paymentContext:(STPPaymentContext *)paymentContext
   didFinishWithStatus:(STPPaymentStatus)status
                 error:(NSError *)error {
    switch (status) {
        case STPPaymentStatusSuccess:
            [self showReceipt];
            break;
        case STPPaymentStatusError:
            [self showError:error];
            break;
        case STPPaymentStatusUserCancellation:
            return; // Do nothing
    }
}

func paymentContext(_ paymentContext: STPPaymentContext,
  didFailToLoadWithError error: Error) {
    self.navigationController?.popViewController(animated: true)
    // Show the error to your user, etc.
}
func paymentContext(_ paymentContext: STPPaymentContext,
  didFailToLoadWithError error: Error) {
    self.navigationController?.popViewController(animated: true)
    // Show the error to your user, etc.
}

- (void)paymentContext:(STPPaymentContext *)paymentContext didFailToLoadWithError:(NSError *)error {
     [self.navigationController popViewControllerAnimated:YES];
     // Show the error to your user, etc.
}
- (void)paymentContext:(STPPaymentContext *)paymentContext didFailToLoadWithError:(NSError *)error {
     [self.navigationController popViewControllerAnimated:YES];
     // Show the error to your user, etc.
}

STPPaymentConfiguration.shared().appleMerchantIdentifier = "your apple merchant identifier"
STPPaymentConfiguration.shared().appleMerchantIdentifier = "your apple merchant identifier"

[[STPPaymentConfiguration sharedConfiguration] setAppleMerchantIdentifier:@"your apple merchant identifier"];
[[STPPaymentConfiguration sharedConfiguration] setAppleMerchantIdentifier:@"your apple merchant identifier"];

STPTheme.default().accentColor = UIColor.blue
STPTheme.default().accentColor = UIColor.blue

[[STPTheme defaultTheme] setAccentColor:[UIColor blueColor]];
[[STPTheme defaultTheme] setAccentColor:[UIColor blueColor]];