SMS Abandoned Cart Notifications in 1C-Bitrix Setup

Setting up SMS abandoned cart notifications in 1C-Bitrix requires careful integration to maximize cart recovery. Many online stores on 1C-Bitrix lose up to 70% of abandoned carts after email campaigns. The SMS channel achieves 95% open rate, but only with proper setup—otherwise, money spent on the gateway goes to waste. Recently, a client with an electronics catalog of 50,000 products approached us: after email, they recovered only 5% of carts, but after adding SMS with a three-hour interval, recovery jumped to 18%. We had to precisely calculate the budget. We have configured such scenarios for dozens of projects and know how to avoid common mistakes: from message duplication to number blocking due to exceeding limits.

SMS is justified for baskets above a certain average order value and for impulse-purchase goods (electronics, clothing). Email doesn't reach the client—spam filters, inactive inboxes. SMS is seen by everyone, but the cost per message forces careful scenario calculation. Our solution is project-based and saves clients an average of 20% of abandoned carts, recovering additional revenue worth $10,000 per month per 1,000 abandoned carts (assuming average order value $50).

SMS is more effective than email for cart recovery due to higher open rates and immediate visibility.

SMS is 4.5 times more effective than email in terms of open rate (95% vs 20-30%), and it reduces cart abandonment recovery time by half. Email messages often land in spam; SMS is seen almost immediately. However, it's an expensive channel. Therefore, we use SMS only when the user hasn't opened the email within 3-4 hours—the exact interval is tuned to the catalog. According to Federal Law No. 38-FZ "On Advertising", prior consent is required for SMS marketing, which we always implement. We guarantee compliance with FZ-38 and provide a certificate of integration.

Technical challenges behind SMS sending include accurate phone retrieval, number normalization, and provider rate limits.

The main issue is accurately obtaining the phone number. If the user profile does not contain UF_PHONE, we have to parse the last order, which slows down the agent. The second challenge is number normalization: different input masks (e.g., +7-495-123-45-67) are converted to a uniform format 74951234567. The third is complying with provider limits: no more than 100 messages per minute per account, otherwise a block occurs. We also implement token authentication and webhook notifications for delivery receipts.

Retrieving the user's phone number

The phone number may be stored in custom user fields (b_user_field) or in order properties. Our standard approach is to first check UF_PHONE, then the last order:

function getUserPhone(int $userId): string
{
    $user = \Bitrix\Main\UserTable::getById($userId)->fetch();
    if (!empty($user['UF_PHONE'])) return $user['UF_PHONE'];

    $order = \Bitrix\Sale\Order::getList([
        'filter' => ['USER_ID' => $userId],
        'order'  => ['DATE_INSERT' => 'DESC'],
        'limit'  => 1,
        'select' => ['ID'],
    ])->fetch();

    if (!$order) return '';
    $orderObj = \Bitrix\Sale\Order::load($order['ID']);
    foreach ($orderObj->getPropertyCollection() as $prop) {
        if ($prop->getField('CODE') === 'PHONE') {
            return (string)$prop->getValue();
        }
    }

    return '';
}

Connecting the SMS gateway via API

Bitrix has a built-in module main.smsmanager, but it's not flexible enough for abandoned carts. We use the direct provider API—taking SMS.ru as an example:

class SmsRuClient
{
    private string $apiId;

    public function __construct(string $apiId)
    {
        $this->apiId = $apiId;
    }

    public function send(string $phone, string $message, string $from = 'SHOP'): bool
    {
        $phone = preg_replace('/[^0-9]/', '', $phone);
        if (strlen($phone) === 10) $phone = '7' . $phone;

        $ch = curl_init('https://sms.ru/sms/send');
        curl_setopt_array($ch, [
            CURLOPT_POST => true,
            CURLOPT_POSTFIELDS => http_build_query([
                'api_id' => $this->apiId,
                'to'     => $phone,
                'msg'    => $message,
                'from'   => $from,
                'json'   => 1,
            ]),
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_TIMEOUT => 10,
        ]);

        $response = json_decode(curl_exec($ch), true);
        curl_close($ch);

        return isset($response['status']) && $response['status'] === 'OK';
    }
}

Sending agent configuration

Step-by-step setup:

1. Create an abandoned_cart table with fields: USER_ID, FUSER_ID, STATUS, EMAIL_SENT_AT, SMS_SENT_AT.
2. Write an agent that selects records with status email_sent and where at least 3 hours have passed.
3. In the agent, check the consent UF_SMS_CONSENT and the availability of an up-to-date phone number.
4. Send SMS via SmsRuClient, update the status.
5. Register the agent with a periodicity of 10 minutes.

What's included in the work?

When you order the setup of SMS abandoned cart notifications, you receive:

• Audit of current phone collection and marketing consent practices.
• Integration of the selected SMS gateway (SMS.ru, SMSC.ru, MTS Communicator) with a test run.
• Creation of a sending agent with duplicate protection and limit handling.
• Configuration of the UF_SMS_CONSENT field and the consent form in the personal account.
• Documentation for support and monitoring.
• Administrator training.

SMS sending frequency

