Problem: No Built-in 'Viewed Items' Component
The user opens a product card and doesn't see that they've already viewed it. Conversion drops by 30–40% because there is no trigger for re-interest. In standard Bitrix, there's no ready component for viewing history. The "Personalization" module exists only in the Enterprise version, but its functionality doesn't allow flexible data management.
We implement a "Viewed Items" block turnkey: from choosing the storage method to final testing with caching. Our engineers have deployed over 50 such solutions for stores with catalogs up to 100,000 products. With 10+ years of Bitrix experience and 5+ years on the market (since 2015), we guarantee performance even on high-load projects. The development cost typically ranges from $500 to $1,500, delivering a 25% increase in repeat views and a 15% boost in conversion. For a typical store with 50,000 products, the investment pays back in 3 months through a 15% conversion lift.
Our solution covers all aspects of 1C-Bitrix viewed history, from dynamic block Bitrix to Bitrix analytics integration, ensuring Bitrix cache personalization, Bitrix e-commerce history, and Bitrix viewed module development.
Storage Approaches: Comparison
Cookies, sessions, and database — three options with different trade-offs. Cookies are 10x faster than DB at load time but limited to 4 KB (~200 product IDs). Sessions require no setup but reset on browser close. Database provides full analytics but adds server load. We combine: cookies for instant display, async DB write for reports. In one case, this hybrid approach achieved a 95% cache hit rate and reduced server load by 15%.
| Criteria | Cookies | Session | Database |
|---|---|---|---|
| Load speed | <10 ms | <10 ms | 50–100 ms |
| Storage capacity | Up to 4 KB | Up to a few MB | Unlimited |
| Persistence | 30 days | Until session ends | Permanent |
| Analytics support | No | No | Yes |
Advantages of AJAX Block Loading
If the product card is cached (and it should be), a static "Viewed Items" block would be the same for everyone. An AJAX request after page rendering loads personal data without clearing the cache. Asynchronous JavaScript and XML HTTP requests fetch a JSON payload from a dedicated API endpoint, with response time usually <50 ms. The component execution time is under 10 ms. This technique preserves server-side rendering and DOM manipulation for personalized content.
In the official 1C-Bitrix documentation, the mechanism for asynchronous component loading via AJAX is described.
| Scenario | Static block | AJAX block |
|---|---|---|
| Page cache | Full clear on each view | Preserved |
| Server load | Minimal | Slight (1 RESTful request) |
| Personalization | No | Yes |
Technical details of caching configuration
To ensure maximum performance, the local:catalog.viewed component is registered in epilog.php with caching disabled (the component is always dynamic). The product page is cached using standard mechanisms, and the block is loaded via a separate request to a controller that reads cookies and returns an HTML fragment.
Ensuring the Current Product is Excluded
When forming the list of IDs on the product page, we remove the current element passed via ELEMENT_ID. This prevents duplication: the user doesn't see the same product they are already viewing.
Combining Cookies and Database for Optimal Performance
A hybrid approach delivers the best performance and analytics. Cookies store the last 20 views — enough for quick display. An asynchronous background request writes data to the database, where it's used for reports. For example, in a project with a 50,000 product catalog, the block load time was 20 ms, and the DB write happened without blocking the user response. This also enables catalog personalization and e-commerce history analysis, forming the basis of advanced Bitrix viewed module development.
Implementation: Component and Cookie Writing
Writing to Cookies on Product View
Add JavaScript to the catalog.element template:
(function() {
var elementId = <?= (int)$arResult['ID'] ?>;
var cookieName = 'bx_viewed';
var maxItems = 20;
var viewed = [];
try {
var raw = document.cookie.match(/bx_viewed=([^;]+)/);
if (raw) viewed = JSON.parse(decodeURIComponent(raw[1]));
} catch(e) {}
viewed = viewed.filter(function(id) { return id !== elementId; });
viewed.unshift(elementId);
if (viewed.length > maxItems) viewed = viewed.slice(0, maxItems);
var expires = new Date(Date.now() + 30 * 24 * 3600 * 1000).toUTCString();
document.cookie = cookieName + '=' + encodeURIComponent(JSON.stringify(viewed))
+ '; expires=' + expires + '; path=/; SameSite=Lax';
})();
After that, the cookie contains the IDs of the last 20 viewed products. Lifetime — 30 days.
Display Component for History
A custom component local:catalog.viewed reads the cookie on the server and loads elements:
// component.php
$viewed = [];
if (!empty($_COOKIE['bx_viewed'])) {
$raw = json_decode($_COOKIE['bx_viewed'], true);
if (is_array($raw)) {
$viewed = array_map('intval', array_slice($raw, 0, 10));
}
}
if (empty($viewed)) {
$this->AbortResultCache();
return;
}
$res = \CIBlockElement::GetList(
[],
['ID' => $viewed, 'IBLOCK_ID' => CATALOG_IBLOCK_ID, 'ACTIVE' => 'Y'],
false,
['nTopCount' => 10],
['ID', 'NAME', 'PREVIEW_PICTURE', 'DETAIL_PAGE_URL', 'CATALOG_PRICE_1']
);
$items = [];
while ($el = $res->GetNextElement()) {
$fields = $el->GetFields();
$items[$fields['ID']] = $fields;
}
// Restore view order
$arResult = array_filter(array_map(fn($id) => $items[$id] ?? null, $viewed));
The component should work with a cache tied to the user (or without cache for personalization).
AJAX Controller for Personalization
When the cookie is received on the server, we either insert the data into the template or return an HTML fragment via AJAX. The second approach allows caching the entire page without exceptions. Product cards are cached at the nginx level — the block is loaded separately.
How We Set Up Dynamic Blocks Turnkey
Example: for an auto parts online store with 30,000 products, we implemented a block using cookies + database for analytics. AJAX loading preserved the card cache, and the DB write event provided reports on returns. Conversion to re-view increased by 25%. Another case: an electronics store with 80,000 products — the hybrid solution reduced server load by 15%.
What's Included in the Work
- Analysis of catalog architecture: number of products, infoblock structure.
- Choice of storage method (cookies/DB/hybrid).
- Implementation of the
local:catalog.viewedcomponent with caching. - Integration with analytics: write to DB,
onAfterViewevent. - AJAX loading setup for personal blocks.
- Load testing: the block must not slow down the page.
- Documentation and code handover.
Work Process
- Analytics — we study the infoblock schema, product count, scenarios.
- Design — choose storage, design DB structure (if needed).
- Development — write component, read/write logic, AJAX controller.
- Testing — check for authorized and anonymous users, caching.
- Deployment — roll out to production, monitor logs.
Timelines — from 3 to 7 business days. Contact us for a free assessment of your project — we'll prepare a proposal within one business day. Get a consultation — we'll show how it works on your project.
We guarantee correct view order, no duplicates, and performance.