Elbuz collects products, specifications and each seller's price from public Kaspi.kz pages — with the shop name and delivery time, not one "Kaspi price".
When you need this:
- You need each seller's price — offers go to the “Seller list”; the product gets the lowest price and the shop name.
- You track a whole category — fast mode takes prices from category pages without opening products.
- You don't trust some shops — “Seller list” checkboxes decide whose price counts.
- Prices differ from your browser — the city code gives your region's prices.
Where to start: create a source on the “Kaspi” tile in the connection wizard.
What the Kaspi parser can do
- Prices from every seller of a product — price, shop, delivery time; the price list product gets the lowest one.
- Seller filtering — blacklist and whitelist, choosing whose price counts.
- Prices for your city — the city code is added to every request.
- Fast mode and the full product page — a category price list without opening product pages, or specifications, photos and sellers from the product page.
- Repeat run — rebuild the price list from scratch or pick up only new products.
- Server-side run — survives a break-off, with clear limits.
How to create a source and give it addresses to crawl
As with any source, the wizard asks who the data comes from (“Who”) and where to get it (“From where”). At “Who”, pick an existing contact or type a name — for example, “Kaspi, competitors”. At “From where”, find the “Kaspi” tile among the ready-made parsers and click “Next”.
The source is then linked to the module, and the settings window opens right away. Nothing is requested from kaspi.kz at this step — crawling starts only when you run it yourself or the schedule kicks in.
The ready-made module's settings are shared by all sources that use it; no copy is made for your price list. With two Kaspi sources — say, one for your category and one for a competitor — changing a checkbox in one changes the other. When there's more than one source, the window says so in a line above the tabs.
List of links: where crawling starts
The “List of links” tab is the list of start addresses. Enter either Kaspi catalog category addresses or specific product page addresses. Each row has a “This is a link to a product” checkbox: with it, the address goes straight to product page parsing; without it, the address is treated as a category page to collect product links from.
The module doesn't ask how much to take from a category. The “Max. number of pages from category” and “Max. number of products from the category” fields on the “Additional” tab are shared by all ready-made modules, but Kaspi ignores them: it divides the category's product count by 12 (items per Kaspi page) and creates a task for every page.
The only way to limit the volume is through the list of links itself — give narrower categories or specific product addresses.
- Start or end
- Action or result
- Decision: the path depends on the answer
How to get prices for your city
Prices and delivery on Kaspi depend on the city. The same product costs different amounts in two cities, and the seller list differs too — not every shop delivers everywhere. That's why the module has a “City ID (code, name)” field on the “Additional” tab.
The field is empty by default. Empty doesn't mean "any city" — it means a specific one: the app uses code 750000000. If your customers are in another city, prices in Elbuz will consistently differ from what you see in your browser — and the heavier the product, the bigger the gap.
The most common reason for "the app shows a different price than the site" is exactly an empty city. Before checking selectors and proxies, compare one product page: open the product on kaspi.kz in your city and compare it with what came in. A difference of a few percent with the same seller means it's the city.
1
City ID (code, name)2
Delivery cost3
Max. number of pages from category- City ID (code, name) — empty means city code 750000000, not any city.
- Delivery cost — your own value added to the price so offers compare fairly.
- Max. number of pages from category — 0 means no limit.
Next to it is the “Delivery cost” field. There's no point filling it in for Kaspi: the module doesn't read this value, and it isn't added to the price.
How to collect prices from every seller of a product
Kaspi works like a storefront with many different shops behind it. Open a product page, and below it is a table of offers: who sells it, for how much, and how many days delivery takes. That's the table the module collects.
For each offer, Elbuz gets the price, the seller name and the delivery time. The seller's rating doesn't always come through: offers read from the table on the page have none. The app also builds two links per seller — to its Kaspi page and its reviews page — so you can check a shop in one click.
Collected offers go to the “Seller list” tab of the settings window. It's more than a reference list: the price list product gets the lowest seller price, with that shop's name next to it. So after a run, the regular price list product list shows what the product costs on Kaspi right now and from whom.
Offers are collected in two ways, and the app picks the one that works. First it reads the seller table from the page. If the table doesn't load, it takes the internal product number from the markup and requests offers from the marketplace directly, up to 60 sellers per product. Nothing to configure: the second way turns on automatically.
How to filter out unwanted sellers and what happens if you clean up the list
The “Seller list” tab isn't just a list: it has checkboxes, and they — not the delete button — control whose price goes to the product. The checkboxes survive runs: the app never cleans the seller list, it only adds new sellers and recalculates the “Total products” column.
- “Blacklist” — at the end of each run, all of this shop's offers are deleted from the price list before the app picks the lowest price. The shop stays in the list but no longer affects the price.
- “Whitelist” — if at least one shop is checked, at the end of the run the offers of all the others are deleted. This is stricter than it looks: one checkbox cuts off the whole market except the checked shops.
- “Price source” — offers aren't deleted, but the lowest price for the product row is picked only among the checked shops. The product's average and maximum prices are still calculated from all remaining offers.
The delete button on this tab does something else and doesn't wait for a run: together with the shop row, it deletes all of its offers for all products in this price list. The price list products stay, but their price is already calculated and won't recalculate by itself — it keeps the deleted seller's value until the next run.
And the next run adds the shop back as soon as it shows up on Kaspi — with empty checkboxes, since they disappeared along with the row. So for permanent filtering use “Blacklist”, not deletion.
- Start or end
- Action or result
- Decision: the path depends on the answer
What comes from Kaspi and where it goes next
Fast mode: a category price list without opening product pages
The “Additional” tab has a “Load products and prices without opening the product page” checkbox. For the Kaspi module it's on by default, and this matters because the mode changes both speed and what data you get.
With the checkbox on, the app reads the category page and takes a ready list: name, price, product address, category path, seller SKU and one photo. Product pages aren't opened. One request instead of a hundred — a large category is many times faster, and the marketplace is much less likely to start refusing.
The trade-off for speed is the data. Without opening the product page, nothing that lives only there comes in: specifications, description, the other photos and — most importantly — the seller table. So the very price you usually do all this for will be just one in fast mode: the one shown in the category list.
Hence a simple rule. To track prices across a wide range — leave the checkbox on. To see every seller of a specific product or to fill in catalog product cards — clear the checkbox and give product addresses on the “List of links” tab.
What comes from a product page
When product pages are opened, each one yields: name, price, category path from the breadcrumbs, photos (duplicates by address are filtered out) and specifications. The module doesn't collect reviews or videos at all — it has no parsing for them, and no checkbox changes that. Specifications aren't fetched in a separate pass: they come only together with the product page.
The category path isn't a separate hand-maintained list: it's a field in the product row, and the price list category tree is built from these values. Category matching is tied to the category name, so a category renamed on Kaspi comes in as a new one, and you'll have to match it again.
The app deliberately skips product pages with variants. On Kaspi, that's a wrapper page with different items at different prices behind it, and taking one price from it would mean recording something untrue. Such addresses simply produce no row — they won't be in the results, and it isn't a crawl error.
Where the collected data goes next
A run ends at the price list rows. Nothing from Kaspi gets into your catalog product cards by itself, let alone the storefront: a run's final operations touch only the price list tables.
- Match the price list products to base catalog products. Until a price list row is linked to a catalog product, there's nothing to update.
- Run the base catalog update — the “Updating base catalog” window, “Update” button. This step moves the price and other fields from the price list to the product card.
The second step happens on its own if “Update catalog after import” is on: after all price lists are imported on schedule or with the button that runs all price lists, and if parsing is still running — once no unfinished tasks are left in the log. Running a single source with the “Start download” button doesn't trigger this chain.
Kaspi as a description source for your catalog
When searching for product descriptions, Kaspi looks up a product by name through a service address of the marketplace that returns results directly as data. The workflow is the same as for other sources — see Content search for products.
What a repeat run overwrites
On the “Additional” tab, in the “Data processing” group, there's a “Delete products before loading” checkbox. For the Kaspi module it's on, and that's the main thing to know before a second run.
1
Delete products before loading2
Load products and prices without opening the product page3
How the server fetches this site- Delete products before loading — enabled, so a repeat run starts by deleting all price list products.
- Load products and prices without opening the product page — product pages are not opened, so no sellers or attributes.
- How the server fetches this site — the mode affects the cost of a page request.
Checkbox on. The run starts with deletion: all products, their specifications, photos, collected seller offers and the price list category tree disappear from the price list. Then the price list is filled again with what Kaspi returns now. There's no "find the same product and update its price" step — each parsed product page becomes a separate new row.
So an edit made by hand in a price list row — a corrected name, your own price, a filled-in field — disappears along with the row after a repeat run.
Checkbox cleared. Old data stays in place. Before the run, the app writes the addresses of all existing price list products to the parsing log as already processed and doesn't request those addresses from Kaspi at all: only what wasn't in the price list yet comes in.
Your edits in old rows survive — but prices in those rows won't be updated from Kaspi anymore either, because the app doesn't open those product pages.
One field is updated in both modes — the price. At the end of every run, the app sets each price list product to the lowest of its sellers' prices, with the name of the shop offering it next to it, and does this for all price list products that have collected offers, not just the newly loaded ones.
So a price entered by hand lasts only until the end of the next run. In fast mode (without opening product pages) there are no seller offers at all, so this overwrite doesn't happen either.
When a product or seller disappears from Kaspi
- The product is no longer on the marketplace, checkbox on. The row just doesn't come back: it was deleted at the start, and no new one was created. No "gone" mark, no zeroed price — the row itself is missing. While the run is in progress, the page that didn't open and the number of attempts on it are visible in the “Parsing log”, but once the run finishes, this source's log is cleared — no trace is left.
- The product is gone, checkbox cleared. The row stays as it was: old price, old date. The app doesn't visit it, so from the row alone you can't tell "product gone" from "product unchanged".
- A seller withdrew its offer. In a run with the checkbox on, its offer simply doesn't come in, and the product price is recalculated from the remaining shops: if the cheapest one left, the product price jumps to the next lowest. The shop row on the “Seller list” tab stays put — a run doesn't clean this list. A shop that's no longer on the marketplace stays in the list with zero in the “Total products” column.
How a run works and what to do after it breaks off
A run takes place in the “Import data from the site” window. The “Start download”, “Continue”, “Pause” and “Cancel” buttons work the same as for the universal parser: how “Continue” differs from “Start download”.
- Start or end
- Action or result
- Decision: the path depends on the answer
A break-off — you closed the tab, the network dropped, the marketplace returned a stub page — doesn't spoil the run. Each parsed product is written to the database separately as its page arrives, so the price list keeps exactly what made it in.
Unfinished tasks stay in the parsing log as not done, and the background job that resumes parsing finds price lists with such tasks and completes them. A task with no response for more than 35 seconds goes back to the queue.
So after a break-off, click “Continue”, not “Start download”: the latter deletes what's collected and starts over. Duplicates aren't a risk: a task for the same address isn't created twice, and at the end of the run the app deletes duplicate rows — by identical product address and by matching SKU, name and address.
Final operations — picking the lowest seller price, deleting duplicates, markup, rebuilding the flat price list table — run once, when the task queue is empty. While anything is left in the queue, price list rows hold the prices that came from the product page or the category page, not the lowest of the seller offers.
Limits of a single run
- A Kaspi category page holds 12 products. The app takes the product count in the category from the page, divides it by 12 and creates a task for every page.
- Seller offers — up to 60 per product, in one request. A second batch isn't requested.
- A page with the marketplace's stub — 3 attempts. After the third, the task is closed as not done. Batches, retries of regular pages and timeouts are the same as for the universal parser: run limits.
- One call makes no more than 15 rounds through the task queue, then the background job takes over. The overall time limit per run is 72 hours.
The module has no cap on the number of products: it takes as many items as there are in the categories from the “List of links”.
You can close the log window: pages are downloaded by the Elbuz server, not your browser, and closing the window doesn't stop the run. This holds as long as server-side parsing is connected to the account; without it, pages are downloaded by the Chrome extension, and the window must stay open.
How to stop runs: disable or delete the source
Turning off the activity switch in the source header removes the source from shared runs and summary calculations; products, the “Seller list”, the “List of links” and settings stay. Deletion is irreversible: along with the source, its settings, rules, markups, list of links, “Seller list” and all collected products disappear. More: How to temporarily disable or delete a source.
Turning off activity doesn't stop the schedule. The schedule task lives separately (the “Schedule setting” button on the “Additional” tab) and has its own “Active” checkbox. While it's on, the source keeps updating on schedule even if the price list is inactive. To stop runs, turn off “Active” in the schedule task or delete it.
What a run costs and where to see spending
The billing unit is one page request. A category page, a product page and a seller offers request are three different requests, and each is counted separately. A product taken from a category page in fast mode doesn't cost a separate request: in this mode one request returns a whole page of items.
The cost of a request depends on how the server loads the site. The mode is set on the “Additional” tab, field “How the server fetches this site”; Kaspi uses “Through a proxy (regular server mode)”. The run log in the “Import data from the site” window shows it too — “Page loading mode: server proxy” — so there's no guessing.
- “Directly, without a proxy” — not billed at all.
- “Through a proxy (regular server mode)” — billed per request. With a fixed monthly price, this mode is included in it until the monthly request quota is used up.
- “Through a protection-bypass service” — paid separately on any plan, from the first request.
Spending isn't deducted instantly: each request becomes a row in the spending queue, and a separate platform background job totals the rows and deducts the sum in one go. The total is in the “Balance and pricing” window, broken down by month and operation type.
If money runs out mid-run, the behavior differs. In regular server mode there's no balance check before the run: the run goes on, and spending is deducted later.
In protection-bypass mode there is a check — before each batch, the app compares the balance with the price of one request and, if it's not enough, stops and writes to the log: “Premium parsing (anti-bot bypass) stopped: insufficient balance. Top up your balance to continue.” The tasks stay in the queue — after you top up, “Continue” completes them.
Scenarios
Track prices across a whole Kaspi category
Setup. On the “List of links” tab — catalog category addresses, with “This is a link to a product” cleared. On the “Additional” tab, “Load products and prices without opening the product page” stays on — that's the Kaspi module's default.
What you get. The app takes the product count from the category page, divides it by 12 and goes through the category pages up to the last one. From each page, the price list gets the name, the price from the category list, the product address, the category path, the Kaspi product code and one photo.
What you don't get. Product pages aren't opened, so there are no specifications, description, other photos or seller offers. No new shops are added to the “Seller list”, and the price in the row is the one shown in the category list: the app has nothing to pick the lowest seller price from.
See every seller of a specific product
Setup. On the “Additional” tab, clear “Load products and prices without opening the product page” and enter your code in “City ID (code, name)”. On the “List of links” tab, add product page addresses with “This is a link to a product” checked. Category addresses work too — the app takes product links from them and opens each.
What you get. The app adds the city code to every Kaspi page address and to the offers request. The product page yields name, price, categories, photos and specifications; seller offers — price, shop, delivery time — go to the “Seller list”. At the end of the run, the product row gets the lowest offer price and that shop's name.
What you don't get. Pages with variants are skipped and produce no row. When there's no seller table on the page and the app requests offers separately, no more than 60 offers per product come in — it doesn't ask for a second batch.
Calculate the price only from shops you trust
Setup. On the “Seller list” tab, check the columns: “Blacklist” — for shops whose prices you don't need; “Whitelist” — if the price should come only from a few specific shops; “Price source” — if the other shops' offers should stay in the price list, but the lowest price should be picked only among the checked ones.
What you get. At the end of the next run, offers from “Blacklist” shops are deleted; if any shop is in “Whitelist”, all other offers are deleted. Then the app picks the lowest price — among “Price source” shops if there are any, otherwise among all remaining — and writes it to the product row with the shop name.
What you don't get. The price in already collected rows doesn't change from the checkbox alone: seller checkboxes take effect only in a run's final operations.
Add new products to the price list without losing manual edits
Setup. On the “Additional” tab, in the “Data processing” group, clear “Delete products before loading”. “Load products and prices without opening the product page” is cleared as well, and the “List of links” has categories or product pages that include new products.
What you get. Before the run, the app writes the addresses of all existing price list products to the parsing log as already processed, and tasks for these addresses aren't created again. Only product pages that weren't in the price list yet are opened, and they come in as new rows. Old rows with your edits stay.
What you don't get. Specifications, photos and names in old rows aren't updated from Kaspi — the app doesn't open their product pages. The exception is the price: at the end of the run, every product with collected seller offers gets the lowest of them, so a manual price in such a row won't hold.
What to do when prices or products are wrong
| What you see | Why | What to do |
|---|---|---|
| Prices differ from those on the site | No city is set — the app uses code 750000000 |
Enter your code in the “City ID (code, name)” field on the “Additional” tab and run again |
| No sellers, just one price | “Load products and prices without opening the product page” is on — the seller table lives only on the product page | Clear the checkbox on the “Additional” tab |
| No specifications or description | Same reason: product pages weren't opened | Clear the same checkbox |
| A sign-up prompt comes in instead of pages | The marketplace decided it's not a human and showed a stub page; the app recognizes such a page and doesn't parse it as a product | Reduce the load: spread runs out over time |
| Some products are skipped | These are pages with variants — they're skipped on purpose | Nothing; if you need specific variants, add their addresses to the “List of links” tab with “This is a link to a product” checked |
| I changed settings — and they changed for another source | Module settings are shared by all sources that use it | Create a separate source on the universal parser if you need different settings |
| After a repeat run, my edits in price list rows are gone | For the Kaspi module, “Delete products before loading” is on, and a run starts by deleting all price list products | Clear the checkbox on the “Additional” tab — then old rows aren't touched, but they aren't updated either (repeat run) |
| The price in a price list row isn't the one I entered by hand | At the end of every run, the product price becomes the lowest of its sellers' prices | Nothing; a manual price here lasts only until the end of the next run |
| The run broke off midway | The tab was closed, the network dropped, or the marketplace returned a stub page | Click “Continue”, not “Start download”: the latter deletes what's collected and starts over (run and break-off) |
| The price list has prices, but base catalog product cards have old ones | A run ends at the price list rows and writes nothing to the catalog | Match the products and run the base catalog update |
| I disabled the source, but it still updates | The price list's activity and the schedule task's activity are different switches | Turn off “Active” in the schedule task itself (how to stop runs) |
FAQ
Does the parser change my prices on Kaspi itself?
No. It collects data; it doesn't manage your shop on the marketplace.
Where do I get the city code?
It's Kaspi's own internal city code. An empty field means code 750000000. Check the code by comparing the price of one product page with kaspi.kz while your city is selected in the top corner of the site.
How many sellers are collected per product?
When offers are requested directly from the marketplace, they come in a batch of up to 60 per product. That many shops on one product page is rare.
Why is collection slow?
Each product page is a separate request to someone else's site. If you only need prices, turn on “Load products and prices without opening the product page”: one request returns a whole category page.
Can prices update automatically?
Yes. The “Additional” tab has a schedule setup button — the source will update by itself, without an open window.
Can I close the window while the import is running?
Yes, if server-side parsing is connected to the account: closing the window doesn't stop the run. Without it, pages are downloaded by the Chrome extension, and the window must stay open.
Will I get a Telegram notification when collection from Kaspi finishes?
There's no separate notification for a single source. The “Products imported from all price lists” event covers the whole price list queue, and server-side parsing may still be running at that moment (Notifications).
Where it is and who has access
There is no separate “Kaspi” window in the menu. The module is a source type in the price list list, and all its settings open from there.
- Menu
- Directories → Processing price lists → List of price lists
- Create
- connection wizard → “From where” step → “Ready-made parsers” block → “Kaspi” tile → “Next”
- Configure
- source row in the list → “Settings” button in the right panel header
- Access right
- the “Price lists” window (in the menu — “List of price lists”)
- Prepare
- Kaspi category or product page addresses and your city code
1
Ready-made parsers2
Kaspi tile3
Next- Ready-made parsers — marketplaces whose parsing rules are built in, no selectors to write.
- Kaspi — the tile that starts collecting marketplace seller prices.
- Next — for a ready-made module it only links the source and opens the settings; nothing is fetched yet.
Don't confuse this with importing orders from Kaspi.kz: there you connect your own seller account with a token and pull your own orders. Here you connect nothing — the module reads the marketplace's public pages the way any shopper sees them. The two connections live separately and don't interfere with each other.
Kaspi sits in the “Ready-made parsers” block — modules for marketplaces we support ourselves. You don't write any selectors: the rules for parsing Kaspi pages are built into the app and updated along with it.
That's why this source's settings window has only three tabs — “List of links”, “Seller list” and “Additional”. The “Import settings” and “Testing” tabs used to configure the universal aren't here at all.
1
List of links2
Seller list3
Additional- List of links — the category or product addresses where the crawl starts.
- Seller list — prices of the shops that sell the product on the marketplace.
- Additional — city, limits and schedule.
Related topics
- If you need the general mechanics of crawling, scheduling and the log — Site parsing.
- If you need to pull your own orders from your seller account — Importing orders from Kaspi.kz via API.
- If you track prices on a Ukrainian price comparison site — Hotline.ua parser.
- If you have several sources and need to see who's cheaper — Source analytics.
- If you want to see what happened to a price from run to run — Product price history.