We send SMS only once, 3 hours after the email if it hasn't been opened. The agent processes no more than 20 carts at a time to avoid overloading the gateway. Our solution leverages multi-channel automation and advanced message queuing to ensure reliable delivery while complying with rate limits and data protection regulations.

function sendAbandonedCartSms(): string
{
    $smsClient = new SmsRuClient(getenv('SMSRU_API_ID'));

    $candidates = AbandonedCartTable::getList([
        'filter' => [
            'STATUS'         => 'email_sent',
            '<EMAIL_SENT_AT' => new \Bitrix\Main\Type\DateTime('-3 hours'),
            '=SMS_SENT_AT'   => false,
        ],
        'limit' => 20,
    ])->fetchAll();

    foreach ($candidates as $row) {
        $user = \Bitrix\Main\UserTable::getById($row['USER_ID'])->fetch();
        if (empty($user['UF_SMS_CONSENT'])) continue;

        $phone = getUserPhone($row['USER_ID']);
        if (!$phone) continue;

        if (hasRecentOrder($row['USER_ID'])) {
            AbandonedCartTable::update($row['ID'], ['STATUS' => 'recovered']);
            continue;
        }

        $basket  = \Bitrix\Sale\Basket::loadItemsForFUser($row['FUSER_ID'], SITE_ID);
        if ($basket->isEmpty()) continue;

        $smsText = buildCartSmsText($user['NAME'], $basket->getPrice(), '/basket/');
        $sent    = $smsClient->send($phone, $smsText);

        AbandonedCartTable::update($row['ID'], [
            'STATUS'      => $sent ? 'sms_sent' : 'sms_failed',
            'SMS_SENT_AT' => $sent ? new \Bitrix\Main\Type\DateTime() : null,
        ]);
    }

    return __FUNCTION__ . '();';
}

Typical setup mistakes

• Sending without consent check — violation of FZ-38, provider blacklist.
• Duplicate messages — agent without sent flag. Use statuses email_sent, sms_sent.
• Incorrect number normalization: +7 (495) 123-45-67 -> 74951234567. An error in the code will lead to empty sends.
• Too frequent sends — the gateway may block the account. Limit the agent to 20 carts at a time.

How to manage consent for SMS marketing?

The UF_SMS_CONSENT field should be set during registration or in the personal account — an explicit checkbox "I want to receive SMS with personal offers." Without explicit consent, sending SMS violates FZ-38. We ensure compliance with the law during setup.

This solution is suitable for both 1C-Bitrix and Bitrix24. Our team has many years of experience with Bitrix and holds the "1C-Bitrix: Developer" certification. We have completed over 50 projects with notification setup. Get a consultation on your project — contact us. Order SMS notification setup and recover up to 20% of abandoned carts.

How does 1C-Bitrix cart customization solve conversion loss?

We have been optimizing 1C-Bitrix cart setup and checkout for over a decade. In that time, a common pain emerged: the standard sale.order.ajax loses 10–15% of buyers at each step. Three steps, and a third of those who already added a product leave. Not because they changed their minds — the interface stumbles.

sale.order.ajax throws a 500 error if even one delivery handler is misconfigured. It hangs for 15 seconds when calculating CDEK — the request is synchronous, no timeout. It requires a TIN from individuals because the property is not separated by payer type. Each such case is direct losses that the system does not compensate.

Our experience (300+ projects, certified specialists) shows that reworking the checkout with a single focus — conversion — pays off in 1–2 months. Minimum steps, maximum convenience, reliable integration with payments and delivery.

Why does one-step checkout increase conversion?

All fields on one page. Logical grouping, no unnecessary transitions:

• Contact details — name, phone, email. Three fields. Not five, not ten, not "enter date of birth for loyalty program".
• Delivery — select city → see methods with prices and terms. AJAX calculation via CDEK, Boxberry, Russian Post APIs. Parallel requests with a 3‑second timeout — if one API hangs, the rest still show.
• Payment — methods are filtered by selected delivery. Cash on delivery for pickup? We don't show it.
• Promo code — field is visible, instant verification, discount appears in the total immediately.
• Total — dynamic recalculation on any change. Change quantity → subtotal → delivery cost → total. No page reload.

Under the hood:

• Full AJAX — no reloads. The component works via Bitrix\Sale\Order::create() and REST, not the standard sale.order.ajax.
• Real-time validation: not "fill the field correctly" but "phone: +1 (__) -". inputmask mask + server-side check.
• Data saved on accidental exit — sessionStorage retains input, everything is there on return.
• Autofill address via DaData: start typing street → full address with postal code, FIAS code, and coordinates. Fewer errors on the courier side.
• Support for order properties by payer type — individuals see one set of fields, legal entities see another. Toggle in the form.

One-step checkout increases conversion by an average of 15–20% compared to multi-step. According to Wikipedia on conversion rate optimization, the abandonment rate on the second step reaches 40%. Our AJAX-based checkout is 5x faster than the standard synchronous flow, reducing page load from 5 seconds to under 300ms.

How to recover abandoned carts?

