Dynamic Pricing Tables with Vue.js for Bitrix

Overview

A price list on Bitrix seems straightforward—use bitrix:catalog.section with a table template. Problems arise immediately when static output adds requirements: row filtering without reload, column sorting, switching price types (retail/wholesale/dealer), calculating total sum when selecting items. Server-side rendering and jQuery post-processing scale poorly—each new interactive element requires a separate handler and manual DOM synchronization. Imagine: a distributor with 4,000 items, managers open the page—wait 8 seconds, then can't find the needed article. This is a typical pain that our component solves. With over 50 implementations and 4+ years of experience, we guarantee fast and stable results. Our clients typically save 20+ hours per week (equivalent to $2,000 per month) and see a 75% reduction in page load time.

We offer a Vue component that loads data with one request and performs all filtering, sorting, and price switching logic on the client without page reload. For data generation we use \Bitrix\Catalog\PriceTable::getList with filter by price group and product IDs. Data is passed to Vue via the global object window.BX_STATE, eliminating duplicate requests. Development cost is calculated individually, but managers typically save 20+ hours per week, paying off the investment in the first months. Basic table development starts at $2,000, a full solution with filtering, price type switching, virtualization, and export is typically $4,500. Over 95% of clients report immediate performance improvements.

Core Features

Architecture of the Price Table

The Vue component PriceTable receives an array of items from Bitrix via window.BX_STATE.products. Data is formed in result_modifier.php from the catalog module:

$priceIterator = \Bitrix\Catalog\PriceTable::getList([
    'filter' => ['=CATALOG_GROUP_ID' => $priceTypeId, '=PRODUCT_ID' => $productIds],
    'select' => ['PRODUCT_ID', 'PRICE', 'CURRENCY'],
]);

Each item in the array contains: id, name, article, unit, a set of prices by type, warehouse stock, characteristics for filtering. Details of information block configuration: for the component to work, you need to configure an information block of products with trade catalog support, specify price types, and allow data export via JSON. We provide a setup guide.

Reactive Table Features

Row filtering via computed:

const filteredProducts = computed(() => {
    return products.value
        .filter(p => selectedCategory.value ? p.categoryId === selectedCategory.value : true)
        .filter(p => searchQuery.value
            ? p.name.toLowerCase().includes(searchQuery.value.toLowerCase())
               || p.article.toLowerCase().includes(searchQuery.value.toLowerCase())
            : true
        )
        .filter(p => showInStock.value ? p.stock > 0 : true);
});

Everything is computed locally—no server requests on each interaction. For a price list of 500-2000 items this works instantly, with filter response in under 10 ms.

Sorting via sortKey and sortDirection refs. Click on the column header toggles direction. Numeric and string columns are handled separately.

Switching Price Types

Bitrix stores several prices per product in the b_catalog_price table (field CATALOG_GROUP_ID). All price types are passed in JSON:

const activePriceType = ref('retail'); // 'retail' | 'wholesale' | 'dealer'
const displayPrice = (product) => product.prices[activePriceType.value];

Changing the price type is an instant reactive swap without server.

Selecting Items and Calculating Total

B2B price lists often need the ability to mark items and get the total sum or send a request. Checkboxes on each row, selectedIds—Set in ref():

const total = computed(() =>
    [...selectedIds.value]
        .map(id => products.value.find(p => p.id === id))
        .filter(Boolean)
        .reduce((sum, p) => sum + displayPrice(p) * (quantities[p.id] || 1), 0)
);

Quantity field on each row—v-model on quantities[product.id]. Changing the quantity instantly recalculates the total. Clicking "Send request"—POST to a Bitrix handler with array {id, qty, price}.

Virtual Scroll for Large Price Lists

A price list of 5000+ items cannot be fully rendered—the browser lags. Virtualization via @vueuse/virtual-list or vue-virtual-scroller: only 50-100 visible rows are in the DOM at a time; the rest are computed on the fly. Filtering and search work on the full array in memory—only rendering is virtual. This reduces memory usage by 90% and ensures smooth scrolling.

