# Conrad Electronic Scraper (`crawlerbros/conrad-electronic-scraper`) Actor

Scrape Conrad Electronic (conrad.com) - Europe's largest electronics, tools and industrial-supplies marketplace. Search by keyword, browse by category, or fetch by product ID. Get live prices, stock availability, technical specifications, images, and brand data.

- **URL**: https://apify.com/crawlerbros/conrad-electronic-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Conrad Electronic Scraper

Scrape **Conrad Electronic** (conrad.com) — one of Europe's largest online marketplaces for electronics, tools, computing, home & industrial supplies, with over a million products from thousands of brands. Search by keyword, browse a category, fetch specific products by ID, or list the full category tree to discover category IDs. Get live prices, stock availability, delivery estimates, technical specifications, images, and brand data. HTTP-only via conrad.com's own public storefront API. No login, no cookies, no proxy required.

### What this actor does

- **Four modes:** `search`, `byCategory`, `byProductIds`, `listCategories`
- **Live pricing:** current gross price, currency, and special-offer flag for every product
- **Live availability:** in-stock status, stock quantity, and delivery-date estimate
- **Filters:** brand, product type, merchandising flag (new/discounted/refurbished/green/top seller/education), price range, in-stock only, sort order — brand and product type are matched case-insensitively
- **Rich specs:** technical attributes (RAM, CPU, dimensions, etc.), feature bullets, and images
- **Empty fields are omitted**

### Output per product

- `productId`, `ean`, `manufacturerId` — manufacturer's own model/part number
- `title`, `shortDescription`, `description` (`byProductIds` mode)
- `modelName` — short model/product-line name (e.g. "Lenovo ThinkPad X280"), distinct from the longer marketing `title` (`byProductIds` mode)
- `brand`, `brandLogoUrl`
- `categoryName` (`byProductIds` mode)
- `imageUrl`, `imageUrls[]` (`byProductIds` mode)
- `features[]` — spec bullet points
- `technicalDetails[]` — `{label, values[]}` structured attributes (RAM, CPU, screen size, etc.); `byProductIds` mode returns Conrad's full detail spec sheet (typically 10-45 attributes), `search`/`byCategory` mode returns the smaller subset attached to search results
- `facts[]` — extra callouts (`byProductIds` mode)
- `heightMm`, `lengthMm`, `widthMm`, `weightGrams` — packaged product dimensions (`byProductIds` mode)
- `accessoryCount` — number of listed compatible accessories (`byProductIds` mode)
- `accessoryProductIds[]` — Conrad product IDs of compatible accessories; pass into `mode=byProductIds` to fetch their full records (`byProductIds` mode)
- `alternativeProductIds[]` — Conrad product IDs of alternative, equivalent, exclusive-line, and successor products; pass into `mode=byProductIds` to fetch their full records (`byProductIds` mode)
- `variantProducts[]` — `{productId, variantLabel, productUrl}` sibling colour/size/model variants of this product (e.g. the same case in "Black" vs. "Red, White"); pass `productId` into `mode=byProductIds` for any specific variant's full record (`byProductIds` mode)
- `energyEfficiencyClass`, `energyLabelImageUrl`, `energyDatasheetUrl` — EU energy label data, when the product category requires one (e.g. appliances)
- `price`, `currency`, `isSpecialOffer`
- `originalPrice`, `discountPercentage` — struck-through "was" price and % off, when the current offer is discounted
- `minimumOrderQuantity` — set when a product is only orderable in bulk; `price` then reflects that seller's per-unit pricing tier
- `inStock`, `stockQuantity`, `availabilityState`, `deliveryEstimateDate`
- `sellerName`
- `flags[]` — merchandising tags (e.g. refurbished offer)
- `isRefurbished`
- `numberOfReviews`, `ratingPercentage` (`byProductIds` mode, when reviews exist)
- `isBuyable`
- `isHazardous` — true for GHS/CLP-regulated chemicals & goods (solvents, cleaners, batteries, etc.)
- `hazardStatements[]`, `hazardSymbolUrls[]` — GHS H-statement text and hazard-pictogram images, when `isHazardous` (`byProductIds` mode)
- `datasheetUrl`, `safetyManualUrl` — technical datasheet / user & safety instructions PDF, English preferred (`byProductIds` mode)
- `unitOfSale` — how the product is sold (`piece`, `pack`, `metre`, etc.)
- `complianceBadges[]` — `{name, description, imageUrl}` compliance/sustainability badges Conrad displays (e.g. "RoHS compliant", "Plastic-free packaging", extended-warranty badges); `description` only in `byProductIds` mode
- `productUrl` — canonical conrad.com product page
- `recordType: "product"`, `scrapedAt`

