Accepter les paiements dans l’application

Côté serveur

Cette intégration exige que votre serveur dispose de endpoints qui communiquent avec l’API Stripe. Utilisez nos bibliothèques officielles pour accéder à l’API Stripe depuis votre serveur :

# Available as a gem
sudo gem install stripe

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

Côté client

Le SDK iOS de Stripe est disponible en open source et fait l’objet d’une documentation complète. Il est également compatible avec les applications prenant en charge iOS 13 et les versions ultérieures.

Vous devez également définir votre clé publique pour que le SDK puisse effectuer des appels à l’API Stripe. Pour commencer, vous pouvez coder en dur la clé publique côté client pendant l’intégration, mais la récupérer sur votre serveur en mode production.

// Set your publishable key: remember to change this to your live publishable key in production
// See your keys here: https://dashboard.stripe.com/apikeys
STPAPIClient.shared.publishableKey = 
"pk_test_TYooMQauvdEDq54NiTphI7jx"

Affichez vos paramètres des moyens de paiement et activez les moyens de paiement que vous souhaitez prendre en charge. Vous devez activer au moins un moyen de paiement pour créer un SetupIntent.

Par défaut, Stripe active les cartes bancaires et les autres moyens de paiement courants qui peuvent vous permettre d’atteindre davantage de clients. Nous vous recommandons toutefois d’activer d’autres moyens de paiement pertinents pour votre entreprise et vos clients. Consultez la page Prise en charge des moyens de paiement pour en savoir plus sur la prise en charge des produits et des moyens de paiement, et notre page des tarifs pour prendre connaissance des frais que nous appliquons.

Le client peut quitter votre application pour s’authentifier (par exemple, dans Safari ou dans son application bancaire). Pour lui permettre de revenir automatiquement sur votre application après s’être authentifié, configurez un schéma d’URL personnalisé et configurez votre délégué d’application pour qu’il transmette l’URL au SDK. Stripe ne prend pas en charge les liens universels.

// This method handles opening custom URL schemes (for example, "your-app://stripe-redirect")
func scene(_ scene: UIScene, openURLContexts URLContexts: Set<UIOpenURLContext>) {
    guard let url = URLContexts.first?.url else {
        return
    }
    let stripeHandled = StripeAPI.handleURLCallback(with: url)
    if (!stripeHandled) {
        // This was not a Stripe url – handle the URL normally as you would
    }
}

Définissez également le paramètre returnURL correspondant à votre objet PaymentSheet.Configuration sur l’URL de votre application.

var configuration = PaymentSheet.Configuration()
configuration.returnURL = "your-app://stripe-redirect"

Pour configurer un moyen de paiement en vue de paiements ultérieurs, vous devez l’associer à un objet Customer. Créez un objet Customer lorsque votre client crée un compte auprès de votre entreprise. Les objets Customer permettent de réutiliser des moyens de paiement et de suivre plusieurs paiements.

curl -X POST https://api.stripe.com/v1/customers \
  -u "
sk_test_BQokikJOvBiI2HlWgH4olfQ2
:"

Nous proposons deux types d’intégration. Choisissez-en un pour continuer.

PaymentSheet	PaymentSheet.FlowController
Affiche un formulaire permettant de collecter les informations de paiement et de finaliser la configuration. Le bouton du formulaire indique Configurer X $ et permet de configurer le moyen de paiement.	Affiche un formulaire permettant uniquement de collecter les informations de paiement. Le bouton du formulaire indique Continuer et redirige le client vers votre application, où votre propre bouton finalise la configuration.

import StripePaymentSheet

class MyCheckoutVC: UIViewController {
  func didTapCheckoutButton() {
    let intentConfig = PaymentSheet.IntentConfiguration(
      mode: .setup(currency: "USD")
    ) { [weak self] _, _, intentCreationCallback in
      self?.handleConfirm(intentCreationCallback)
    }
    var configuration = PaymentSheet.Configuration()
    configuration.returnURL = "your-app://stripe-redirect" // Use the return url you set up in the previous step
    let paymentSheet = PaymentSheet(intentConfiguration: intentConfig, configuration: configuration)
  }

  func handleConfirm(_ intentCreationCallback: @escaping (Result<String, Error>) -> Void) {
    // ...explained later
  }
}