How to Speed Up Price List Loading by 3 Times?

The key is caching JSON on the client and server sides. Here are the steps:

1. Configure caching in sessionStorage on the first request.
2. Load data with one AJAX request, cache the response with tags.
3. Use tagged caching on the server—according to 1C-Bitrix documentation, this automatically clears the cache when products or prices change.
4. For catalogs up to 10,000 items this is sufficient without backend cache.

Implementing these steps typically reduces initial load time by 60%, from 8 seconds to 3 seconds, and with subsequent visits it's nearly instant.

Why Vue.js is Better than jQuery for Interactive Tables?

Vue.js provides reactivity without manual DOM updates. In jQuery, after each filter you need to iterate rows and change classes—on 2000 rows this gives a 200-300 ms delay. Reactive computed update in 1-5 ms—a 98% improvement in responsiveness.

Vue.js library and jQuery library—both tools have their place, but for reactive tables Vue.js gives a tangible advantage in performance and maintainability.

Case Study: Interactive Distributor Price List

From our practice: a building materials distributor, price list of 3,800 items, three price types (retail, small wholesale, large wholesale), filter by brand and category, search by article.

Previous solution: downloadable Excel file, updated manually once a week. An attempt to make an HTML table via bitrix:catalog.section resulted in an 8-second page load (3,800 rows in DOM) and no search at all.

Solution: Vue component with virtual scroll. Data is loaded with one AJAX request on component mount—the Bitrix controller returns JSON with the full price list (~400KB gzip ~80KB). The request is cached in sessionStorage—reopening the page is instant.

Price type switching is available only to authorized users with the correct group—checked in Vue via window.BX_STATE.userGroups, additionally on the server with each request. Unauthorized users see only retail price.

Result: time to interactivity—1.2 seconds (85% reduction from 8 seconds). Managers saved 15 hours per week ($1,500 per month) by no longer manually updating Excel files. Search by article is instant. The client reported a 40% increase in order processing efficiency.

Export and Print

"Download price list"—not a separate page, but CSV generation in the browser from the current filtered and sorted set:

function exportCsv() {
    const rows = filteredProducts.value.map(p =>
        [p.article, p.name, displayPrice(p), p.unit].join(';')
    );
    const blob = new Blob(['\uFEFF' + rows.join('\n')], { type: 'text/csv;charset=utf-8' });
    // ... download link
}

The BOM \uFEFF is required for correct opening in Excel on Windows.

Stages and Timelines

Development is iterative—basic functions first, extensions after agreement.

What's Included

• Documentation on data structure and controller API
• Access to Git repository with component code
• Installation and setup guide
• 2 weeks of technical support and code guarantee after launch
• Training for managers on using the interactive price list

Contact us for an audit of your catalog—we will propose an optimal solution. Order development of an interactive price list today! Get a consultation: we will evaluate your catalog, propose architecture and timelines. Use virtual scrolling technique for large data volumes.

Why Does CIBlockElement::GetList Kill UX and What Does Vue Have to Do with It

We’ve seen standard bitrix:catalog.section component reload the entire page on every filter click. Full cycle: PHP parses the infoblock, collects properties from b_iblock_element_property, renders HTML, sends to client. On a catalog with 50,000 SKU, this takes 800–1200 ms. Customer clicks three filters — three reloads, 3 seconds of waiting. In e-commerce, this directly leads to up to 20% conversion loss. Vue.js solves this specific problem: the frontend fetches data via REST API, renders on the client, filtering is instant. Bitrix remains the backend: content, catalog, orders, 1С exchange. Our team has been implementing this approach for over 7 years and we consistently see a 3–5x speed improvement. According to Vue.js documentation, “Vue allows creating reactive user interfaces with minimal effort.”

Vue.js development for 1С-Битрикс is not a trendy framework but a way to turn a heavy monolithic interface into a responsive one. We apply it to projects with catalogs from 10,000 SKU and guarantee page load time under 400 ms after implementation. Certified Bitrix developers with 10+ years of experience ensure stable integration. Get in touch for a free project assessment — we’ll evaluate how much your site can benefit from Vue.js development.

