How to Install and Use Stripe-iOS for Seamless Payments 🚀

Wednesday, Dec 18, 2024 | 8 minute read

GitHub Trend

Transform mobile payments with this secure and seamless integration! 💳✨ Experience a user-friendly setup, automatic authentication, and Apple Pay integration that elevates checkout processes. Make payments extraordinary, while ensuring high security and compliance! 🔒🚀

“In today’s world where mobile payments are increasingly popular, developers need a secure and convenient solution to enhance user experience.” 💡

With the rapid development of mobile internet, consumer demand for online payments is skyrocketing. Particularly on the iOS platform, developers are faced with the challenge of how to quickly implement a secure payment experience. This is where the Stripe-iOS SDK comes in! This highly popular payment solution is designed to simplify payment integration, providing a smooth and secure payment experience that will truly impress! 💳🌍

🌈 Stripe-iOS SDK: Your Payment Solution 💳

As your ideal choice for developing iOS applications, the Stripe-iOS SDK will bring you an exceptional payment integration experience! It is designed to streamline payment processes and aims to provide developers with rich and powerful user interface components. ✨ This SDK not only features a sleek UI but also includes low-level APIs, allowing you to efficiently and securely collect payment information. With this magical tool, you will fully comply with PCI compliance standards, offering users secure payment processing that enhances the trust and professionalism of your app! 🔒

🚀 Unique Features: Why is it So Outstanding? 🌈

Stripe-iOS SDK makes every step of payment feel magical! ✨

1. Secure Payment Data Collection: Safely collect sensitive payment data, ensuring users have a perfect experience while paying. 🛡️
2. Seamless Integration with Apple Pay: Integrate Apple Pay with a single tap, making the user checkout process smoother and significantly improving satisfaction and conversion rates! 📱✨
3. Automatic Strong Customer Authentication Handling: Easily manage SCA and support 3D Secure authentication, saving developers from complex tasks and making payments hassle-free! 🔐
4. User-Friendly UI Components: With native UI elements like PaymentSheet, the information collection process flows effortlessly, leaving you free from customization worries! 👌
5. Flexibility of Low-Level APIs: With low-level APIs like STPCardValidator, you can create a customized payment experience that showcases your developer creativity! 🤹‍♂️
6. Convenient Card Scanning Feature: For users on iOS 13 and later, they can easily make payments by scanning their credit cards – incredibly convenient! 📸💰
7. Support for App Clips: The Stripe-iOS SDK also supports App Clips, integrates Apple Pay, and provides more convenience for users, enhancing their experience! 🌟

🎉 The Developer’s Choice: The Reasons for Stripe-iOS SDK’s Popularity

What makes the Stripe-iOS SDK the NO.1 choice for developers? ✨

1. High Security: Developers love the Stripe-iOS SDK for its high-security guarantees on transactions and payment information, making it a safe choice! 🔒🔑
2. Elegant User Experience: Smooth integration and convenient payment processes enhance overall user satisfaction, providing immense joy for users while using the app! 🌈❤️
3. Comprehensive Payment Functionality: Compatible with various payment methods, suitable for diverse application scenarios, making the creation of payment processes simple and efficient! 🏦✨
4. Rich Functionality Support: With features like Apple Pay and authentication, developers can easily build competitive payment solutions, enhancing product value! 🚀🔧

With the Stripe-iOS SDK, developers can not only create flexible and effective payment processes but also provide users with an extraordinary payment experience while ensuring high security and compliance standards. 😄💪 Want to learn more? Visit the Stripe Documentation for further information! 📚💻

🛠️ How to Install the Stripe SDK

To use the Stripe SDK, first, you need to install it using CocoaPods, a widely-used dependency management tool for iOS! First, add a simple line of code to your project’s Podfile:

pod 'Stripe'

This line tells CocoaPods: “Hey, I want to include the Stripe SDK as a dependency for my project!"✍️ After updating the Podfile, remember to save the file, open the terminal, and run the following command to install the dependencies:

pod install

After running this command, CocoaPods will automatically download and install the Stripe SDK along with all required dependencies. Once done, don’t forget to open the generated .xcworkspace file instead of the original .xcodeproj file. This way, you can smoothly use the Stripe SDK in Xcode! ✨

👤 Steps to Create a Customer

In Stripe, customers are the core concept for payments and transactions! Creating a customer using the Stripe API is extremely simple. You simply need to send a POST request with the customer information. Here’s an example of a cURL command:

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

In this command, sk_test_4eC39HqLyjWDarjtT1zdp7dc is your Stripe test key, so remember to replace it with your own for security! 🔑 If successful, Stripe will return a customer object containing a unique customer ID for later use.

🔑 Creating an Ephemeral Key

For security reasons, when interacting with customers, we need to create an ephemeral key. This can be done by sending another POST request:

curl https://api.stripe.com/v1/ephemeral_keys \
  -u sk_test_4eC39HqLyjWDarjtT1zdp7dc: \
  -H "Stripe-Version: 2024-11-20.acacia" \
  -X "POST" \
  -d "customer"="{{CUSTOMER_ID}}"

In this command, replace the customer parameter with the customer ID you obtained earlier. 📋 This ephemeral key allows you to safely interact with the client, ensuring the security of user data. Remember to use your real keys in production, and test keys while developing!

