Parsing rules show Elbuz where pages keep the name, price, photos, and specifications for the source price list. The selector wizard and AI help pick them.
When you need this:
- New site, no rules yet — the wizard shows ready selectors for every link group.
- Product page setup takes long — AI picks field selectors, checks them on the page, writes them into rules.
- Price comes with text or in different blocks — fallback selectors and a regex clean it.
- Product data is page-embedded JSON — the JSON wizard shows the data tree, checks the value path.
Where to start: the “Import settings” tab → step 1, category links.
What parsing rules can do
- Fallback selectors — up to four options per field: the app takes the first one that returns a value.
- Value processing — or text, cleanup, replace, regular expression, price from digits.
- Test, wizard, and AI — check a rule on a live page and pick a selector without writing it by hand.
- Collecting without opening product pages — names and prices straight from the section page.
- Specifications — from a table on the product page or from a separate page.
- Data from JSON — when the site puts a product not in the markup but in an object inside the page.
How the rules grid works
Only the universal parser has the “Import settings” tab. It's a grid of rules grouped by crawl operation, and each group is one step of the pipeline. You edit rows right in the cell with a click; there's no “Save” button here, just like on the other tabs of this window.
1
Product links group2
Product card group3
Operation selector row4
Selector #1 column5
Test link column6
Lightning icon- The group of rules for the list of product links.
- The group of rules for the product card fields.
- The operation selector row is where parsing starts and where the action buttons live.
- Selector #1 holds the address of the needed place on the page.
- The test link column must be filled in, otherwise the test buttons do not work.
- The lightning icon starts selector picking with the wizard or AI.
In each group, the first row is called “Operation selector” — it points to the list or block itself where parsing of the whole group starts. The other rows are individual product fields. The difference matters: if the “Operation selector” fails, the whole group fails, no matter how many fields you fill in below.
For the “Product card” and “Attributes” operations, you can leave the “Operation selector” empty — then the app looks for fields across the whole page. For the two list operations, an empty selector means the crawl stops at this step.
Four selector columns — and four different meanings
Each row has “Selector #1” … “Selector #4”. In a field row, these are fallback options: the app tries them in turn and stops at the first one that returns a value. Handy when sale products are marked up differently from regular ones: put the main option in #1 and the sale one in #2. The exception is one field, “Image”: all four columns are used there, and the photos are combined into one list.
In the “Operation selector” row, though, the four columns mean completely different things, depending on the operation:
| Operation | Selector #1 | Selector #2 | Selector #3 | Selector #4 |
|---|---|---|---|---|
| List of product category links | links to sections | three more selectors of section links: all four run, and the results are combined into one list | ||
| List of product links | product block or link to the product page | pagination links | link to the current page (canonical address) | additional pagination links |
| Product card | product page block; empty — the whole page | — | — | links to option products: each becomes a separate “Product card” task |
| Attributes | specifications block; empty — the whole page | specification row: without it, the operation collects nothing | link to a separate specifications page | a tail appended to the product page address to get the specifications page |
This has two practical consequences. Site pagination is set up not in the “List of product category links” group, as the name suggests, but in “Selector #2” of the “List of product links” group. And specifications from a separate page (a separate “Specifications” tab) are turned on by filling in “Selector #3” or “#4” in the “Attributes” group. As soon as something appears there, the app stops looking for specifications on the product page itself and creates a separate task for the second page.
What else you can set in a rule row
The other columns process the value that's already been found. The order is fixed, and confusion about it causes most “strange” results.
- What to take. By default, the element's text is taken. The “Get HTML” checkbox keeps the markup — you need it for descriptions; “Allowed HTML tags” narrows it to the listed ones, for example
<p><br><ul><li>. - Addresses are completed. A relative link
/catalog/nasosy/becomes a full one;#,javascript:,mailto:, andtel:are dropped; the?click_track_data=tail is cut off. - Automatic cleanup. HTML comments, service tag attributes, emoji, non-breaking spaces, and repeated spaces are removed from the text.
- “Text to clean up” — cuts the specified text out of the result. Separate multiple values with
|||. - “Find” / “Replace” — three different actions depending on what's filled in. Both fields — a regular replace. Only “Replace” — the text is appended to the end of the value. Only “Find” — the text is cut out.
- “Remove links” — removes link tags from the result; two checkboxes in the “Additional” accordion set what exactly to remove: links to your own domain or to other domains.
- Price. In “price” type fields, only digits and separators are kept, the thousands and decimal separators come from the price list settings, and the result is rounded to two decimal places. If one value contains two prices — old and new side by side — the lower one is taken.
- “Regular expression” — extracts a piece of the found value.
- “Value delimiter” — if the selector found several elements, they're joined with this delimiter. The default is a comma, “ / ” for the category, and
|||for photos.
Two more columns are about quantity, not the value. “Max. number of results” in the “Operation selector” row limits how many elements are taken from one page: with 20, a run brings twenty products from a section, however many it has. A rule test ignores this limit and shows everything found. But the number of pagination pages the app builds from the address is limited by this number in both a test and a run. “Link prefix”, despite its name, goes at the end of the address — it builds pagination pages like ?page=.
“Regular expression” works differently depending on whether the row has a selector. Without a selector, the app searches the whole page for the expression and takes every match of the first group. With a selector, it applies the expression to the found value and takes the second match of the first group. So an expression that matches exactly once changes nothing when paired with a selector: the value stays as it was. If the expression “doesn't work”, check this first, not the expression itself.
One more small thing that's easy to miss: if you write text in curly braces instead of a selector, it becomes a fixed field value. {New collection} in the “Manufacturer” field sets this text for all products without searching the page for anything.
How to pick and check a selector
Selectors are written in or XPath; for XPath, select the “XPath” checkbox in the same row — without it, page parsing breaks off with an error. Syntax, ::attr(), pseudo-classes, and ready-made recipes for each field are in the selector reference.
Three different buttons help you pick a selector, and it's worth not mixing them up.
- Rule test (the horizontal arrows icon in the “Operation selector” row) — opens the page on the neighboring “Testing” tab and shows what the selector returned in the left “Test result” panel. It doesn't change anything in the rules.
- The lightning button in the same row — “Get page selectors”. For the two list operations, it opens the “Parser configuration wizard”; for “Product card” and “Attributes”, it starts AI selection. Both download the site page.
- The AI assistant magic wand in the toolbar of the “List of links” tab, tooltip “AI assistant: compose a CSS selector or XPath”. It's a conversation, not a button: you paste a piece of HTML from the page, and the assistant replies with a ready selector and an explanation of what it selects. It doesn't write anything into the rules grid — you copy the selector yourself.
The “Parser configuration wizard” doesn't write anything for you either, and that's the main thing to know about it. It downloads the page and shows a grid: “Activity”, “Name”, “Link”, “Selector”, “Total links”. Each row is a group of similar links from the page with a ready CSS selector for it, and the “Total links” column shows how many links that selector catches.
The hint at the top of the window says so: “The following is a list of site links based on CSS styles (the class attribute ). You need to copy the desired selector and paste it into the “Operation Selector” field.” So your job is to find the row whose link count resembles the number of sections (or products in a section) and move its selector to the rules grid by hand.
AI selection works differently: the page is downloaded, the markup is cleaned and sent to the model, and the app immediately checks the suggested selectors on the same page. If some fields fail, it makes one more request for them, and then writes the result into the rules. Before it starts, the window asks: “AI will pick selectors for this operation and REPLACE the current parsing settings. The previous values cannot be restored.” The confirm button says “Pick and replace”.
This replacement can't be undone — neither with a button nor by picking again. If your selectors were set up by hand and work, copy them somewhere before you click the lightning button.
All three buttons in a rule row need the “Test Link” column filled in: a section address for the list operations, a product address for the product card and attributes. If the column is empty, the lightning button shows the “There was a problem!” window with the text “Test Link!”, and the test button simply does nothing — no message at all.
How to read the test result
The left “Test result” panel is the main setup tool, and it shows exactly what a run will return. What it looks like depends on the operation.
- For the two list operations — a heading with a count in brackets (“List of product category links (37)”) and the list itself: the name with the address under it. The number in brackets is the first thing to look at: 0 means a dead selector, 300 instead of 30 means the selector grabbed the whole site menu along with service pages.
- For “List of product links”, a second heading follows the list — “List of links to product listing pages (pagination)” with the same counter. Empty here means only the first page of the section will be collected.
- For “Product card” — a list of fields with names: “Name”, “Price”, “Manufacturer SKU”, and so on, each with its value. Below are separate blocks: “Photo (8)” with thumbnails, “Video”, “Files”, “Attributes”, and “Product links” (these are option products from “Selector #4”).
- For “Attributes” — “name: value” pairs and a counter in the heading.
Next to each link found in the results of the first operation there's a trash icon, “Add to ignore list” — you can weed out junk sections right here; the rule goes to the , which lives in a separate window.
A row can have two trash icons, and they create different rules: the one next to the name ignores by section name, the one next to the address ignores by address.
The test and the selector wizard get the page differently, and it shows when a site is picky. The test opens the address in an embedded window of your browser, and the Elbuz extension returns the markup — so you see the page the way your browser sees it, with your cookies. The wizard and AI selection download the page through the Elbuz server. If the test shows data but a run in server mode doesn't, this is usually the reason: the site returns different content to a browser and to a server.
1
Test result panel2
Website URL field3
Border between the panels- The test result panel lists every field the rules extracted from the page: category, name, manufacturer, SKU and barcode.
- The website URL field holds the address of the page the rules were tested on.
- The border between the panels separates the extracted values on the left from the page they came from on the right.
Step 1. List of product category links
What the app does. It opens one page — the address from the “Category link” field, or the site home page if the field is empty — and collects all links on it that match the selector. There's no “smart” filtering here: every link the selector catches goes into the queue, including “Delivery” and “Contacts” if they sit in the same menu.
What you set. One link selector in the “Operation selector” row — and, if needed, three more in columns #2–#4 if sections on the page are marked up differently (for example, the top menu and the tiles on the home page). The “Link prefix” column works as a tail here: whatever is written in it is appended to the end of every address found.
How to check. The test button in this row. The number in the result heading should be close to the number of sections in the site's catalog.
You don't know which CSS selector to use for category links. You don't guess it — you take it from the site page. Enter the address of the home page or a page with the section menu in the “Test Link” column and click the lightning button “Get page selectors” in the “Operation selector” row.
The “Parser configuration wizard” opens (about the three helpers): each grid row is a group of site links by CSS class, the “Selector” column is a ready CSS selector for it, and “Total links” is how many addresses it catches. Find the row where the number matches the number of catalog sections and the links in the “Link” column lead to categories. Copy its “Selector” to the “Operation selector” and check it with a rule test. The wizard doesn't write anything into the rules itself.
What you see when something's wrong. If the selector found nothing, the parsing log has a single row with code 200 — the page arrived, but no tasks for the next step appeared. In the feed, this looks like an instant “Job completed”.
If “Auto-detect selectors” is on and the column is empty, the behavior is different. The app first strips the footer, sidebars, and scripts from the page, then tries forty-eight typical menu and catalog selectors, takes up to four different ones, and writes them into the empty columns of the rule. Along the way, it drops links by a list of service words — payment, delivery, contacts, blog, cart, compare, language switchers, and sign-in pages. That's why, after a test with auto-detect on, the rules grid reloads: it already contains the selectors that were picked.
Step 2. List of product links
What the app does. It opens a section page and does two things at once: collects links to product pages and collects the addresses of the next pages of this section. A “Product card” task is created for each product, and one more task of this same step for each pagination page.
What you set. “Selector #1” — the product block in the listing (for example, div.product-item) or the link to the product page. “Selector #2” — pagination links. If the site has no pagination links and pages are built by address, use three special columns: “Total pages selector”, “Total products selector”, and “Products per page selector”. From them, the app calculates the number of pages and builds the addresses itself, appending the “Link prefix” and the number (for example, ?page=).
A special case — “Products in this operation”. This is a checkbox in the same “Operation selector” row. If it's selected, product pages aren't opened at all: the name, price, availability, and photo are taken straight from the listing, and you fill in not one selector but the field rows in this same group. This is exactly what the wizard's “Load products and prices without opening the product page” switch turns on.
In “products straight from the listing” mode, a product without a name or without an address isn't saved at all. So the “Product link (URL)” field in this group is as mandatory as the name: without it, the run finishes cleanly, but the price list has no rows.
How to check. Run a test on a section address. The result should have two counters: products and pagination. If “Products in this operation” is selected, you'll see the fields of each product instead of a list of links — it's immediately clear whether the price got mixed up with the old price.
What you see when something's wrong. An empty list means the block selector doesn't match the layout. If the section page has no products at all — this happens when a section consists of subsections — the app doesn't give up: it tries to parse the same page with the step 1 rules and take subsection links from it.
One more column in this group helps on sites where search sometimes opens a product page right away instead of a list: “Text on the page to go to the next operation”. If the specified text is found on the page, the app doesn't look for links but parses this page as a product page.
And the last safety net of this step: if in “products straight from the listing” mode the selectors returned no products, but the page has product markup for search engines, the app tries to collect products from it. “Product card” has no such safety net.
Step 3. Product card
What the app does. It opens a product page and fills in the price list fields — one rule row per field. Photos, videos, and files go into separate product lists. If “Selector #4” holds a link selector, each link found becomes another “Product card” task — that's how option products that sit on separate pages of the site are collected.
What you set. Field selectors. Only one is filled in out of the box — h1 for the name. An empty row means “don't collect this field”: no default values are substituted into it.
The full list of product page fields and what happens to each on the way to the catalog is in the article What exactly the parser takes from a product page.
How to check. Run a test on any product's address. The left panel shows the list of fields with values and a “Photo” block with thumbnails — you can see both what was collected and what was collected wrong.
What you see when something's wrong. An empty field in the test result means an empty or dead selector. A product without a name in the price list is the same case, only after a run.
The app handles a few small things itself, so you don't need to spend selectors on them. If the “Category from price list” field is empty, the product category is taken from the breadcrumbs in the page markup, and words like “Home / ” and “Catalog / ” at the start are dropped. A YouTube link that lands in the “Image” field goes to videos, not photos. Placeholder images named placeholder, no-photo, empty, no_image, no-image and images from /brand/ aren't saved.
Step 4. Attributes
What the app does. It parses the specifications table row by row and saves “name — value” pairs. If “Selector #3” and “#4” are empty, specifications are looked for on the same product page right after it's parsed. If they hold something, specifications are taken from a separate page, and a task of its own is created for it.
What you set. Four rows. “Operation selector” — the specifications block (for example, table.specs), or empty if the block can't be singled out. “Selector #2” in the same row — the selector of one specification row (tr). Then the separate rows “Attribute name” and “Attribute value” — the cells inside the row (td.name and td.value). Two more rows, “Attribute block name” and “Attribute description”, are needed for sites where specifications are split into sections.
How to check. Run a test on a product address: the result shows “Attributes (N)” and the pairs themselves. If specifications are taken from a separate page, a row with its address appears in the test result — that's normal and means the app found where to go.
What you see when something's wrong. An empty “Selector #2” — specifications aren't collected at all, even if everything else is filled in: without a row selector, the operation exits without doing anything. The same name and value in a pair — the cell selectors point to the same element; the app drops such pairs itself.
Products are delivered as JSON right in the page
Many sites put product data not in the HTML markup but in a JSON object inside the page — in a <script> tag or in an attribute like data-product. The site can take data from there, but only in the “Product card” and “Attributes” groups: for link lists, isn't parsed. The “Operation selector” row of each group has a file-with-code icon, tooltip “Configure JSON extraction”. It opens the “JSON data setup wizard” window.
1
Regular expression for getting JSON text2
Get JSON button3
Data tree tab4
Expression for testing data fetch- Regular expression field — cuts the JSON text out of the page code.
- Get JSON button — downloads the page and applies the expression (not pressed while shooting).
- Data tree tab — shows the received JSON as a tree; the Received code tab next to it shows the raw text.
- Expression for testing data fetch — a path into the tree that the Verify button checks.
- In the “Operation selector” row, fill in the “Test Link” column with a product page address — the wizard takes the page from there.
- In the “Regular expression for getting JSON text” field, write an expression that cuts the JSON out of the page; the part you need is taken from the first group in brackets. For example, for
<script>var product = {...};</script>, usevar product = (\{.*?\});; for an attribute —data-product_variations="(.*?)". The field saves itself as soon as you change it — to the “Regular expression for getting JSON” column of this rule row. - Click “Get JSON”. The wizard takes the saved expression and shows the object structure on the “Data tree” tab and the raw text on the “Received code” tab. Empty means the expression cut out nothing or what it cut out isn't valid JSON.
- In the “Expression for testing data fetch” field, try the path to the value you need, for example
nameoroffers.price, and click “Verify”.
Two things are left to do by hand in the rules grid: select the “JSON” checkbox in the “Operation selector” row, and in the field rows (“Name”, “Price”…) enter a JSON path instead of CSS in “Selector #1” — in the JMESPath language, the same one as in the test field.
If the expression finds several matches on the page, the wizard shows the last one, while the parser takes the first one during a run. Paths checked in the wizard may then fail in a run — refine the expression so there's only one match. The wizard downloads the page from the server directly, without the extension or a proxy, so a site that blocks servers may return nothing in the wizard even though it opens in a browser.
Scenarios
Name and price are enough, no need to open product pages
In the “List of product links” group, select the “Products in this operation” checkbox in the “Operation selector” row and fill in the field rows in the same group: “Name”, “Product link (URL)”, “Price”. Products are collected straight from the section page, and no “Product card” tasks are created.
What you won't get: specifications and anything else that's only on the product page, not on the section page. A product without a name or an address isn't saved at all — that's why the “Product link (URL)” field is mandatory here.
Specifications are on a separate tab of the site
In the “Attributes” group, fill in “Selector #3” in the “Operation selector” row — the link to the specifications page, or “Selector #4” — the tail appended to the product page address. The app stops looking for specifications on the product page itself and creates a separate task for the second page.
What you won't get: without “Selector #2” — the specification row — “name — value” pairs aren't collected either on the product page or on the separate page.
The site has no pagination, pages are built by address
In the “List of product links” group, fill in “Total pages selector” or the pair “Total products selector” and “Products per page selector”, and put a tail like ?page= in “Link prefix”. The app calculates the number of pages and builds the addresses itself.
What you won't get: “Max. number of results” also limits the number of pages built — both in a test and in a run.
What to do when a rule doesn't work
| What you see | Why | What to do |
|---|---|---|
| The rule test shows an empty panel, even though the selector was copied from the browser | The row contains XPath, but the “XPath” checkbox isn't selected — or the CSS selector has a syntax error. Page parsing then breaks off instead of returning an empty list | Select the “XPath” checkbox in the same row or fix the selector (about selectors) |
| “Regular expression” in a rule row changes nothing | With a selector, the expression takes the second match of the first group. If there's only one match, the value stays as it was | Remove the selector from the row so the expression searches the whole page, or rewrite the expression so the part you need is the second match (value processing) |
| Attributes aren't collected, even though the name and value selectors are filled in | “Selector #2” is empty in the “Operation selector” row of the “Attributes” group: without a specification row selector, the operation exits without doing anything | Enter the selector of one specification row in “Selector #2”, usually tr (the “Attributes” step) |
| In “without opening the product page” mode, the run finishes, but the price list is empty | A product without a name or an address isn't saved. Most often, the “Product link (URL)” field isn't filled in in the “List of product links” group | Fill in both fields in this group — “Name” and “Product link (URL)” (the “List of product links” step) |
| The “There was a problem!” window with the text “Test Link!” | The lightning button was clicked, but the “Test Link” column in the row is empty | Enter the address of the right kind of page in this column: a section for the list operations, a product page for the product card and attributes |
FAQ
I'm setting up a parser for a new supplier and don't know which CSS selector to use for category links. How do I pick one?
With the wizard: enter the address of a page with the section menu in “Test Link” and click the lightning button in the “Operation selector” row. Copy the selector of the row where “Total links” matches the number of sections, and check it with a test (step by step).
Where is pagination set up?
In the “List of product links” group, the “Operation selector” row, the “Selector #2” column. If there are no pagination links, pages are built by address — see step 2.
The rule test shows nothing, even though I copied the selector from the browser. What's wrong?
Three reasons: XPath without the “XPath” checkbox; the page in “Test Link” is the wrong kind — a section instead of a product page; the site returns different content to a server than to a browser. More: how to read the test result.
I clicked the AI selector button. Can I get the old values back?
No. After you confirm “Pick and replace”, there's no undo: you'll have to enter the selectors again or pick them once more. Before clicking the lightning button, copy working values somewhere.
Can I set one value for all products without searching the page for it?
Yes: instead of a selector, write text in curly braces. {New collection} in the “Manufacturer” field sets this text for all products.
Where it is and who has access
- Menu
- Directories → Processing price lists → List of price lists
- Rules grid
- the “Site parser” row → “Setup” → the “Import settings” tab
- Access right
- the “Price lists” window
- Have ready
- a section address and a product page address — to test the rules
Related topics
- If you need the big picture of collecting from sites — Site parsing.
- If you need a ready selector for the price, SKU, or photo — CSS and XPath selectors: examples.
- If you need to know which fields can be collected at all — What exactly the parser takes from a product page.
- If the rules are checked and it's time to collect — How to start collecting from a site.
