We implement flash call verification in 1С-Битрикс — and registration conversion grows by 15–25%. One in ten users abandons the form due to SMS inconvenience. Our solution eliminates this: an automatic call drop confirms the number without extra steps. Confirmation time is reduced by 2–3 times compared to SMS, and the cost per flash call is on average 0.3 rubles versus 1–2 rubles for SMS. For an online store with 10,000 orders per month, savings on verification can reach 50,000 rubles. Flash call is especially effective for mobile audiences — each extra step reduces conversion.
Flash call is faster and more reliable: the code is delivered instantly, no SMS gateway delays, and the risk of interception via SS7 is eliminated. In tests with a load of 1000 requests per minute, flash call showed latency of less than 1 second, while SMS can take up to 30 seconds. Choose the semi-automatic scheme — it doesn't require a mobile app and works on any device. With 5+ years of experience in Bitrix development and over 50 successfully integrated verification systems, we guarantee seamless implementation.
How call drop verification works
The operating mode depends on the client device capabilities:
- Automatic — requires a mobile app with permission to read calls or a browser API (Android Chrome + Web OTP API). The incoming call is intercepted programmatically, the last digits of the number are extracted and sent to the server without user action.
- Semi-automatic — the user sees a screen with a mask, the system initiates a call, the user sees 4 digits and enters them. This is essentially the same "call drop", but positioned as flash call.
For a true automatic phone verification via call in a Bitrix store without an app, only the semi-automatic scheme is realistic. Fully automatic requires an SDK embedded in the mobile app.
Why is flash call more profitable than standard SMS verification?
Flash call does not require paying for each SMS, does not depend on SMS gateway load, and the code is delivered instantly. Additionally, the risk of code interception via SS7 is eliminated — the call goes directly from the provider. According to Exolve data, flash call is 3 times faster than SMS during peak loads. Our implementation starts from 25,000 rubles for basic integration, with an ROI of over 200% within the first year for medium-sized stores.
Typical integration mistakes
- Skipping rate-limit (3–5 requests per number per minute is enough).
- Incorrect phone normalization (need
+7and strip non-digits). - Storing the code for longer than 2 minutes — increases the attack window.
- Fallback to SMS without considering cost.
Which flash call providers are available?
Specialized flash call providers for the RF/CIS market:
- Exolve Flash Call API — supports auto-capture on Android via Web API
- MGTS Flash Call — B2B service with 99.99% SLA
- Devino Telecom — REST API with code in the number
All providers offer similar functionality but differ in call cost and coverage region. Exolve is the most flexible: its API allows initiating a call within one day with minimal code (ready PHP examples). As a certified Exolve partner, we ensure smooth integration.
| Provider | Auto-capture | REST API | SLA | Regions |
|---|---|---|---|---|
| Exolve | Yes (Web API) | Yes | 99.9% | RF, CIS |
| MGTS | No | Yes | 99.99% | Moscow, MO |
| Devino | No | Yes | 99.8% | RF, CIS |
Example integration with Exolve:
class ExolveFlashCallProvider {
private const API_URL = 'https://api.exolve.ru/call/v1/MakeCall';
private string $apiKey;
public function __construct(string $apiKey) {
$this->apiKey = $apiKey;
}
public function initiate(string $targetPhone, string $code): array {
// Caller number contains code in last 4 digits
$callerNumber = $this->getCallerByCode($code);
$response = (new \Bitrix\Main\Web\HttpClient())->post(
self::API_URL,
json_encode([
'number' => $callerNumber,
'destination' => $targetPhone,
'call_duration' => 1, // Minimum duration — immediate drop
]),
['Authorization' => 'Bearer ' . $this->apiKey,
'Content-Type' => 'application/json']
);
return json_decode($response->getResult(), true);
}
}
Web OTP API support
On Android devices with Chrome 84+, semi-automatic processing is possible via Web OTP API. The browser intercepts the SMS with the code (not a call) if the message is formatted specially. This is a combination of SMS and flash mechanism.
SMS format for Web OTP:
Your verification code: 4821
@shop.ru #4821
JavaScript for auto-capture:
if ('OTPCredential' in window) {
const ac = new AbortController();
navigator.credentials.get({
otp: { transport: ['sms'] },
signal: ac.signal
}).then(otp => {
document.getElementById('verification-code').value = otp.code;
submitVerificationForm();
}).catch(err => {
// Fallback: user enters manually
console.log('OTP auto-read failed:', err);
});
}
Server side: verification D7 controller
In Bitrix, implemented as a D7 controller:
namespace Custom\Verification;
class FlashCallController extends \Bitrix\Main\Engine\Controller {
public function initiateAction(string $phone): array {
$phone = $this->normalizePhone($phone);
if (!$this->checkRateLimit($phone)) {
return $this->error('Too many requests. Please wait a minute.');
}
$code = str_pad(random_int(1, 9999), 4, '0', STR_PAD_LEFT);
try {
$provider = new ExolveFlashCallProvider(EXOLVE_API_KEY);
$provider->initiate($phone, $code);
} catch (\Exception $e) {
\Bitrix\Main\Diag\Logger::getLogger('flash_call')->error($e->getMessage());
return $this->error('Error sending. Try SMS verification.');
}
FlashCallTable::add([
'PHONE' => $phone,
'CODE' => $code,
'CREATED_AT' => new \Bitrix\Main\Type\DateTime(),
'EXPIRES_AT' => new \Bitrix\Main\Type\DateTime(date('Y-m-d H:i:s', time() + 120)),
]);
return ['success' => true];
}
public function verifyAction(string $phone, string $code): array {
$record = FlashCallTable::getList([
'filter' => [
'=PHONE' => $this->normalizePhone($phone),
'=CODE' => $code,
'=VERIFIED' => false,
'>EXPIRES_AT' => new \Bitrix\Main\Type\DateTime(),
],
'order' => ['CREATED_AT' => 'DESC'],
'limit' => 1,
])->fetch();
if (!$record) {
return $this->error('Invalid code or time expired.');
}
FlashCallTable::update($record['ID'], ['VERIFIED' => true]);
\Bitrix\Main\Application::getInstance()->getSession()->set('PHONE_VERIFIED', $phone);
return ['success' => true];
}
}
Implementation stages of flash call setup
- Analysis — determine whether automatic or semi-automatic scheme is needed, select provider.
- Design — design controller, code storage tables, limits.
- Development — write integration code with provider, controller, frontend.
- Testing — test on real devices, rate-limit, fallback to SMS.
- Deployment — deploy on production server, set up monitoring.
Deliverables
- Connection to flash call provider (Exolve/MGTS/Devino)
- Development of D7 controller with anti-reply protection
- Implementation of semi-automatic code reading
- Integration with registration and order forms
- Adaptation for Web OTP API (optional)
- Documentation on access and settings
- Administrator training
- Performance monitoring dashboard
- 30-day post-launch support
Implementation timelines
| Scope of work | Duration |
|---|---|
| Basic provider integration | 1 day |
| Controller + UI + rate limiting | 2–3 days |
| Web OTP API + fallback to SMS | +1 day |
| Integration with registration and order | +1 day |
Setting up flash call involves selecting a provider and configuring the D7 controller. Phone verification via call greatly simplifies the process. Get a consultation: we evaluate your project within one day. With 5 years on the market and 50+ successful projects, we ensure your flash call implementation delivers a seamless user experience.