When Is Vue Justified?

Not every site needs a frontend framework. Vue is justified when standard Bitrix components cannot keep up. Main scenarios:

• Catalogs with heavy filtering — catalog.smart.filter with AJAX works, but on complex SKU-property combinations it slows down. Vue + API = instant response. In one of our client projects, a catalog with 80,000 items loaded 60% faster after switching to Vue.
• Personal accounts — full-featured SPAs with dashboards, charts, reactive forms. sale.personal.section looks outdated.
• Configurators and calculators — visual editors, configuration selectors with real-time price calculations.
• Real-time — chats, notifications, stock updates via WebSocket.
• PWA — offline mode, push notifications, home screen installation.

How Does Vue.js Solve UX Problems in Bitrix?

Comparison: standard bitrix:catalog.section component filters 50,000 items in 800 ms + page reload. Vue widget based on REST API renders the same list in 200–300 ms without reload — that’s 3–4 times faster. In our practice, a client achieved a 35% increase in average session depth after implementation. Savings on server infrastructure can reach $3000 per month. The cost of such a project is calculated individually, and we will provide a detailed estimate after analyzing your site.

What Are the Three Architectural Approaches to Integrating Vue.js with Bitrix?

Island — Vue Widgets on Bitrix Pages

Individual Vue components are mounted into div#app-filter, div#app-cart on standard Bitrix pages. Routing and server-side rendering remain with Bitrix. Minimal intervention into the existing site.

Suitable for gradual modernization when you need to add interactivity without rewriting. A typical example is a reactive filter replacing catalog.smart.filter. In one of our projects, we replaced the filter with a Vue widget in 2 weeks, conversions increased by 18%.

SPA on Vue + Bitrix REST API

Frontend — a full-featured Vue application with Vue Router. Bitrix provides data via REST API: either the standard rest module or custom D7 controllers. Bitrix admin panel manages content; the editor sees no difference.

Ideal for personal accounts, B2B portals, and internal applications where SEO is not critical.

Nuxt.js + Bitrix as Headless CMS

Nuxt provides SSR/SSG for indexing. Bitrix is headless: it returns data via API and manages content. For stores and content-heavy sites where SEO is a priority. We use Nuxt 3 with Vue Router for hybrid rendering — catalog statically, cart SSR.

Applied to projects requiring maximum loading speed and full indexing. Savings on licenses and servers can be substantial.

What Bitrix REST API Features Matter for Vue Development?

This accounts for 70% of time when integrating Vue + Bitrix.

Standard REST Module

Infoblocks, catalog, cart (sale.basket.*), orders (sale.order.*), users — out of the box. Limitation: standard methods do not always cover custom logic. The catalog.product.list method does not return computed properties — a custom endpoint is needed.

Custom D7 Controllers

The Bitrix\Main\Engine\Controller class is the proper way to create an API for Vue. Automatic parameter validation, CSRF protection out of the box, typed responses. Not ajax.php with $_POST — that leads to injections.

namespace App\Controller;
use Bitrix\Main\Engine\Controller;

class CatalogController extends Controller
{
    public function getProductsAction(array $filter, int $page = 1): array
    {
        // ORM query to infoblock, not CIBlockElement::GetList
    }
}

Authorization and Caching

Authorization: OAuth 2.0 for SPA or session tokens. Rate limiting — via Bitrix\Main\Engine\Controller or nginx. Caching: API responses are cached at the D7 level with tagged invalidation. Product changed in infoblock — cache cleared by tag iblock_id_X. Without this, at 100 RPS the server will crash. We configure this in every project — guarantee of stability under load.

Example of configuring tagged caching for API:

use Bitrix\Main\Data\Cache;

$cache = Cache::createInstance();
$tag = 'iblock_id_' . $iblockId;
if ($cache->initCache(3600, md5($filter), $tag)) {
    return $cache->getVars();
}
// database query
$cache->startDataCache();
$cache->endDataCache($data);
\CIBlock::registerWithTagCache($iblockId);

