Skip to content
Create account
or
Sign in
The Stripe Docs logo
/
Ask AI
Create account
Sign in
Get started
Payments
Finance automation
Platforms and marketplaces
Money management
Developer tools
Get started
Payments
Finance automation
Get started
Payments
Finance automation
Platforms and marketplaces
Money management
Overview
About Stripe payments
Upgrade your integration
Payments analytics
Online payments
OverviewFind your use caseManaged Payments
Use Payment Links
Build a checkout page
Build an advanced integration
Build an in-app integration
Payment methods
Add payment methods
Manage payment methods
Faster checkout with Link
Payment interfaces
Payment Links
Checkout
Web Elements
In-app Elements
Payment scenarios
Custom payment flows
Flexible acquiring
Orchestration
In-person payments
Terminal
    Overview
    Accept in-person payments
    Integration design
    Select your reader
    Design an integration
    Quickstart
    Example applications
    Terminal setup
    Set up your integration
    Connect to a reader
    Accepting a payment
    Collect card payments
    Accept offline payments
      Collect card payments
    Mail order and telephone order payments
    Regional considerations
    During checkout
    Collect tips
    Collect and save payment details for future use
    Flexible authorizations
    After checkout
    Refund transactions
    Provide receipts
    Customize checkout
    Cart display
    Collect on-screen inputs
    Collect swiped data
    Apps on devices
    Manage readers
    Order, return, replace readers
    Register readers
    Manage locations and zones
    Configure readers
    Encryption
    References
    API references
    Mobile readers
    Smart readers
    SDK migration guide
    Testing
    Deployment checklist
    Stripe Terminal reader product sheets
Other Stripe products
Financial Connections
Crypto
Climate
HomePaymentsTerminalAccept offline payments

Collect card payments while offline

Collect card payments when you have internet connectivity issues.

Copy page

The Terminal SDK allows your application to continue collecting payments using a mobile reader without a network connection.

Common mistake

When operating offline, payment information is collected at the time of sale, and authorization is only attempted after connectivity is restored and the payment is forwarded. You, as the user, assume all decline and tamper-related risks associated with an offline transaction. If your tampered reader can’t forward payments to Stripe, or the issuer declines the transaction, there’s no way to recover the funds, and you might not receive payment from the customer for goods or services already provided.

To reduce the chances of an issuer decline, you’re encouraged to:

  • Reestablish internet connectivity as soon as possible to record the payments to Stripe.
  • Restrict transactions if they exceed a certain amount.
  • Fail all offline payments if the SDK has stored a set of transactions whose sum exceeds a certain amount.

Collect payments while offline

Offline payments follow the same steps as online payments: create, collect, process, and capture the payment. Your device can transition from online to offline at any step in the process.

  1. Enable offline mode
  2. Connect to a reader while offline
  3. Handle offline events
  4. Create a PaymentIntent while offline
  5. Collect a payment method
  6. Confirm the payment
  7. Wait for payments to forward
  8. (Optional) Capture the payment
  9. (Optional) Examine payments collected offline

Enable offline mode

To use offline mode, your application needs to consume version 3.3.0 or later of the Terminal iOS SDK.

Use a Configuration object to enable offline mode for the supported devices at your Location.

Command Line
cURL
curl https://api.stripe.com/v1/terminal/configurations \ -u "
sk_test_BQokikJOvBiI2HlWgH4olfQ2
:"
\ -d "offline[enabled]"=true

After you enable offline mode on a Configuration object, you can assign it to a Location. You can also enable offline mode by default for all Locations by updating the default Configuration object for your account. Configuration API changes can take several minutes to propagate to your SDK and reader, and require you to disconnect from and reconnect to your reader to take effect.

Connect to a reader while offline

The SDK stores necessary Location information locally after connecting online. On subsequent offline connections, it uses the stored configuration information from that Location.

To collect payments with a smart reader while offline, you must have previously connected to any mobile reader of the same type at the same Location while online within the last 30 days, and have updated your reader’s software within that time.

