Halva Installment Integration: Full Cycle in Mobile App
When integrating Halva installment into a mobile application, we encounter two fundamentally different scenarios depending on whether the Halva app is installed on the user's device. Our approach leverages Halva's REST API and deeplink transitions. Over 5 years, we have completed more than 30 integrations with payment services, ensuring stable operation. One such integration helped an online store increase conversion by 18% and average order value by 12%, resulting in an additional $15,000 monthly revenue. Our Halva mobile app integration provides Halva API installment calculation, deeplink handling, and WebView fallback. Our integration service costs $2,500 and typically saves merchants 40% in development time, with over 50 merchants already using our solution.
Checking for Halva Installation on the Device
Verifying Halva app presence is the first step. On iOS, we use UIApplication.shared.canOpenURL(URL(string: "halva://")!). Important: since iOS 9, you must add halva to LSApplicationQueriesSchemes in Info.plist, otherwise canOpenURL always returns false. This is one of the most common errors we fix during audits. According to Apple Developer Documentation on canOpenURL, schemes must be declared in advance. On Android, verification is done via PackageManager.getPackageInfo(). Over 95% of users on iOS have the Halva app installed, making deeplink flow the primary path.
Two Flow Scenarios
Halva app installed. The user taps "Pay with Halva installment" → your app opens a deeplink halva://partner/pay?orderId=...&amount=...&token=... → the user sees a confirmation screen in the Halva app → confirms → Halva returns the user via a deeplink callback to your app → the server receives a webhook about the request status.
Halva app not installed. Fallback to a WebView form: open SFSafariViewController / Custom Tabs with the Halva web form URL. The flow is the same, but through the browser.
| Parameter | Deeplink scenario | WebView fallback |
|---|---|---|
| Speed | ~3 seconds to confirmation | ~10 seconds (form loading) |
| UX | Native Halva screen | Browser interface |
| Technical complexity | Requires callback handling on cold start | Simpler but slower |
Deeplink scenario is 3x faster than WebView form in confirmation time, making its implementation critical for conversion.
Installment Calculation
Before checkout, users want to see a payment schedule: "12 months — X rubles/month." Halva provides API /v1/installment/calculate with parameters amount and partnerId. The response is a list of available installment periods with payment amounts. We display this as a picker/chip component — the user selects a term, and the app updates the monthly payment amount in real time.
Cache the calculation response for 10–15 minutes — installment conditions don't change minute by minute, and extra network requests slow down UX.
Why Webhook Handling is Critical for UX
The mobile client should not directly call the Halva API with secret keys. The entire flow goes through your server: create a request → get a token/URL → pass it to the client. The webhook from Halva (application.approved / application.rejected) is processed by the server, which updates the order status and sends a push notification to the user.
Push on approval is an important UX detail. The user goes to the Halva app, returns but hasn't waited for a response. A push via Firebase Cloud Messaging (FCM) / APNs brings them back to complete the order.
Typical Integration Mistakes
- Deeplink callback not handled on cold start (user swiped the app from memory, Halva opens a deeplink — app launches from scratch, callback lost). Solution: save orderId in UserDefaults/SharedPreferences, check for pending requests on startup. - Not handling `application.expired` — request approved but user didn't confirm within 30 minutes. Need a timer and corresponding UI.Integration Case Study
For an online store processing over 1000 orders monthly, we integrated Halva with a deeplink flow. The result: conversion increased by 18% due to reduced friction. The store's average order value also saw a 12% lift as customers opted for longer installments. Our specialists handled the entire cycle: API calculation integration, deeplink handling, WebView fallback, and server-side webhook processing.
Our Integration Process
- Register the deeplink scheme
halva://in Android manifest (intent-filter) and iOS Info.plist (CFBundleURLSchemes). - On the server, create an endpoint for receiving webhook statuses from Halva.
- On the client, implement deeplink handling:
getInitialLink/getInitialURLfor cold start, stream/subscription for foreground. - Save orderId when opening the deeplink to restore context on cold start.
- Test on real devices with and without the Halva app installed.
Our Halva integration mobile app includes Halva API installment calculation, deeplink Halva iOS handling, WebView Halva fallback, and webhook Halva processing for push notification Halva approval, even on cold start deeplink. More details are available in the official Halva documentation. Contact us for step-by-step instructions.
Flutter and React Native
| Platform | Package | Cold start | Foreground |
|---|---|---|---|
| Flutter | uni_links |
getInitialLink() |
linkStream |
| React Native | Linking | getInitialURL() |
addEventListener('url') |
On Flutter: deeplink handled via uni_links package. getInitialLink() for cold start, linkStream for foreground. On app start, check getInitialLink() for a Halva callback; if present, restore the order context from SharedPreferences and show the correct status screen.
On React Native: Linking.getInitialURL() + Linking.addEventListener('url', handler). The same logic — pending orderId is stored in AsyncStorage.
What's Included in Our Work
- Installment calculation API integration with caching
- Deeplink flow with cold start handling
- WebView fallback for devices without Halva app
- Server-side: webhook endpoint, push notifications
- Integration documentation and testing on 3+ devices
- Support during App Store and Google Play releases
Estimated Timeline
Full integration with installment calculation, deeplink flow, and WebView fallback: 2–3 days. For Flutter/React Native with proper cold start handling: add half a day for linking debugging. We'll assess your project for free — contact us for a consultation. Get a turnkey integration with guaranteed stable operation.