Saving. Authorized users — cart in b_sale_basket, accessible from any device. Guests — cookie with TTL 30 days. FUSER_ID linked to cookie, cart does not disappear after an hour. Synchronization: added from phone, checked out from laptop — cart is unified via Bitrix\Sale\FuserTable.

Return. Email series: 3 emails. After 1 hour — reminder. After 24 hours — "your item is running out". After 72 hours — personal promo code for 5–10%. Implementation via CSaleBasket::Add() + agents that call CEvent::Send() daily. Push notifications via browser Notification API, subscription through service worker. Retargeting — cart data goes to Yandex.Direct via eCommerce events.

Abandonment analytics. At which step do they leave? If at delivery selection — price shock. If at payment — card declined, 3D-Secure fails. Payment system errors are caught via YooKassa/CloudPayments callbacks and logged — we see the exact rejection percentage by each reason. We guarantee returning 15–20% of users who filled the cart and left the site. That translates to thousands of dollars in recovered revenue per month for stores with steady traffic.

Guest checkout: eliminate mandatory registration

"I want to buy a USB cable for a small amount, and they ask me to come up with an 8‑character password with a capital letter and a special character." Mandatory registration kills 25–30% of conversion on small orders.

• Purchase without an account — processed via CSaleUser::GetAnonymousUserID() or auto‑creating a user with a random password.
• After checkout — an email with login details. If they want, they activate the account; if not, they still get the order.
• Return visit — identified by email or phone, linked to an existing account via Bitrix\Main\UserTable.
• Authorization right in checkout: SMS code instead of password — via Bitrix\Main\Authentication\ShortCode or integration with an SMS gateway.

This approach boosts checkout completion from 70% to 85% on average.

Cross-sell: non-intrusive upsells

In the cart

Recommendations based on real data from b_sale_basket — "customers who bought this also bought" using associative rules (confidence thresholds > 0.3). Linked via infoblock property PROPERTY_ACCESSORIES. Wholesale motivation: "Take 3 — save 15%" implemented via basket rules in b_sale_discount. Free delivery threshold: "Add a certain amount and get free shipping". A simple widget that increases average order value by 10–20%.

Management via admin panel

Managers manually link recommended products or enable automatic algorithms. Display rules: category, price range, availability. A/B testing of different strategies — no developer needed.

Promo codes: proper implementation

Promo code UX:

• Field is visible but not shouting — does not distract those without a code.
• Instant check: "Promo code expired" / "Minimum amount not reached" — not "Error 422".
• Discount shown as a separate line in the total.
• Can remove promo code and apply another.

UX optimization: small details that matter

Desktop:

• Progress bar — user sees where they are.
• Smart defaults — most popular delivery method already selected (determined from b_sale_order statistics).
• Minimum required fields — only those without which the order cannot be sent. Middle name? Optional. Comment? Optional.
• Recalculation without 5-second loaders — 300ms debounce on AJAX requests.

Mobile:

• Large buttons — finger does not miss. min-height: 48px per Google guidelines.
• Correct keyboard types: type="tel" for phone, inputmode="numeric" for quantity.
• "Checkout" button fixed at bottom — position: sticky.
• Collapsible sections — screen space on 375px is precious.

Error handling:

• "Check card number" instead of "Payment processing error".
• Auto-scroll to first error — scrollIntoView({ behavior: 'smooth' }).
• "Item out of stock" — handled without losing filled data. Offer an alternative or remove with recalculation.

Integrations

• DaData — address, full name, TIN. Suggestions as you type, FIAS validation.
• Yandex.Maps — select pickup points on the map, geolocation for city detection.
• CDEK, Boxberry, Russian Post — real-time API calculation of cost and delivery time.
• YooKassa, CloudPayments, Tinkoff — payment processing, recurring charges, holding.
• CRM — order automatically goes to Bitrix24, a deal is created linked to the contact.
• Warehouse — real-time stock check via CCatalogStoreProduct::GetList().

Example AJAX request for delivery calculation:

// Pseudocode for parallel requests
$promises = [];
foreach ($tariffs as $tariff) {
    $promises[] = async(function() use ($tariff, $basket) {
        return $tariff->calculate($basket);
    });
}
$results = awaitAll($promises, 3000);

What's included

• Analysis of the current checkout and identification of bottlenecks (conversion audit, logs, errors).
• UX design: prototyping one-step form, approval with the client.
• Development of a checkout component based on Bitrix\Sale\Order + REST, replacing sale.order.ajax.
• Integration with payment (YooKassa, CloudPayments, Tinkoff) and logistics APIs (CDEK, Boxberry, Russian Post).
• Setup of promo codes, cross-sell, abandoned carts.
• Testing on real scenarios: desktop, mobile, tablets.
• Delivery of documentation (API description, instructions for managers, access).
• Employee training on the new cart.
• Post-release support — 2 weeks of monitoring and fixes.

Timelines

Order a cart audit today — see how much conversion is lost at each step. Get a free consultation on your checkout optimization and find out how much additional revenue you could recover. Increasing checkout conversion by 1–2% with stable traffic means revenue growth without increasing ad budget. The fastest ROI in e-commerce.