# Hoogvliet Category Scraper (`incognito_mode/hoogvliet-category-scraper`) Actor Scrape Hoogvliet's full category tree (hoogvliet.com): every category and subcategory with name, hierarchical URI, parent and level. Clean JSON/CSV, ideal as input for the Hoogvliet product scraper. Needs a Dutch (NL) proxy. Failed lookups are never billed. - **URL**: https://apify.com/incognito\_mode/hoogvliet-category-scraper.md - **Developed by:** [Elena Vance](https://apify.com/incognito_mode) (community) - **Categories:** E-commerce, Developer tools, Integrations - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $5.00 / 1,000 category results This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event ## What's an Apify Actor? Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases. In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours, and optionally produces a well-defined JSON output, datasets with results, or files in key-value store. In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server. Actors are written with capital "A". ## How to integrate an Actor? If asked about integration, you help developers integrate Actors into their projects. You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready. The best way to integrate Actors is as follows. In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md): ```bash npm install apify-client ``` In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md): ```bash pip install apify-client ``` In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md): ````bash # MacOS / Linux curl -fsSL https://apify.com/install-cli.sh | bash # Windows irm https://apify.com/install-cli.ps1 | iex ```bash In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md). If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md). For usage examples, see the [API](#api) section below. For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt). # README ## Hoogvliet Category Scraper — Map the Full Hoogvliet.com Category Tree **Discover Hoogvliet's entire category structure (hoogvliet.com) as clean, structured JSON or CSV: every category and subcategory with its name, the link you need to address it, its parent category, its depth in the tree, and a flag telling you whether it holds products — one tidy record per category node.** This is the map of the store, not the products on the shelves. The output is the ideal input for the **Hoogvliet Product Scraper**: pipe the category links straight in and let it pull the products. Use it on its own to analyze site structure, or as the first step of a two-stage pipeline. No login, no HTML wrangling — and **you are never billed for failed requests**. > **Good to know:** this Actor runs through a **Dutch residential proxy** — > already pre-selected in the input, just keep it enabled. --- ### Why this Actor - **The whole tree in one run.** Every node Hoogvliet exposes — top-level departments down to the deepest subcategories — flattened into one record per category. No clicking through menus. - **The exact link you need to fetch products.** Bare category ids simply 404. Each record carries the working `uri` — the single thing the product scraper needs to read a category's products. - **Know which categories actually hold products.** Every record has a `hasOnlineProducts` flag, so you can feed the product scraper only the leaves that carry products instead of crawling the whole tree blindly. - **Reconstruct the hierarchy.** `parentId` and `level` let you rebuild the tree exactly — breadcrumbs, navigation, a category picker, or a coverage report. - **The perfect companion to the product scraper.** Run this once to get the map, then drive the **Hoogvliet Product Scraper** with the links — or schedule it to catch new categories as Hoogvliet adds them. - **You never pay for failures.** Timeouts and other transient errors are reported in the run summary — **not** written to your dataset and **not billed**. - **Fast and browserless.** No headless browser — so a full run finishes in seconds and compute stays minimal. --- ### Problems this Actor solves | If you are… | Your problem | How this Actor solves it | |---|---|---| | **Running the Hoogvliet product scraper** | You need the category links to scrape, and bare ids don't work | One run hands you every category's working link — paste them straight into the product scraper | | **Building a price/assortment pipeline** | You want to scrape only product-bearing categories, not the whole tree | Filter on `hasOnlineProducts` and feed just the leaves downstream | | **A market researcher / analyst** | Understanding how a competitor organizes its assortment is manual and partial | A complete, dated map of the category hierarchy — export to pandas, Sheets, or BI | | **Maintaining a category mapping** | Hoogvliet adds, renames, and reshuffles categories over time | Schedule a run and diff the tree to catch structural changes automatically | | **An app / chatbot / agent developer** | You need Hoogvliet's navigation structure without building a crawler | Pay per category record on demand; a stable, normalized schema you can rely on | --- ### What data you get Each category node becomes one dataset record: | Field | Description | |---|---| | `id` / `externalId` | Hoogvliet's category id (the record's unique id) | | `name` | Category display name (e.g. *Zuivel, eieren, boter*) | | `uri` | **The full category link** — required to address the category; bare ids 404 | | `parentId` | The id of the parent category (`null` for top-level nodes) — rebuild the tree from this | | `level` | Depth in the tree (0 = top level, increasing downward) | | `hasOnlineProducts` | `true` when the category carries products (the leaves to feed the product scraper) | | `hasOnlineSubCategories` | `true` when the category has child categories | | `categoryUrl` | The full URL for the category node | | `source` | Constant tag identifying the producing Actor | | `scrapedAt` | ISO 8601 timestamp of the run | | `rawData` | *Optional:* the raw category fields, when **Include raw category payload** is on | #### Example output ```jsonc { "id": "100495", "externalId": "100495", "name": "Verse zuivel", "uri": "org-webshop-Site/-/categories/schappen/100/100495", "parentId": "100", "level": 1, "hasOnlineProducts": true, // a leaf — feed this link to the product scraper "hasOnlineSubCategories": false, "categoryUrl": "https://www.hoogvliet.com/...&/categories/schappen/100/100495", "source": "hoogvliet-category-scraper", "scrapedAt": "2026-06-18T08:30:00+00:00" } ```` Categories or subtrees that could not be fetched are **not** written to the dataset (and never billed). They are listed in the run's `SUMMARY` record in the key-value store — `{ "failures": [ { "input": "…", "source": "hoogvliet-category-scraper", "error": "…" } ] }` — and the run's status message tells you at a glance how many categories were mapped. *** ### How to use it (60 seconds) 1. Click **Try for free / Start**. 2. Choose what to map: - **The whole tree (default):** leave **Category URIs** empty to emit every category in the entire tree. - **A subtree:** add one full category URI per line under **Category URIs** (e.g. `org-webshop-Site/-/categories/schappen/100`) to emit only those categories and everything beneath them. 3. Keep the **Dutch residential proxy** enabled (required — see above). 4. Click **Save & Start**. Download results as **JSON, CSV, Excel, or via API** from the **Dataset** tab; check **Key-value store → SUMMARY** for run totals and any failed requests. 5. **Next step:** copy the `uri` values (filter on `hasOnlineProducts` if you only want product-bearing ones) and paste them into the **Hoogvliet Product Scraper**. *** ### Input reference | Field | Type | Default | Description | |---|---|---|---| | **Category URIs** | list | *(empty)* | One full category URI per line to emit only those categories and everything beneath them. Empty = emit the entire tree. **Bare category ids do not work — use the full URI.** | | **Include raw category payload** | boolean | `false` | Adds the raw category fields under `rawData`. Leave off unless you need them. | | **Proxy configuration** | object | Apify Residential, **NL** | Required — keep the Dutch residential default unless you route NL traffic another way. | | **Max concurrency** | integer | `5` | Parallel requests (1–20). Kept moderate to be respectful. | | **Delay between requests** | integer | `0` | Politeness delay in seconds before each request (0–10). ~0.15s is recommended; 0 is fine at moderate concurrency. | | **Max items** | integer | `0` | Stop after N category records (`0` = unlimited / the whole tree). | *** ### Pricing — what a run costs This Actor uses transparent **pay-per-event** pricing with a built-in **volume discount**: a small Actor-start fee, a fixed price per category record for the first results of a run, and a cheaper rate for every result beyond a high threshold. **No subscription, no minimums, and failures are never charged.** The exact per-result rate is shown on the Actor's **Pricing** tab. - **A category map is small and cheap.** Hoogvliet's whole tree is a few hundred categories, so a full run is a tiny, predictable cost — and it is the input that unlocks the much larger product scrape. - **Failed requests are free.** Timeouts and other transient errors are reported in the summary, never billed. - **Bigger runs cost less per item.** The volume-discount tier resets per run (though most category runs stay well under it). - **Try it free:** an Apify free account includes **$5 of monthly platform credit** — more than enough to map the tree before paying anything. - **Stay in control:** set **Max items** and Apify's **maximum charge per run**; the Actor stops gracefully at your cap, keeping everything already scraped. *** ### Compared to the alternatives | | **This Actor** | Build your own crawler | Click through the site by hand | |---|---|---|---| | Full category tree, normalized | Yes | You maintain it | Impractical | | Working full links (not 404-ing ids) | Yes | You build and maintain it | – | | `hasOnlineProducts` / `parentId` / `level` | Yes | You maintain it | – | | Dutch residential proxy built in | Yes | You source proxies | – | | Feeds the product scraper directly | Yes | DIY glue | Copy-paste | | Never billed for failures | Yes | – | – | | Export JSON / CSV / Excel / API | Yes, built-in | DIY | Copy-paste | | Setup time | ~60 seconds | Days; breaks when the site changes | Hours | *** ### Integrate the data - **Feed the Hoogvliet Product Scraper (the main use case).** Run this Actor, take the `uri` field from each record (optionally filter on `hasOnlineProducts == true` to scrape only product-bearing categories), and pass those URIs as the category input to the **Hoogvliet Product Scraper**. That two- stage pipeline — map the tree, then scrape the products — is exactly what these two Actors are designed for. - **Exports:** JSON, CSV, Excel, XML from the Dataset tab — or fetch programmatically: ``` GET https://api.apify.com/v2/datasets/{datasetId}/items?format=json ``` - **Run on a schedule:** use Apify **Schedules** to refresh the category map periodically, and **webhooks** to push finished runs into your pipeline (or to trigger the product scraper automatically). - **From code:** call the Actor with the [Apify API or SDKs](https://docs.apify.com/api) (Python / JavaScript) and read the dataset when the run finishes. - **Run summary:** every run writes a `SUMMARY` record (key-value store) with totals, successes, failures, and billing counts — ideal for monitoring automated pipelines. *** ### FAQ **Is this the product scraper?** No — this Actor maps the **category tree** (one record per category). To get the products themselves, use its companion, the **Hoogvliet Product Scraper**, and feed it the category URIs this Actor produces. **Do I need a Hoogvliet account or API key?** No. There is no login. **Why is a Dutch proxy required?** The Actor ships with a Dutch residential proxy pre-selected; keep it on. Without it, requests are blocked and the run returns no categories (the block is reported in `SUMMARY`). **Why can't I just use a category id?** Bare category ids return 404. That is exactly why this Actor exists — it captures the working `uri` for every category so you don't have to. **What does `hasOnlineProducts` mean?** It is `true` when the category actually holds products. Filter on it to feed the product scraper only the leaves that have something to scrape. **Does the output include every category or only the ones with products?** Every node in the tree — including parent/department categories that hold only subcategories. The `hasOnlineProducts` and `hasOnlineSubCategories` flags let you filter to whatever you need. **How fresh is the data?** Each run fetches the live tree, so you get exactly Hoogvliet's current category structure. Schedule the Actor to catch new or renamed categories. **What formats can I export?** JSON, CSV, Excel, XML — from the Console or via the Apify API. *** ### Related Actors - **Hoogvliet Product Scraper — its companion (run this one first).** This Category Scraper is stage one of a two-stage pipeline: run it to map the tree, then feed the `uri` of each category (filter on `hasOnlineProducts == true` to scrape only product-bearing leaves) into the **Hoogvliet Product Scraper** to pull the actual products, prices, and promotions. Map the store, then scrape the shelves. - **The wider Dutch supermarket family.** Product scrapers for every major Dutch chain — **Albert Heijn**, **Lidl**, **Plus**, **Dirk van den Broek**, and **DekaMarkt** Product Scrapers — plus the **Lidl Category Scraper**, the other category-tree mapper (same map-then-scrape pairing as Hoogvliet's two Actors). - **Same clean schema and pay-per-event billing across every Dutch chain** — mix and match for full market coverage, and you are never billed for failures on any of them. *** ### Disclaimer This Actor is intended for personal and research use. You are responsible for ensuring your use complies with Hoogvliet's terms and applicable law. Please scrape responsibly — keep concurrency moderate and delays reasonable. This project is not affiliated with, endorsed by, or sponsored by Hoogvliet. # Actor input Schema ## `categoryUris` (type: `array`): One full category URI per line to emit only those categories and everything beneath them (e.g. 'org-webshop-Site/-/categories/schappen/100'). Leave empty to emit the entire category tree. Bare category ids do NOT work — use the full URI. ## `includeRawData` (type: `boolean`): Adds the raw discovered category fields to each record under 'rawData'. Leave off unless you need them. ## `proxyConfiguration` (type: `object`): A Dutch RESIDENTIAL proxy is required. The default selects Apify Residential proxy in NL — keep it unless you route NL traffic another way. ## `maxConcurrency` (type: `integer`): Maximum number of parallel requests. Keep this moderate to stay respectful. ## `requestDelaySecs` (type: `integer`): Politeness delay applied before each request. A small delay (~0.15s) is recommended; 0 is fine at moderate concurrency. ## `maxItems` (type: `integer`): Stop after producing this many category records. Set to 0 for no limit (the whole tree). ## Actor input object example ```json { "categoryUris": [ "org-webshop-Site/-/categories/schappen/100" ], "includeRawData": false, "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ], "apifyProxyCountry": "NL" }, "maxConcurrency": 5, "requestDelaySecs": 0, "maxItems": 0 } ``` # Actor output Schema ## `categories` (type: `string`): All scraped category records (one item per category). ## `summary` (type: `string`): JSON summary of the run: totals, successes, failures, and billing counts. # API You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup. ## JavaScript example ```javascript import { ApifyClient } from 'apify-client'; // Initialize the ApifyClient with your Apify API token // Replace the '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "categoryUris": [], "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ], "apifyProxyCountry": "NL" } }; // Run the Actor and wait for it to finish const run = await client.actor("incognito_mode/hoogvliet-category-scraper").call(input); // Fetch and print Actor results from the run's dataset (if any) console.log('Results from dataset'); console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`); const { items } = await client.dataset(run.defaultDatasetId).listItems(); items.forEach((item) => { console.dir(item); }); // 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs ``` ## Python example ```python from apify_client import ApifyClient # Initialize the ApifyClient with your Apify API token # Replace '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "categoryUris": [], "proxyConfiguration": { "useApifyProxy": True, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "NL", }, } # Run the Actor and wait for it to finish run = client.actor("incognito_mode/hoogvliet-category-scraper").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"]) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item) # 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{ "categoryUris": [], "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ], "apifyProxyCountry": "NL" } }' | apify call incognito_mode/hoogvliet-category-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=incognito_mode/hoogvliet-category-scraper", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "Hoogvliet Category Scraper", "description": "Scrape Hoogvliet's full category tree (hoogvliet.com): every category and subcategory with name, hierarchical URI, parent and level. Clean JSON/CSV, ideal as input for the Hoogvliet product scraper. Needs a Dutch (NL) proxy. Failed lookups are never billed.", "version": "0.1", "x-build-id": "2KKHfamvy7300FU7r" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/incognito_mode~hoogvliet-category-scraper/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-incognito_mode-hoogvliet-category-scraper", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } }, "/acts/incognito_mode~hoogvliet-category-scraper/runs": { "post": { "operationId": "runs-sync-incognito_mode-hoogvliet-category-scraper", "x-openai-isConsequential": false, "summary": "Executes an Actor and returns information about the initiated run in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK", "content": { "application/json": { "schema": { "$ref": "#/components/schemas/runsResponseSchema" } } } } } } }, "/acts/incognito_mode~hoogvliet-category-scraper/run-sync": { "post": { "operationId": "run-sync-incognito_mode-hoogvliet-category-scraper", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } } }, "components": { "schemas": { "inputSchema": { "type": "object", "properties": { "categoryUris": { "title": "Category URIs (optional)", "type": "array", "description": "One full category URI per line to emit only those categories and everything beneath them (e.g. 'org-webshop-Site/-/categories/schappen/100'). Leave empty to emit the entire category tree. Bare category ids do NOT work — use the full URI.", "items": { "type": "string" } }, "includeRawData": { "title": "Include raw category payload", "type": "boolean", "description": "Adds the raw discovered category fields to each record under 'rawData'. Leave off unless you need them.", "default": false }, "proxyConfiguration": { "title": "Proxy configuration", "type": "object", "description": "A Dutch RESIDENTIAL proxy is required. The default selects Apify Residential proxy in NL — keep it unless you route NL traffic another way.", "default": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ], "apifyProxyCountry": "NL" } }, "maxConcurrency": { "title": "Max concurrency", "minimum": 1, "maximum": 20, "type": "integer", "description": "Maximum number of parallel requests. Keep this moderate to stay respectful.", "default": 5 }, "requestDelaySecs": { "title": "Delay between requests (seconds)", "minimum": 0, "maximum": 10, "type": "integer", "description": "Politeness delay applied before each request. A small delay (~0.15s) is recommended; 0 is fine at moderate concurrency.", "default": 0 }, "maxItems": { "title": "Max items", "minimum": 0, "type": "integer", "description": "Stop after producing this many category records. Set to 0 for no limit (the whole tree).", "default": 0 } } }, "runsResponseSchema": { "type": "object", "properties": { "data": { "type": "object", "properties": { "id": { "type": "string" }, "actId": { "type": "string" }, "userId": { "type": "string" }, "startedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "finishedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "status": { "type": "string", "example": "READY" }, "meta": { "type": "object", "properties": { "origin": { "type": "string", "example": "API" }, "userAgent": { "type": "string" } } }, "stats": { "type": "object", "properties": { "inputBodyLen": { "type": "integer", "example": 2000 }, "rebootCount": { "type": "integer", "example": 0 }, "restartCount": { "type": "integer", "example": 0 }, "resurrectCount": { "type": "integer", "example": 0 }, "computeUnits": { "type": "integer", "example": 0 } } }, "options": { "type": "object", "properties": { "build": { "type": "string", "example": "latest" }, "timeoutSecs": { "type": "integer", "example": 300 }, "memoryMbytes": { "type": "integer", "example": 1024 }, "diskMbytes": { "type": "integer", "example": 2048 } } }, "buildId": { "type": "string" }, "defaultKeyValueStoreId": { "type": "string" }, "defaultDatasetId": { "type": "string" }, "defaultRequestQueueId": { "type": "string" }, "buildNumber": { "type": "string", "example": "1.0.0" }, "containerUrl": { "type": "string" }, "usage": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "integer", "example": 1 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } }, "usageTotalUsd": { "type": "number", "example": 0.00005 }, "usageUsd": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "number", "example": 0.00005 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } } } } } } } } } ```