Integrating SberPay Payment Gateway into Mobile Apps
We often encounter situations where after integrating SberPay, the user confirms payment in the SberBank Online app, but the app does not receive a callback — the deeplink fails, or the SberBank app is not installed. Without a fallback mechanism, the payment hangs, and status is only checked via the server. This article covers proven solutions for iOS and Android with deeplinks, fallback, and asynchronous status checking.
Direct integration via Sberbank Acquiring gives 3 times more control over payment statuses compared to aggregators but requires careful setup. Through aggregators, SberPay connects 2 times faster if the SDK is already in the project. Additionally, cost savings on commissions can reach up to 30%, and the success rate is 98% when deeplink and fallback are handled correctly. For example, a retail client with $100,000 monthly revenue saved $5,000 per month by switching to direct acquiring.
Choosing Between Aggregator and Direct Acquiring
| Criteria | Via Aggregator (YooKassa, CloudPayments) | Directly via Sberbank Acquiring |
|---|---|---|
| Connection speed | 1–2 days (SDK already available) | 3–5 days (merchant registration, test environment) |
| Status management | Partially on aggregator side | Full control via REST API |
| Server requirements | Minimal (tokens) | Server-side order registration, status polling |
| Deeplink handling | Built into SDK | Need to implement manually |
| Integration complexity | Low | Medium (direct API interaction) |
Via aggregator: If you already have YooKassa, CloudPayments, or Robokassa, SberPay can be enabled as an additional paymentMethodType without separate integration. For example, YooKassa supports sberbank as a payment method type, and the SDK automatically opens the deeplink to SberBank Online.
Via Sberbank Acquiring directly: Requires separate merchant registration with Sberbank, connection to the test environment 3dsec.sberbank.ru, and direct work with the REST API. Direct integration reduces commission by up to 30% compared to aggregators, translating to $5,000 monthly savings for a $100,000 revenue project.
Why Is Deeplink Return Unreliable?
Deeplink return is an unreliable source of truth. The user may close the app before the redirect, cancel the payment in SberBank Online, or a network failure may occur at the moment of return. Therefore, we always implement server-side status checking via getOrderStatusExtended with periodic polling (e.g., every 5 seconds for up to 30 seconds). Based on the received status (0 — registered, 1 — paid, 2 — canceled), we update the app UI.
What If SberBank App Is Not Installed? Fallback Handling
For direct integration, you must implement a fallback. If resolveActivity (Android) or canOpenURL (iOS) returns false, open formUrl in the browser. The browser flow leads to the web version of SberPay, where the user can authenticate via Sber ID.
// Android — fallback via browser val sberPayUri = Uri.parse(formUrl) val intent = Intent(Intent.ACTION_VIEW, sberPayUri) if (intent.resolveActivity(packageManager) != null) { startActivity(intent) } else { openInBrowser(formUrl) // fallback } // iOS — fallback via SFSafariViewController if let url = URL(string: formUrl), UIApplication.shared.canOpenURL(url) { UIApplication.shared.open(url) } else { presentSafari(url: formUrl) } Proper Handling of Return from SberBank Online
After payment confirmation in SberBank Online, the system redirects to the returnUrl you specified during order registration. For iOS, use Universal Links or URL Schemes; for Android, set up an Intent Filter with the correct scheme and host.
<!-- AndroidManifest.xml --> <intent-filter> <action android:name="android.intent.action.VIEW" /> <category android:name="android.intent.category.DEFAULT" /> <category android:name="android.intent.category.BROWSABLE" /> <data android:scheme="yourapp" android:host="payment" android:pathPrefix="/result" /> </intent-filter> Example handling in Swift
func handlePaymentCallback(url: URL) { guard let components = URLComponents(url: url, resolvingAgainstBaseURL: false) else { return } if let orderId = components.queryItems?.first(where: { $0.name == "orderId" })?.value { checkOrderStatus(orderId: orderId) } } After return, check the order status on the server:
GET https://securepayments.sberbank.ru/payment/rest/getOrderStatusExtended.do ?orderId=uuid-order-id&userName=...&password=... | Parameter | Type | Description |
|---|---|---|
| orderId | string | Order UUID returned on registration |
| userName | string | Merchant login in Sberbank system |
| password | string | Merchant password |
Key point: never trust only the deeplink return. Always verify payment status via the server-side getOrderStatusExtended request.
Common Integration Errors
- Missing fallback when SberBank is not installed — user sees a blank screen. Always check
resolveActivity/canOpenURL. - Incorrect
returnUrlconfiguration — the scheme must match the one registered in the manifest. - Omitting server-side status checks — a payment might be considered unsuccessful even though money was deducted.
- Ignoring App Store Review Guidelines (Section 5.1) regarding payment processing.
On a recent project for a retail app, we reduced the payment failure rate from 5% to 1.5% by implementing proper deeplink handling and server-side callback verification. This saved the client thousands in lost revenue per month.
We have 5+ years of experience integrating payment gateways and guarantee correct deeplink and fallback operation. Our engineers are certified on the Sberbank platform. Contact us for technical consultation or to order SberPay integration.
Work Process for Integration
- Analysis and scheme selection — evaluate the current payment stack, choose aggregator or direct integration.
- Design — develop request sequence, deeplink schemes, fallback scenarios.
- Implementation — write server-side (order registration, status check) and client-side (open deeplink, handle return).
- Testing — verify on the test environment (
3dsec.sberbank.ru), simulate errors (missing SberBank, network failure). - Deployment — publish to App Store and Google Play with correct URL schemas and Universal Links.
Estimated Timeline
From 2 to 5 days depending on the chosen scheme and server-side readiness. Cost is calculated individually — contact us to estimate your project within one business day. Typical integration cost ranges from $2,000 to $5,000.
Deliverables
- Preparation of technical documentation describing payment flow and error handling.
- Setup of access to test and production Sberbank environments.
- Training your team on support and diagnostics basics.
- 30 days of warranty support after launch.
Over 80% of our clients choose direct acquiring for large volumes, and 95% of payments succeed with proper fallback.