If you attempt to connect to a reader while offline without meeting these requirements, the request fails with an error.

ErrorResolution
The SDK isn’t connected to the internetMake sure the Location you’re using is configured for offline mode. Otherwise, connect to any reader while online, and then connect to a reader of the same type while offline.
The selected reader requires a software update before it can be used to collect payments offline.The reader’s software hasn’t been updated in 30 days or more. Connect to the reader while online to update it.
The selected reader must be paired online at this location before it can be used to collect payments offline.You’re attempting to connect to a reader type that your POS hasn’t previously connected to while online. You must first connect to this reader or any reader of the same type while online. Or, if you want to connect while offline, you can connect to a reader type that your POS previously connected to while online.

If you reinstall the application or perform any operation that clears the disk storage for the SDK (such as clearing your POS app’s cache in the POS device’s settings) you lose any payments that the SDK has stored and not yet forwarded. Make sure there are no stored payments before you perform any destructive action.

Handle offline events
Client-side

SDK Reference

  • OfflineDelegate (iOS)
  • NetworkStatus (iOS)

To allow your application to receive updates about the SDK’s network status and the state of forwarded payments, implement the OfflineDelegate protocol and pass it to the Terminal SDK. You must set OfflineDelegate before collecting payments offline.

CustomOfflineDelegate.swift
Swift
import StripeTerminal class CustomOfflineDelegate: OfflineDelegate { func terminal(_ terminal: Terminal, didChangeOfflineStatus offlineStatus: OfflineStatus) { // Check the value of `offlineStatus` and update your UI accordingly. For instance, // you can check the SDK's network status at `offlineStatus.sdk.networkStatus`. // // You can also check the SDK's current offline status using // `Terminal.shared.offlineStatus.sdk.networkStatus`. } func terminal(_ terminal: Terminal, didForwardPaymentIntent intent: PaymentIntent, error: Error?) { // The PaymentIntent was successfully forwarded, or an error occurred. // Reconcile any local state using the backend-generated `PaymentIntent.stripeId` // and the metadata you supplied when creating the PaymentIntent. // // Note that the `PaymentIntent.stripeId` may still be nil if creating the // PaymentIntent in the backend failed. } func terminal(_ terminal: Terminal, didReportForwardingError error: Error) { // A non-specific error occurred while forwarding a PaymentIntent. // Check the error message and your integration implementation to // troubleshoot. } }
AppDelegate.swift
Swift
import UIKit import StripeTerminal @UIApplicationMain class AppDelegate: UIResponder, UIApplicationDelegate { func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil) -> Bool { Terminal.setTokenProvider(APIClient.shared) Terminal.shared.offlineDelegate = CustomOfflineDelegate() // ... return true } // ... }

Create a PaymentIntent while offline
Client-side

SDK Reference

  • createPaymentIntent (iOS)
  • CreateConfiguration (iOS)
  • OfflineDetails (iOS)

To support operating offline, use the SDK’s createPaymentIntent to create PaymentIntent objects. This allows the SDK to create PaymentIntents while offline and forward them to Stripe after you’ve re-established connectivity.

While operating offline, PaymentIntent objects have a null stripeId. We recommend adding a custom identifier to the PaymentIntent’s metadata to help reconcile PaymentIntent objects created offline in your database.

After the PaymentIntent has been successfully forwarded to Stripe in Step 7, use your custom identifier to reconcile it in the OfflineDelegate.didForwardPaymentIntent callback.

PaymentViewController.swift
Swift
import UIKit import StripeTerminal class PaymentViewController: UIViewController { // Action for a "Checkout" button func checkoutAction() throws { // Populate the correct transaction amount from your application. let amount = UInt(10_00) // Build up parameters for creating a `PaymentIntent` let params = try PaymentIntentParametersBuilder( amount: amount, currency: "usd" ) .setMetadata(["offlineId": UUID().uuidString]) .build() Terminal.shared.createPaymentIntent(params) { createResult, createError in if let error = createError { // Handle errors in your application. print("createPaymentIntent failed: \(error)") } else if let paymentIntent = createResult { print("createPaymentIntent succeeded") // If the `PaymentIntent` was created offline, its `stripeId` field will be nil. if let onlineCreatedId = paymentIntent.stripeId { print("created online"); } else { print("created offline") } } } } }

The Terminal.createPaymentIntent accepts a CreateConfiguration parameter. By default, if you’re operating offline, the Terminal SDK stores all offline payments, then forwards them to Stripe’s backend when connectivity is restored.

To customize this behavior, you can pass in a CreateConfiguration object with an offlineBehavior attribute set to as REQUIRE_ONLINE, PREFER_ONLINE or FORCE_OFFLINE.

Managing risk

Setting offlineBehavior to REQUIRE_ONLINE fails the current transaction if you’re operating offline. For example, you might want to disallow transactions above a certain amount or disallow all offline transactions if the SDK has stored a set of transactions whose sum exceeds a certain amount.

The SDK exposes two properties to help you manage risk:

  1. Terminal.offlineStatus.sdk.offlinePaymentsCount
  2. Terminal.offlineStatus.sdk.offlinePaymentAmountsByCurrency

Managing latency while offline

Based on your network connectivity, the Terminal SDK automatically determines whether to collect payments online or offline. However, you might want to operate offline despite having an active network connection (for example, if you need to collect transactions quickly and your network connection is slow). You can pass a CreateConfiguration object with offlineBehavior set to FORCE_OFFLINE to collect the payment offline regardless of connectivity.

Payments collected offline while the Terminal SDK has an active network connection are forwarded in the background.

PaymentViewController.swift
Swift
import UIKit import StripeTerminal class PaymentViewController: UIViewController { // Action for a "Checkout" button func checkoutAction() throws { // ...build up parameters and callback for creating a `PaymentIntent` // Your app might want to prevent offline payments for too large an amount. // Here, we block the payment if the amount is over 1000 usd. // Otherwise, we allow collecting offline if the network connection is unavailable. let offlineBehavior: SCPOfflineBehavior = { if amount > UInt(1_000_00) { return .requireOnline } else { return .preferOnline } }() let createConfiguration = try CreateConfigurationBuilder().setOfflineBehavior(offlineBehavior).build() Terminal.shared.createPaymentIntent(params, createConfig: createConfiguration) { createResult, createError in // handle success or failure } } }

Collect a payment method
Client-side

SDK Reference

  • didRequestReaderInput (iOS)
  • CollectConfiguration (iOS)

Note

Payment liability is your responsibility when operating your reader offline. Because magnetic stripe data is easy to spoof, Stripe disallows this option while operating offline. Tapping cards is also not supported in markets where Strong Customer Authentication is required.

Collecting payments while offline is similar to collecting payments while online. Use the didRequestReaderInput method to display the valid card presentment options to the customer.

Note

Inspecting payment method details before authorization isn’t supported while offline. Although you can still use the initWithUpdatePaymentIntent parameter in CollectConfiguration, the paymentMethod field on the PaymentIntent is absent if the SDK is operating offline.

PaymentViewController.swift
Swift
import UIKit import StripeTerminal class PaymentViewController: UIViewController { // Action for a "Checkout" button func checkoutAction() { Terminal.shared.collectPaymentMethod(paymentIntent) { collectResult, collectError in if let error = collectError { print("collectPaymentMethod failed: \(error)") } else if let paymentIntent = collectResult { print("collectPaymentMethod succeeded") // ... Confirm the payment } } } }

Confirm payment
Client-side

Confirming payments while offline is similar to confirming payments while online. The primary difference is that your integration must handle offline-specific error cases, such as when the transaction exceeds the Stripe-enforced offline maximum of 10,000 USD or equivalent in your operating currency.

In some cases, the SDK might create a PaymentIntent online, but confirm it while offline. When this happens, the PaymentIntent might have a non-null stripeId. If it was confirmed offline, offlineDetails will be defined and populated.

PaymentViewController.swift
Swift
import UIKit import StripeTerminal class PaymentViewController: UIViewController { // Action for a "Checkout" button func checkoutAction() { Terminal.shared.confirmPaymentIntent(paymentIntent) { confirmResult, confirmError in if let error = confirmError { // Handle offline-specific errors in your application (for example, // unsupported payment method). print("confirmPaymentIntent failed: \(error)") } else if let confirmedPaymentIntent= confirmResult { print("confirmPaymentIntent succeeded") if let offlineDetails = paymentIntent.offlineDetails { print("confirmed offline"); } else { print("confirmed online") } } } } }

Providing receipts

You might require information about the card used to complete a payment while offline. For example, you might need to generate a receipt for customers who require one at the time of purchase.

If the PaymentIntent is confirmed offline, retrieve its OfflineCardPresentDetails from the paymentIntent.offlineDetails.offlineCardPresentDetails property.

This hash contains a ReceiptDetails property you can use to generate a receipt, as well as other card details like the cardholder name and card brand.

The account_type and authorization_response_code receipt fields are unavailable on PaymentIntents processed offline. Prebuilt email receipts are only sent after connectivity is restored and the payment is successfully captured.

Wait for payments to forward
Client-side

When Internet access is restored, the SDK automatically begins forwarding the stored offline payments.

The SDK attempts to forward payments even if its network status is offline. This means your connection token provider might receive a request to provide a connection token even when the device is offline.

If you power off your POS device too soon, your payments might not be forwarded. You can query Terminal.offlineStatus.sdk.networkStatus to make sure your POS is online and can forward payments, and Terminal.offlineStatus.sdk.offlinePaymentsCount to check how many payments the Terminal SDK has to be forwarded.

Capture payment

While offline, you can create PaymentIntents with captureMethod set to automatic.

After you confirm these PaymentIntents, they have a Succeeded status instead of RequiresCapture. Stripe automatically captures the payments after you forward them.

If you opt for manual capture, payments that are successfully forwarded and authorized require capture from your backend or application.

  • To capture payments from your backend, use webhooks to listen for PaymentIntents with a requires_capture status.
  • To capture payments from your application, wait for your application to receive calls to OfflineDelegate.didForwardPayment for each PaymentIntent as the SDK forwards it. A PaymentIntent is ready to capture if its status is RequiresCapture and the offlineDetails is null or has a requiresUpload value of NO .
PaymentViewController.swift
Swift
Terminal.shared.confirmPaymentIntent(paymentIntent) { confirmResult, confirmError in if let error = confirmError { // Handle offline-specific errors in your application (for example, // unsupported payment method). print("confirmPaymentIntent failed: \(error)") } else if let confirmedPaymentIntent = confirmResult { if intent.status == .requiresCapture { if let offlineDetails = confirmedPaymentIntent.offlineDetails(), offlineDetails.requiresUpload { // Offline payment, wait for `didForwardPaymentIntent` (see snippet below) } else { // Online payment, can be captured now } } // else, handle other intent.status results here } }

Capture an offline payment after the SDK forwards it in your OfflineDelegate’s didForwardPaymentIntent:

CustomOfflineDelegate.swift
Swift
import StripeTerminal class CustomOfflineDelegate: OfflineDelegate { // ... func terminal(_ terminal: Terminal, didForwardPaymentIntent intent: PaymentIntent, error: Error?) { if let error = error { // Handle the error appropriate for your application return } if intent.status == .requiresCapture { // The intent is ready to be captured. } else { // Handle the intent.status as appropriate. } } // ... }

Examine payments collected offline

After authorization, you can use the PaymentIntents API to examine offline details on a payment. Access the payment method details on the latest Charge object on a PaymentIntent to determine if it was collected offline.

Was this page helpful?
YesNo
Need help? Contact Support.
Join our early access program.
Check out our changelog.
Questions? Contact Sales.
LLM? Read llms.txt.
Powered by Markdoc