PHP Parser for 1C-Bitrix — Automated Product Import

Imagine an online store receiving price lists from 20 suppliers in CSV, XML, and HTML formats. Manually updating 50,000 items daily leads to inevitable errors and duplicates causing lost sales. We solve this – we develop a parser in PHP embedded in 1C-Bitrix, which automatically fetches data from any source and loads it into information blocks. A PHP parser for Bitrix is 2x faster than a Python solution due to direct API access. Contact us – we'll assess the task within one business day.

Over five years, we have implemented more than 20 parsing projects for Bitrix. Each parser is designed for a specific task: whether loading 10,000 products from CSV or gathering data from a dozen competitor websites. We use PHP because it's the native language for Bitrix. The parser can work directly with the information block API, without REST or intermediate queues. This reduces complexity and accelerates development by 2–3 times compared to hybrid setups. For tasks that don't require JavaScript rendering, PHP is the best choice.

Architecture of a PHP Parser

The parser consists of four components:

1. Source configuration. An array or database table with parameters for each source: URL, type (RSS, HTML, API), CSS selectors for data extraction, field mapping, update frequency.

2. HTTP client. For simple tasks – cURL via CHttpClient from Bitrix core or native curl_multi for parallel requests. For complex tasks – Guzzle with middleware for retry, logging, proxy rotation. More on parallel requests in the PHP documentation.

3. HTML/XML parser. DOMDocument + DOMXPath for precise DOM navigation. For CSS selectors – the Symfony\Component\DomCrawler library. For RSS – SimpleXMLElement.

4. Importer. A layer for writing data to Bitrix information blocks via D7 API or the old API (CIBlockElement).

How to Speed Up Parsing by 10x?

The main bottleneck of a PHP parser is sequential requests. Loading 1,000 pages at 2 seconds each = 33 minutes. With curl_multi, you can handle 10–20 requests in parallel:

$multiHandle = curl_multi_init(); $handles = []; foreach ($urls as $i => $url) { $ch = curl_init($url); curl_setopt($ch, CURLOPT_RETURNTRANSFER, true); curl_setopt($ch, CURLOPT_TIMEOUT, 30); curl_multi_add_handle($multiHandle, $ch); $handles[$i] = $ch; } do { $status = curl_multi_exec($multiHandle, $active); curl_multi_select($multiHandle); } while ($active > 0); 

Limitation: more than 50 parallel connections – and PHP starts consuming too much memory. For large-scale parsing (10,000+ URLs), split into batches of 20–30 connections.

Integration with the Bitrix Core

The advantage of a PHP parser is direct API access. No REST, no intermediate database needed. Import into information blocks:

$element = new CIBlockElement(); $elementId = $element->Add([ 'IBLOCK_ID' => IBLOCK_CATALOG, 'NAME' => $parsedData['title'], 'XML_ID' => $parsedData['external_id'], 'ACTIVE' => 'Y', 'PREVIEW_TEXT' => $parsedData['description'], 'DETAIL_TEXT' => $parsedData['content'], 'DETAIL_TEXT_TYPE' => 'html', 'PREVIEW_PICTURE' => CFile::MakeFileArray($parsedData['image_path']), ]); if ($elementId) { CIBlockElement::SetPropertyValuesEx($elementId, IBLOCK_CATALOG, [ 'SOURCE_URL' => $parsedData['url'], 'ARTICLE' => $parsedData['sku'], ]); } 

Important: during mass import, disable search and URL update:

CIBlockElement::DisableEvents(); // Disables event handlers 

Without this, each Add() triggers search reindexing, facet index updates, and other handlers – importing 10,000 products would take hours.

Learn more about working with events.

Error Handling and Resilience

A PHP parser in production must handle:

• Timeouts – server not responding, connection hangs. Set CURLOPT_TIMEOUT and CURLOPT_CONNECTTIMEOUT.
• HTTP errors – 403, 429, 503. For 429 (rate limit) – increase delay. For 403 – change proxy. For 503 – retry later.
• Invalid HTML – DOMDocument::loadHTML generates warnings. Suppress with @ or libxml_use_internal_errors(true), but log problematic URLs.
• Memory exhaustion – large HTML pages (5+ MB) consume memory. Set memory_limit appropriately and free DOM after processing: unset($dom).

Retry pattern with exponential backoff:

function fetchWithRetry(string $url, int $maxRetries = 3): ?string { for ($i = 0; $i < $maxRetries; $i++) { $response = @file_get_contents($url); if ($response !== false) { return $response; } sleep(pow(2, $i)); // 1, 2, 4 seconds } return null; } 

Logging

Without logs, debugging a parser is impossible. Minimal set of events to record:

• Start and end of parsing session (time, number of processed URLs).
• Each HTTP request: URL, response status, load time.
• Parsing errors: URL, error type, context.
• Import result: created, updated, skipped (duplicates), errors.

Use \Bitrix\Main\Diag\Logger from D7 or write to a separate parser_log table.

Comparison: PHP vs Python for Parsing

When PHP is Not Enough

A PHP parser is not suitable when:

• JavaScript rendering is needed – SPA websites, dynamic content loading. Here a headless browser (Puppeteer/Playwright) is required, which means Node.js or Python.
• Parsing volume exceeds 50,000 pages per session – PHP hits limits with single-threading and memory consumption.
• Complex text processing (NLP, classification, entity extraction) is required – Python's ecosystem is much richer.

In these cases, consider a hybrid approach: Python/Node.js for data collection, PHP for import into Bitrix.

Parser Development Stages

1. Source analysis – determine data structure, format, update frequency.
2. Architecture design – choose parsing scheme, parallelization, error handling strategy.
3. Implementation – write PHP code, integrate with information blocks and external systems.
4. Testing – load testing with real data, simulate failures.
5. Documentation and handover – architecture description, operation manual, developer training.

What You Get

• A working parser embedded in your 1C-Bitrix instance.
• Full documentation and code comments.
• A 3-month warranty on parser performance after project delivery.
• Free post-project support.

Developing a PHP parser costs 2 times less than a hybrid Python+Node.js solution, and maintenance is 3 times cheaper because all logic resides in one system.

Order parser development – we guarantee results and full documentation. Get a free engineer consultation.