Bolt iOS SDK and Ecosystem Integration

The integration of Bolt into the iOS ecosystem represents a sophisticated intersection of mobility services and merchant checkout capabilities. For developers and business owners operating within the United Kingdom and globally, understanding the technical deployment of the Bolt iOS SDK, alongside the broader application ecosystem, is essential for optimising user conversion and service delivery. The Bolt infrastructure is designed to reduce friction in the checkout process through highly secure, PCI-compliant tokenisation and seamless account detection, ensuring that the transition from a product selection to a completed transaction is as rapid as possible. This technical framework is supported by a wider mobility super-app that integrates ride-hailing, scooter sharing, and delivery services, creating a holistic digital environment for the end-user.

Merchant Integration via the Bolt iOS SDK

The Bolt iOS SDK is specifically engineered to enable merchants to incorporate Bolt Checkout directly into their native iOS applications. This integration allows for a streamlined payment experience, leveraging Bolt's infrastructure to handle complex checkout flows.

The SDK is delivered as an XCFramework bundle. This format is critical as it contains pre-built frameworks that are compatible with both physical iOS devices and the Xcode simulator, ensuring that developers can test their implementation across various hardware configurations without needing to recompile the core SDK for different architectures.

To manage the integration of the SDK, Bolt supports two primary package managers:

• Swift Package Manager: This is Apple's native dependency management system, integrated directly into Xcode.
• Cocoapods: A widely used third-party dependency manager for Swift and Objective-C projects.

The minimum system requirement for the Bolt iOS SDK is iOS version 13.0. This ensures that the SDK can leverage modern Swift features and API capabilities while maintaining compatibility with a vast majority of active iPhones currently in use.

Installation Procedures for Xcode

Adding the Bolt package to an Xcode project involves a structured sequence of steps to ensure the framework is correctly linked to the application target.

For those using the Swift Package Manager, the process is as follows:

• Navigate to the File menu and select Add Packages.
• Input the official package URL: https://github.com/BoltApp/bolt-ios.
• Confirm the addition by clicking Add Package.

In instances where the framework is not automatically linked to the app target, manual intervention is required:

• Select the app project within the project navigator.
• Choose the specific app target.
• Navigate to the General tab.
• Click the + icon located within the Frameworks, Libraries and Embedded Content section.
• Select the Bolt module and click Add.

For developers utilising Cocoapods, the process is simplified through the Podfile. The developer must add the following line to the project's Podfile:

• pod 'Bolt'

Following this addition, the command pod install must be executed in the terminal to fetch the dependency and generate the workspace.

SDK Initialization and Client Configuration

Before the Bolt SDK can be utilised for processing transactions or detecting accounts, it must be initialized with specific client properties. These properties define the identity of the merchant and the environment in which the SDK operates.

The following properties are required for successful initialization:

• Publishable key: This is a publicly viewable identifier used to uniquely identify a merchant division. This key is not a secret and is retrieved from the Bolt Merchant Dashboard under the Administration -> Developers -> API section.
• Environment: This specifies which Bolt server environment the app should communicate with. The two primary options are staging, used for testing and development, and production, used for live customer transactions.

The implementation in Swift is handled via the following code structure:

• import Bolt
• Bolt.ClientProperties.shared.publishableKey = ""
• Bolt.ClientProperties.shared.environment = .staging

This initialization process ensures that all subsequent API calls are routed to the correct merchant account and the appropriate server environment, preventing test data from entering production systems.

PCI Compliant Credit Card Tokenisation

A core component of the Bolt iOS SDK is the credit card tokenizer. This tool provides a secure method to collect and store credit card information.

The impact of this feature is significant for merchants as it ensures that sensitive payment data is handled in a PCI compliant manner. By tokenising the data, the merchant avoids the risk of storing raw credit card numbers on their own servers, thereby reducing their PCI DSS compliance burden and protecting the consumer from potential data breaches.

Account Detection and User Authorization

The Bolt SDK allows merchants to implement a streamlined login process by detecting if a user already has a Bolt account associated with their email address.

Implementing Account Detection

Account detection can be triggered when a user finishes entering their email address. This can be implemented using specific handlers depending on the UI framework being used:

• UIKit: Utilise the UITextField.textFieldDidEndEditing(_:) method.
• SwiftUI: Utilise the TextField.onSubmit(of:_:) method.

Within these handlers, the merchant calls the Bolt DetectAccount API, providing the user's email address and the merchant's publishable key. If the API identifies a registered account, it returns a JSON response indicating the account's existence:

• { "hasboltaccount": true }

The Authorization Flow and OTP Verification

Once a Bolt account is detected, the user must be directed to the Bolt authorization page. This page serves as a security gateway, prompting the user to input a one-time passcode (OTP).

The OTP is delivered to the user via their registered email or phone number. This multi-factor authentication ensures that the person attempting to access the account is the rightful owner. Upon the successful entry of the OTP, the page redirects to a URL containing an authorization code within the query parameters.

Technical Implementation of the Authorization Page

To display the authorization page within a native iOS app, developers must use a web view.

• Create a WKWebView object.
• Set the navigationDelegate property to an object that conforms to WKNavigationDelegate.
• Obtain the Bolt authorization URL using the following method: let url = Bolt.Login.getAuthorizationURL(email: "[email protected]")!.
• Load this URL into the webview using webView.load(.init(url: url)).

