↑↓ selectEnter openEsc close

    1. Elbuz

    How to collect prices from every Kaspi.kz seller of a product

    25 min readUpdated

    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

    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.

    The first fork is the “This is a link to a product” checkbox; the second is the mode without opening the product page: the “yes” branch ends with rows from the category list and has no sellers. Seller offers come only from the lower part of the diagram, after the product page opens.
    yesnoyesnoyesnoyesnoAddresses from the “List of links”“This is a link to a product”?The product page opensCategory pages of 12 products, atask for each“Load products and prices withoutopening the product page”?Rows from the category list: name,price, one photoProduct page links from thecategory pagePage with variants?The address is skipped, no rowSeller table on the page?Offers go to the “Seller list”Separate offers request, up to 60per product
    • 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.

    Additional tab: city ID and delivery cost fields above the category limits
    1City ID (code, name)
    2Delivery cost
    3Max. number of pages from category
    1. City ID (code, name) — empty means city code 750000000, not any city.
    2. Delivery cost — your own value added to the price so offers compare fairly.
    3. 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.

    The order of a run's final operations: first filtering by “Blacklist” and “Whitelist”, then picking the lowest price. Seller checkboxes take effect here, so changing a checkbox affects the product price only after the next run.
    yesnoyesnoThe task queue is emptyDuplicate rows are deletedNew shops are added to the “Sellerlist”, “Total products” is recalculatedOffers from shops in “Blacklist” aredeletedAny shops in “Whitelist”?Offers from all other shops aredeletedAny shops with “Price source”?Lowest price among the checkedshopsLowest price among all offersThe price and shop name arewritten to the product rowMarkup, price list operations, flattable rebuild
    • 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.

    1. 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.
    2. 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.

    Parsing options: Page loading mode and Data processing groups
    1Delete products before loading
    2Load products and prices without opening the product page
    3How the server fetches this site
    1. Delete products before loading — enabled, so a repeat run starts by deleting all price list products.
    2. Load products and prices without opening the product page — product pages are not opened, so no sellers or attributes.
    3. 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”.

    The “Continue” branch: what's collected stays, unfinished tasks are completed. The “Start download” branch: what happens to products already collected depends on the “Delete products before loading” checkbox.
    “Continue”“Start download”yesnoWhich button was clicked?Unfinished tasks are completed,nothing is deletedThe source's parsing log is cleared“Delete products before loading”?Price list products are deletedExisting product addresses arerecorded as already processedA task for each address from the“List of links”The queue runs in batches of 100addresses, final operations after itempties
    • 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 seeWhyWhat 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
    New supplier source wizard, From where step, with the Kaspi ready-made parser selected
    1Ready-made parsers
    2Kaspi tile
    3Next
    1. Ready-made parsers — marketplaces whose parsing rules are built in, no selectors to write.
    2. Kaspi — the tile that starts collecting marketplace seller prices.
    3. 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.

    Site data import settings window for the new Kaspi source with the tab row
    1List of links
    2Seller list
    3Additional
    1. List of links — the category or product addresses where the crawl starts.
    2. Seller list — prices of the shops that sell the product on the marketplace.
    3. Additional — city, limits and schedule.

    Related topics

    Was this article helpful?

    Missing a feature? Tell us.

    We will add it for free if other users need it too.

    If only you need it, we will agree on it separately.

    Article contents

    Suggest an improvement

    Try Elbuz free