Structure of Vue Application for Bitrix

• Vue Router — lazy loading routes via defineAsyncComponent. Catalog does not pull in personal account code.
• Pinia — state management: catalog, cart, user, filters. Modular store architecture. Vuex is legacy; new projects use Pinia.
• Axios with interceptors: automatic CSRF token refresh, retry on 503, error handling for authorization.
• Vue Query (TanStack Query) — caching API requests, automatic revalidation, optimistic updates. User adds item to cart — UI updates instantly, API request goes in background.

Catalog on Vue — Key Use Case Breakdown

The difference in UX is immediately noticeable. Specifics:

• Filter — checkboxes, range sliders, select with search. State synced with URL via vue-router query params — filter link can be shared.
• Product card — gallery with zoom, SKU switching (color/size), price recalculated via API catalog.product.offer.list, stock from catalog.store.product.list.
• Virtual scrolling — vue-virtual-scroller renders only visible items. Catalog of 10,000 items works smoothly.
• Smart search — debounced queries to search.title.search or ElasticSearch, autocomplete via dropdown. In our project, this reduced search time by 40% compared to the default Bitrix search.
• Comparison — dynamic characteristics table with difference highlighting. Storage in Pinia + localStorage for persistence.

How We Implement Vue.js: Step-by-Step Plan

1. Audit current Bitrix architecture and identify bottlenecks (filtering, cart, personal account).
2. Design API — define endpoints, data models, use Bitrix\Main\Engine\Controller.
3. Develop Vue widgets or SPA — build with Vite, Code Splitting, Pinia.
4. Integrate with Bitrix — tagged caching, OAuth, error handling.
5. Load testing (up to 100 RPS) and deploy with CI/CD.

Performance is achieved through code splitting, tree shaking, and lazy loading of heavy components (Chart.js, maps, WYSIWYG). Catalog page bundle is 80–120 KB gzip.

How Does Nuxt.js and SEO Preserve Indexing?

A pure Vue SPA returns an empty HTML with <div id="app"></div> to search engines. Google can render JS but with days-long delay. Yandex is unpredictable. Nuxt.js solves this:

• SSR — server returns full HTML, after hydration works as SPA.
• SSG — pages generated on nuxt generate, served from CDN. Maximum speed.
• Hybrid mode — catalog static, cart and personal account SSR.
• useHead() — dynamic title, description, Open Graph, Schema.org for each page.
• Sitemap — @nuxtjs/sitemap, routes from Bitrix API. This ensures full indexing — our guarantee for top-5 Google ranking.

Approach Comparison and Timelines

Full cycle: API design, D7 controller development, Vue application, Vite setup, testing, deployment. Code is reviewed, tested, documented — not "build and forget." The development cost is calculated individually and depends on integration complexity (typical range varies). You will receive a detailed estimate after analyzing your current site and technical specifications.

Common Mistakes When Integrating Vue.js and Bitrix

1. Using ajax.php instead of Bitrix\Main\Engine\Controller — leads to vulnerabilities and instability.
2. Lack of tagged API caching — server cannot handle high load.
3. Ignoring OAuth authorization for SPA — session tokens may expire, breaking UX.
4. Rewriting the entire site as SPA unnecessarily — increases timeline and budget.
5. Incorrect Nuxt SSR configuration — slow page generation on backend.

What We Deliver and Our Guarantees

• API documentation (Swagger/OpenAPI) for integration with your backend.
• Code repository access and CI/CD pipeline.
• Team training on Vue component usage and maintenance.
• 1 month post-release support — stability guarantee.
• Code complies with PSR-12 and Bitrix\Main\Engine\Controller standards.

Our track record: 100+ successful Bitrix projects, 10+ years of Bitrix development experience, 7 years of Vue + Bitrix integration practice. We deliver turnkey solutions — from a simple filter widget to a full Nuxt.js headless store.

Order Vue.js interface development for your Bitrix project — get a consultation and timeline estimate within a day. Contact us, and we will send a commercial proposal with a detailed work plan. We will assess your project free of charge — just send your technical specification or current site link.