### Output per category (`listCategories` mode)

- `categoryId` — pass directly into `categoryId` (mode=byCategory/search)
- `categoryName`, `breadcrumb` — full path from a top-level category down to this one
- `level` — depth in the tree (0 = top-level)
- `parentCategoryId` — the immediate parent's `categoryId`, when it's itself a usable filter value
- `productCount` — total products in this category and all its subcategories
- `hasSubcategories` — `true` if deeper categories exist below the requested `categoryDepth`
- `categoryImageUrl`
- `recordType: "category"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `byCategory` / `byProductIds` / `listCategories` |
| `searchQuery` | string | `laptop` | Free-text keyword (mode=search). Optional if `brand`/`productType`/`flagFilter`/`categoryId` is set instead, to browse without a keyword; mode=byCategory, optional narrowing |
| `categoryId` | string | – | Conrad category ID (mode=byCategory, required; mode=search, optional narrowing) |
| `categoryDepth` | int | `3` | How many tree levels to walk (mode=listCategories): `2` / `3` / `4` |
| `productIds` | array | – | Product IDs to fetch directly (mode=byProductIds, required) |
| `brand` | string | – | Exact brand name filter, case-insensitive |
| `productType` | string | – | Conrad product-type filter, e.g. `Laptop bag`. Case-insensitive. |
| `flagFilter` | string | – | Merchandising flag: `newProduct` / `priceReduced` / `refurbished` / `greenProduct` / `topSeller` / `education` |
| `sortBy` | string | `relevance` | `relevance` / `priceLowToHigh` / `priceHighToLow` |
| `minPrice` | number | – | Drop products cheaper than this (EUR, decimals allowed, e.g. `9.99`) |
| `maxPrice` | number | – | Drop products more expensive than this (EUR, decimals allowed, e.g. `49.99`) |
| `inStockOnly` | bool | `false` | Only return immediately-shippable products |
| `maxItems` | int | `25` | Hard cap (1–500) |

#### Example: keyword search with brand + price filter

```json
{
  "mode": "search",
  "searchQuery": "laptop",
  "brand": "Lenovo",
  "minPrice": 200,
  "maxPrice": 600,
  "sortBy": "priceLowToHigh",
  "maxItems": 30
}
```

#### Example: only new, in-stock laptop bags under €50

```json
{
  "mode": "search",
  "searchQuery": "laptop",
  "productType": "Laptop bag",
  "flagFilter": "newProduct",
  "maxPrice": 50,
  "inStockOnly": true,
  "maxItems": 20
}
```

#### Example: browse everything from a brand, no keyword needed

```json
{
  "mode": "search",
  "brand": "Lenovo",
  "sortBy": "priceLowToHigh",
  "maxItems": 30
}
```

#### Example: browse a category, in-stock only

```json
{
  "mode": "byCategory",
  "categoryId": "0413029",
  "inStockOnly": true,
  "maxItems": 50
}
```

#### Example: discover category IDs to browse

```json
{
  "mode": "listCategories",
  "categoryDepth": 3,
  "maxItems": 100
}
```

#### Example: lookup specific products by ID

```json
{
  "mode": "byProductIds",
  "productIds": ["3779675", "3595997", "3531804"]
}
```

### Use cases

- **Price monitoring** — track live prices and special-offer flags for electronics/tools
- **Stock alerts** — poll `inStock` / `deliveryEstimateDate` for products you're waiting on
- **Market research** — compare brand assortment and pricing across categories
- **Product data enrichment** — pull structured technical specs into your own catalog
- **Comparison shopping** — build price-comparison tools using `productUrl` + `price`
- **Category analytics** — browse an entire category to gauge assortment breadth

### FAQ

**What is Conrad Electronic?** A pan-European online and retail marketplace for electronics, tools, computing, and industrial supplies, operating since 1923. The `conrad.com` storefront serves an English-language, EUR-priced international catalog. See [conrad.com](https://www.conrad.com).

**Is this affiliated with Conrad Electronic?** No — this is an independent, third-party actor built on conrad.com's public storefront data, not an official Conrad product.

**Where do I find a `categoryId`?** Run `mode=listCategories` — it returns Conrad's full category tree (name, breadcrumb, product count) with a ready-to-use `categoryId` for each entry. Alternatively, run `search` mode first and inspect a matching product, or browse conrad.com and note the numeric ID at the end of a category page's URL.

**Why do some products lack `description` or `categoryName`?** Those fields come from the full product-detail lookup, which only runs in `byProductIds` mode (keeps `search`/`byCategory` fast for bulk browsing). Pass the `productId` from a search result into `byProductIds` to get the full detail record.

**Is `title` ever truncated?** No — Conrad's own product-detail API caps very long product names at 120 characters server-side (mid-word, e.g. "...Intel UHD Graph"). `byProductIds` mode automatically detects this and recovers the untruncated title from Conrad's search index, so `title` is always the full name.

**What is `isHazardous` / `hazardStatements`?** Some electronics-adjacent chemicals (solvents, contact cleaners, battery acid, etc.) carry EU GHS/CLP hazard classifications. When present, `isHazardous` is `true` and `hazardStatements`/`hazardSymbolUrls` (from `byProductIds` mode) list the official H-statement warnings and pictogram images Conrad publishes for that product. Most products are not hazardous, so these fields are simply omitted for them.

**Why is `price` sometimes missing?** A tiny fraction of listings have no active seller offer at query time (e.g. end-of-life items); the record is still emitted with the rest of its fields, just without `price`/`inStock`.

**What does `minimumOrderQuantity` mean?** Some bulk electronics components (resistors, capacitors, etc.) are only sold in multiples of a minimum quantity. When present, `price` reflects that seller's per-unit price at their lowest order tier rather than a single-unit price.

**Where do I find valid `productType` values?** Run `search`/`byCategory` first without `productType` set, then use the product-type wording that shows up in results (e.g. `Laptop bag`, `USB-C® docking station`) — it's Conrad's own product-type taxonomy and varies per category.

**Is there a rate limit?** No documented hard cap for normal usage. The actor uses small delays between requests and batches price lookups to stay well within polite-use limits.

**What are `complianceBadges`?** Conrad displays badges on some product pages for things like RoHS compliance, plastic-free packaging, or an extended manufacturer's warranty. When present, `complianceBadges[]` lists each badge's name (and, in `byProductIds` mode, its full description) plus the badge icon URL. Most products carry no badges, so the field is omitted for them.

**Are prices in EUR?** Yes — conrad.com's international storefront prices in EUR (gross, VAT-inclusive where applicable) regardless of your location.

**Why does the product page URL sometimes take a moment to load in automated tools?** conrad.com's product pages sit behind standard browser-bot protection; they load normally in any real browser. The underlying product data (price, stock, specs, images) comes from conrad.com's storefront API directly and is unaffected.

**How fresh is the data?** Live — every run queries conrad.com's storefront API directly, so prices and stock levels reflect the current moment.

**What are `originalPrice` / `discountPercentage`?** When a product's current offer is on a price reduction, Conrad shows a struck-through "was" price next to the current one; `originalPrice` is that struck-through price and `discountPercentage` the percentage off. Both are omitted for products currently at full price.

**How do I chain accessories, alternatives, or variants into a second run?** In `byProductIds` mode, `accessoryProductIds`/`alternativeProductIds` list Conrad's own cross-sell product IDs for that item, and `variantProducts[]` lists its colour/size/model sibling products (e.g. the same case in different colours), when it has any. Feed the IDs straight into a follow-up `mode=byProductIds` run's `productIds` field to fetch their full records too.

**How do I know if there are more matching products than I fetched?** When a `search`/`byCategory` run stops because it hit `maxItems` while more matches remained upstream, the run's status message reports how many were fetched out of the total available (e.g. "Fetched 25 of 1552 total matching products") — raise `maxItems` and re-run to get more.

# Actor input Schema

## `mode` (type: `string`):

What to fetch.

## `searchQuery` (type: `string`):

Free-text keyword search (mode=search). Optional if `brand`, `productType`, `flagFilter`, or `categoryId` is set instead — lets you browse e.g. "everything from brand X" without a keyword. Also narrows results within a category (mode=byCategory, optional).

## `categoryId` (type: `string`):

Conrad category ID to browse (mode=byCategory, required). Find one from a product's category breadcrumb, from a `mode=listCategories` run's `categoryId` field, e.g. `0413029` (Laptop Bags), `2705040` (Notebooks), `0413040` (Laptop Care). Also narrows a keyword search (mode=search, optional).

## `categoryDepth` (type: `integer`):

How many levels deep to walk Conrad's category tree, starting from the 12 top-level categories. 2 = top-level + their direct children (~130 categories). 3 = one level deeper (~1,000 categories). 4 = deepest practical level (~5,000 categories).

## `productIds` (type: `array`):

Conrad product IDs to fetch directly, e.g. `3779675`. Find these in a product's URL (`conrad.com/en/p/<slug>-<id>.html`) or in `search` mode output (`productId` field).

## `brand` (type: `string`):

Only return products from this brand (exact name, e.g. `Lenovo`, `Hama`, `Renkforce`). Case-insensitive.

## `productType` (type: `string`):

Only return products of this product type, e.g. `Laptop bag`, `USB-C® docking station`, `Laptop battery`. Case-insensitive. Find valid values via a broader `search`/`byCategory` run first — this narrows to Conrad's own product-type facet for the current query/category.

## `flagFilter` (type: `string`):

Only return products carrying this Conrad merchandising tag.

## `sortBy` (type: `string`):

How to order results (mode=search / byCategory).

## `minPrice` (type: `number`):

Drop products cheaper than this (gross price, EUR). Decimals allowed, e.g. 9.99.

## `maxPrice` (type: `number`):

Drop products more expensive than this (gross price, EUR). Decimals allowed, e.g. 49.99.

## `inStockOnly` (type: `boolean`):

Only return products that are immediately available to ship.

## `maxItems` (type: `integer`):

Hard cap on emitted records.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "laptop",
  "categoryDepth": 3,
  "productIds": [],
  "flagFilter": "",
  "sortBy": "relevance",
  "inStockOnly": false,
  "maxItems": 25
}
```

# Actor output Schema

## `products` (type: `string`):

Dataset containing all scraped Conrad Electronic products.

# 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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "mode": "search",
    "searchQuery": "laptop",
    "categoryDepth": 3,
    "productIds": [],
    "flagFilter": "",
    "sortBy": "relevance",
    "inStockOnly": false,
    "maxItems": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/conrad-electronic-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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "mode": "search",
    "searchQuery": "laptop",
    "categoryDepth": 3,
    "productIds": [],
    "flagFilter": "",
    "sortBy": "relevance",
    "inStockOnly": False,
    "maxItems": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/conrad-electronic-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "search",
  "searchQuery": "laptop",
  "categoryDepth": 3,
  "productIds": [],
  "flagFilter": "",
  "sortBy": "relevance",
  "inStockOnly": false,
  "maxItems": 25
}' |
apify call crawlerbros/conrad-electronic-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,crawlerbros/conrad-electronic-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/OA7lzmAfK0dKGZfXO/builds/xxqACoOBMp30gZwFw/openapi.json