class MyCheckoutVC: UIViewController {
  func didTapCheckoutButton() {
    // ...
    paymentSheet.present(from: self) { result in
      switch result {
        case .completed:
          // Setup completed - show a confirmation screen.
        case .failed(let error):
          print(error)
          // PaymentSheet encountered an unrecoverable error. You can display the error to the user, log it, etc.
        case .canceled:
          // Customer canceled - you should probably do nothing.
      }
    }
  }
}

class MyCheckoutVC: UIViewController {
  // ...

  func handleConfirm(_ intentCreationCallback: @escaping (Result<String, Error>) -> Void) {
    // Make a request to your own server and receive a client secret or an error.
    let myServerResponse: Result<String, Error> = ...
    switch myServerResponse {
    case .success(let clientSecret):
      // Call the `intentCreationCallback` with the client secret
      intentCreationCallback(.success(clientSecret))
    case .failure(let error):
      // Call the `intentCreationCallback` with the error
      intentCreationCallback(.failure(error))
    }
  }
}

Sur votre serveur, créez un SetupIntent. Vous pouvez gérer les moyens de paiement à partir du Dashboard. Stripe évalue les restrictions des moyens de paiement et d’autres paramètres pour déterminer la liste des moyens de paiement pris en charge.

Si l’appel réussit, renvoyez la clé secrète du client du SetupIntent. Si l’appel échoue, traitez l’erreur et renvoyez un message d’erreur avec une courte explication à l’intention de votre client.

require 'stripe'
Stripe.api_key = 
'sk_test_BQokikJOvBiI2HlWgH4olfQ2'

post '/create-intent' do
  data = JSON.parse request.body.read
  params = {
    customer: ..., # The Customer ID you previously created
    # In the latest version of the API, specifying the `automatic_payment_methods` parameter is optional because Stripe enables its functionality by default.
    automatic_payment_methods: {enabled: true},
  }
  begin
    intent = Stripe::SetupIntent.create(params)
    {client_secret: intent.client_secret}.to_json
  rescue Stripe::StripeError => e
    {error: e.error.message}.to_json
  end
end

Au moment de débiter votre client hors session, utilisez l’ID des objets Customer et PaymentMethod afin de créer un PaymentIntent. Pour trouver un moyen de paiement à débiter, répertoriez les moyens de paiement associés à votre client. Cet exemple liste des cartes, mais vous pouvez répertorier n’importe quel type de moyen de paiement pris en charge.

curl -G https://api.stripe.com/v1/payment_methods \
  -u "
sk_test_BQokikJOvBiI2HlWgH4olfQ2
:" \
  -d customer=
{{CUSTOMER_ID}} \
  -d type=card

Après avoir obtenu les ID de Customer et de PaymentMethod, créez un PaymentIntent indiquant le montant et la devise du paiement. Définissez quelques autres paramètres afin d’effectuer le paiement hors session :

• Définissez l’attribut off_session sur true pour indiquer que le client ne se trouve pas dans votre tunnel de paiement lors d’une tentative de paiement, et qu’il ne peut donc pas répondre à une demande d’authentification effectuée par un partenaire, comme un émetteur de cartes, une banque ou un autre établissement de paiement. Si un partenaire demande une authentification dans le tunnel de paiement, Stripe demande une exemption en s’appuyant sur les informations utilisée par le client pendant une session précédente. Si les conditions d’exemption ne sont pas remplies, le PaymentIntent peut renvoyer une erreur.
• Définissez la propriété confirm du PaymentIntent sur la valeur true, ce qui aura pour effet de générer immédiatement une confirmation lors de la création du PaymentIntent.
• Renseignez l’ID du PaymentMethod dans payment_method et l’ID du client dans customer.

curl https://api.stripe.com/v1/payment_intents \
  -u 
sk_test_BQokikJOvBiI2HlWgH4olfQ2
: \
  -d amount=1099 \
  -d currency=usd \
  # In the latest version of the API, specifying the `automatic_payment_methods` parameter is optional because Stripe enables its functionality by default.
  -d "automatic_payment_methods[enabled]"=true \
  -d customer="{{CUSTOMER_ID}}" \
  -d payment_method="{{PAYMENT_METHOD_ID}}" \
  -d return_url="https://example.com/order/123/complete" \
  -d off_session=true \
  -d confirm=true

Consultez la section consacrée aux tests pour obtenir des informations supplémentaires sur la manière de tester votre intégration.