💰 Creating a Payment Intent

The Payment Intent is the essence of Stripe, responsible for tracking payment status and handling information. The method to create a payment intent is as follows:

curl https://api.stripe.com/v1/payment_intents \
  -u sk_test_4eC39HqLyjWDarjtT1zdp7dc: \
  -X "POST" \
  -d "customer"="{{CUSTOMER_ID}}" \
  -d "amount"=1099 \
  -d "currency"="eur" \
  -d "automatic_payment_methods[enabled]"=true

In this command, amount is the total we want to charge, expressed in cents (for example, 1099 represents €10.99). 💵 This command creates a payment intent and prepares to process payment for the specified customer, Stripe will return relevant information related to the payment intent for further handling!

📱 Example of Using the Stripe SDK

Now, let’s see how to implement the payment process in an iOS application. First, we need to import the Stripe PaymentSheet module and create a payment page. Here’s an example of the implementation code:

import UIKit
import StripePaymentSheet

First, ensure you import the module. Then define a CheckoutViewController class and set up the necessary information for the payment sheet in the view loading method: 📊

class CheckoutViewController: UIViewController {
  @IBOutlet weak var checkoutButton: UIButton!
  var paymentSheet: PaymentSheet?
  let backendCheckoutUrl = URL(string: "Your backend endpoint/payment-sheet")!
}

Next, we connect an IBOutlet to a button and define the payment sheet variable with the backend URL. In the viewDidLoad method, we set up the button-click event and request the payment information from the backend:

override func viewDidLoad() {
  super.viewDidLoad()
  
  checkoutButton.addTarget(self, action: #selector(didTapCheckoutButton), for: .touchUpInside)
  checkoutButton.isEnabled = false
  
  // Create a request to get payment sheet information from the backend
  var request = URLRequest(url: backendCheckoutUrl)
  request.httpMethod = "POST"
  
  let task = URLSession.shared.dataTask(with: request, completionHandler: { [weak self] (data, response, error) in
    guard let data = data,
          let json = try? JSONSerialization.jsonObject(with: data, options: []) as? [String : Any],
          let customerId = json["customer"] as? String,
          let customerEphemeralKeySecret = json["ephemeralKey"] as? String,
          let paymentIntentClientSecret = json["paymentIntent"] as? String,
          let publishableKey = json["publishableKey"] as? String,
          let self = self else {
      return // Request failed, handle error
    }

Here, we use URLSession to send a request to the backend, receive data, and parse the JSON.🧐 Based on the returned data (such as customerId, ephemeralKeySecret, and paymentIntentClientSecret), we initialize the payment sheet.

Once the request is successful, we can enable the payment button:

    STPAPIClient.shared.publishableKey = publishableKey
    var configuration = PaymentSheet.Configuration()
    configuration.merchantDisplayName = "Example, Inc."
    configuration.customer = .init(id: customerId, ephemeralKeySecret: customerEphemeralKeySecret)
    configuration.allowsDelayedPaymentMethods = true
    self.paymentSheet = PaymentSheet(paymentIntentClientSecret: paymentIntentClientSecret, configuration: configuration)

    DispatchQueue.main.async {
      self.checkoutButton.isEnabled = true // Enable payment button
    }
  })
  task.resume()
}

Note: Here, we set the publishableKey with the obtained key and configure the display name for the payment sheet. Then, we combine all configurations with the payment intent into the payment sheet object.🛍️ Finally, ensure the button is disabled before the user clicks, avoiding duplicate submissions.

When the user clicks the button, we present the payment sheet and handle the payment result:

@objc func didTapCheckoutButton() {
  paymentSheet?.present(from: self) { paymentResult in
    switch paymentResult {
    case .completed:
      print("Your order is confirmed")
    case .canceled:
      print("Canceled!")
    case .failed(let error):
      print("Payment failed: \(error)")
    }
  }
}

🔄 Setting Up the Return URL

To ensure that customers can smoothly return to your app after authentication, you need to configure a custom URL scheme. You can do this in the SceneDelegate as follows:

func scene(_ scene: UIScene, openURLContexts URLContexts: Set<UIOpenURLContext>) {
  guard let url = URLContexts.first?.url else {
    return
  }
  let stripeHandled = StripeAPI.handleURLCallback(with: url)
  if (!stripeHandled) {
    // Handle other types of URLs
  }
}

This way, once the user returns to your app after authentication, Stripe will be able to handle these URLs! 📲

🔔 Handling Post-Payment Events

To monitor payment status, it’s recommended to listen for key events provided by Stripe, such as payment_intent.succeeded. After a successful payment, you can send an order confirmation email to the customer and handle any follow-up processing based on your business needs to ensure everything goes smoothly!

🧪 Testing Your Integration

When testing the payment process, you can use the following test card numbers to simulate different payment scenarios:

• Successful Payment: 4242424242424242
• Requires Authentication: 4000002500003155
• Declined Payment: 4000000000009995
• Variable Length UnionPay: 6205500000000000004

With these test cards, you can ensure that your payment integration works properly in various scenarios. 💪 Using a testing environment helps avoid potential financial losses, which is especially important for new developers! I hope this guide helps you get started with Stripe smoothly. If you have any questions, feel free to reach out! 📞