To ensure a positive user experience, the WKWebView should be embedded within a UIViewController (for UIKit) or a UIViewRepresentable (for SwiftUI). It must be presented as a fullscreen modal. This specific presentation style is mandatory to ensure there is sufficient screen real estate to display the virtual keyboard and any potential error messages generated by the webpage.

Token Exchange and Data Access

After the authorization code is received from the web view, it must be passed to the merchant's backend server. The server then uses the Bolt OAuthToken endpoint to exchange this authorization code for an access token.

Once the access token is acquired, the merchant can use Bolt's Account APIs to retrieve stored user information, such as:

• Saved shipping addresses.
• Stored credit cards.

This eliminates the need for the user to manually enter their details during every checkout, drastically increasing the conversion rate.

Analytics and Checkout Funnel Tracking

As an optional but highly recommended step, merchants can invoke analytics methods to track checkout funnel events. This allows businesses to gather granular data on the user's shopping journey, from the initial checkout trigger to the final payment.

By tracking predefined events at specific points in the flow, merchants can identify where users drop off and optimise the user interface to improve the overall completion rate.

Bolt Mobility Super-App Ecosystem

While the SDK focuses on merchant integration, Bolt also operates a comprehensive mobility super-app. Bolt is positioned as the first European mobility super-app, aiming to provide alternatives to private car ownership.

Range of Services

The Bolt app offers a variety of services, although availability varies by country. These include:

• Ride-hailing: On-demand transport for individuals.
• Shared cars: Access to vehicles for flexible use.
• Scooters: Short-distance urban mobility.
• Food and grocery delivery: Rapid delivery of consumables.

Hardware Innovation: Bolt 7

The Bolt 7 is the next-generation e-scooter developed in collaboration with city authorities. It is designed to address common rider struggles and improve urban safety. Key features include:

• Integrated display: Provides navigation for the rider.
• Real-time parking guidance: Ensures scooters are parked in designated areas.
• Safety enhancements: Stronger features to protect the rider.
• AI systems: Built-in intelligence to reduce pavement riding and improve safety for pedestrians.

Economic Opportunity for Partners

Bolt provides revenue growth opportunities for a wide range of partners, with over 4.5 million partners globally. This includes:

• Drivers.
• Couriers.
• Merchants.
• Fleet owners.

Mobile App Development via Expo Integration

For developers looking to build mobile applications using Bolt's platform, Expo is utilised as the primary framework. Expo allows for the creation of apps for both iPhone and Android using a single codebase.

Goals of Expo Integration

The integration of Expo within the Bolt ecosystem is designed to achieve three main objectives:

• Accessibility: Making mobile development available to individuals regardless of their coding expertise.
• Seamless Transition: Providing a direct path from an initial idea to the app store by handling complex technical configurations.
• Control: Giving developers full authority over the publishing and distribution of their applications.

Development Strategy

It is critical that developers specify the intention to build a mobile app from the very first prompt. Because projects created for the web do not transition easily to mobile, identifying the platform at the start prevents significant rework.

Deployment and Publishing Workflows

The process for moving an app from development to the public is segmented by platform.

iOS Deployment Path

1. Build for iPhone.
2. Create an app listing in the Apple Developer account.
3. Set up a TestFlight testing group.
4. Submit the build for internal testing.
5. Once satisfied, go to App Store Connect.
6. Fill in app details and submit for App Store review.
7. Upon approval, the app becomes publicly available on the App Store.

Android Deployment Path

1. Create a production build.
2. Access the Google Play Console.
3. Create a new app listing.
4. Set up internal testing via Testing > Internal testing.
5. Create a release and upload the build file.
6. Add tester email addresses and share the testing link.
7. For public release, navigate to Production.
8. Create a release, upload the build, and fill in store listing details.
9. Submit for review and go live on Google Play.

App Management and Monitoring

Post-launch management is handled via the Expo dashboard at expo.dev. This allows developers to:

• View build status and logs.
• Monitor for crashes and errors.
• Track performance and usage metrics.

To update a published app, developers must download the updated code from Bolt. While web updates are direct, mobile updates require a full rebuild and resubmission to the respective app stores.

Summary of Technical Specifications

The following table outlines the technical requirements and options for Bolt's iOS and mobile frameworks.

Detailed Analysis of the Bolt Ecosystem

The synergy between the Bolt iOS SDK and the Bolt mobility super-app demonstrates a strategic approach to reducing friction in the digital economy. By providing a robust SDK, Bolt allows merchants to integrate high-conversion checkout tools that leverage a pre-existing user base. The use of OAuth tokens and OTP verification creates a secure loop that protects user data while speeding up the transaction process.

From a development perspective, the reliance on XCFrameworks and Expo indicates a commitment to reducing the "time-to-market" for partners. The shift towards a "super-app" model, where ride-hailing, delivery, and micro-mobility converge, places Bolt in a position to capture a larger share of the user's daily digital interactions. Furthermore, the integration of AI in hardware, as seen in the Bolt 7 scooter, suggests that the company is moving beyond software into the realm of smart urban infrastructure.

The combination of PCI-compliant tokenisation and a streamlined authorization flow ensures that the merchant's risk is minimised while the consumer's convenience is maximised. This creates a virtuous cycle where users are more likely to shop with merchants who utilize Bolt, knowing their details are securely stored and can be retrieved with a simple OTP.

Sources

1. Bolt iOS SDK GitHub
2. Bolt Support - Downloading the App
3. Bolt Main Site
4. Bolt Expo Integration Documentation