# Redbrain Product Search Scraper (`stealth_mode/redbrain-product-search-scraper`) Actor

Scrape product listings from Redbrain.shop search results in bulk. Capture pricing, availability, merchant info, images, shipping details, and 17+ product fields — ideal for price monitoring, market research, and competitive intelligence.

- **URL**: https://apify.com/stealth\_mode/redbrain-product-search-scraper.md
- **Developed by:** [Stealth mode](https://apify.com/stealth_mode) (community)
- **Categories:** Automation, Developer tools, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

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

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

## Redbrain Product Search Scraper: Extract Product Data from Search Results

---

### What Is Redbrain.shop?

Redbrain.shop is an e-commerce search and aggregation platform that indexes products from multiple merchants and retailers. It provides curated search results for consumers looking to compare prices, availability, and merchant options across a wide product catalog. For businesses, **scraping Redbrain product data** unlocks market insights — tracking competitor pricing, monitoring product availability, analyzing merchant performance, and building product intelligence databases. The **Redbrain Product Search Scraper** automates this process, transforming search result pages into clean, structured datasets.

---

### Overview

The **Redbrain Product Search Scraper** extracts comprehensive product details from Redbrain.shop search result pages. It captures product metadata, pricing, merchant information, and availability in a single structured output. Ideal users include:

- **Price monitoring services** tracking competitive pricing across retailers
- **E-commerce aggregators** building product databases and comparison tools
- **Market researchers** analyzing product trends, merchant performance, and pricing strategies
- **Developers** integrating Redbrain data into affiliate platforms or price alerts
- **Retailers** benchmarking against competitor listings on the platform

The scraper handles multiple search queries, respects pagination, and offers configurable limits for flexible data collection at any scale.

---

### Input Configuration

The scraper accepts a JSON configuration object with three key parameters:

```json
{
  "urls": [
    "https://www.redbrain.shop/search?q=nike%20shoes&locales=en_GB"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 200
}
````

#### Parameter Definitions

| Parameter | Type | Description |
|---|---|---|
| `urls` | Array | Search result page URLs from Redbrain.shop. Format: `https://www.redbrain.shop/search?q=[QUERY]&locales=[LOCALE]`. You can add multiple search URLs in a single run. |
| `ignore_url_failures` | Boolean | If `true`, the scraper continues running even if some URLs fail. If `false`, the entire run stops on first failure. Default: `true`. |
| `max_items_per_url` | Integer | Maximum number of products to extract per URL (1–200). Set to 20 for light runs, 100+ for bulk collection. Default: 20. |

#### Example Usage

```json
{
  "urls": [
    "https://www.redbrain.shop/search?q=nike%20shoes&locales=en_GB",
    "https://www.redbrain.shop/search?q=adidas%20running&locales=en_GB",
    "https://www.redbrain.shop/search?q=puma%20sports&locales=en_US"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 150
}
```

> **Tip:** Use URL encoding for special characters in search queries (e.g., spaces as `%20`). Customize the `locales` parameter for region-specific results.

***

### Output Format

#### Example Output Record

```json
{
  "typename": "Offer",
  "title": "Rat & Boa Green Cobra Skirt Lime Medium Women's 100% Fsc Viscose",
  "gtin": "05060915356949",
  "catalogue_id": "05060915356949",
  "traffic_channel_id": "2dab090926fe4c179f2d25ef3dcdad9d",
  "external_id": "d72b76c61393c99c121682fb70f0485e0c0433a0",
  "condition": null,
  "availability": "IN_STOCK",
  "merchant": {
    "__typename": "Merchant",
    "name": "Rat & Boa",
    "logo": null
  },
  "affiliate": {
    "__typename": "Affiliate",
    "name": "RAKUTEN"
  },
  "pricing": {
    "__typename": "Pricing",
    "price": {
      "__typename": "Money",
      "value": 140,
      "currency": "GBP"
    },
    "onsale_percentage": null
  },
  "images": [
    {
      "__typename": "Image",
      "u_r_l": "https://cdn.shopify.com/s/files/1/0942/9062/products/cobra-skirt-lime-4_dec1c675-d04e-4c77-a88d-81b420f71f26.jpg?v=1693302818"
    }
  ],
  "shipping": {
    "__typename": "Shipping",
    "price": null,
    "label": "DEFAULT_CARRIER",
    "min_days": 1,
    "max_days": 3
  },
  "links": {
    "__typename": "Links",
    "tracking": "https://click.linksynergy.com/link?id=pfxNKSnglIM&offerid=1863225.529446058676572154175410&type=15&murl=https%3A%2F%2Fwww.ratandboa.com%2Fproducts%2Fcobra-skirt-lime%3Fvariant%3D40718594801769"
  },
  "discount": null,
  "tag": {
    "__typename": "Tag",
    "sale_discount": null,
    "watching": null,
    "trending": null,
    "new_in": null,
    "is_demo": null
  },
  "has_price_history": true,
  "from_url": "https://www.redbrain.shop/c/1604/clothing-and-accessories/clothing?locales=en_GB&categoryIds=1604"
}
```

Each product extracted returns a detailed record with 17+ fields:

#### Product Identification

| Field | Description |
|---|---|
| `Typename` | Product category or type (e.g., "Shoe", "Apparel", "Accessory") |
| `Title` | Full product name as displayed on Redbrain |
| `GTIN` | Global Trade Item Number (barcode/UPC code) for product identification |
| `Catalogue ID` | Redbrain's internal product catalogue identifier |
| `External ID` | Merchant-specific product ID or SKU |

#### Merchant & Marketplace Info

| Field | Description |
|---|---|
| `Condition` | Product condition (e.g., New, Used, Refurbished) |
| `Availability` | Stock status (e.g., In Stock, Out of Stock, Pre-order) |
| `Merchant` | Seller or retailer name offering the product |
| `Affiliate` | Whether the listing is affiliate-enabled for commission tracking |

#### Pricing & Offers

| Field | Description |
|---|---|
| `Pricing` | Current price, currency, and price-per-unit metrics |
| `Discount` | Active discount amount or percentage off original price |
| `Has Price History` | Boolean indicating whether historical pricing data is available for trend analysis |

#### Product Media & Details

| Field | Description |
|---|---|
| `Images` | Array of product image URLs (thumbnail, full-size, alternative angles) |
| `Links` | Product page URL, merchant store link, and related product links |
| `Shipping` | Shipping cost, estimated delivery time, and carrier information |
| `Tag` | Product tags, categories, and keyword labels for filtering |

***

### How to Use

1. **Prepare search URLs** — Navigate to Redbrain.shop, perform a search (e.g., "nike shoes"), and copy the full search result URL including the `q` and `locales` parameters.

2. **Build your configuration** — Create a JSON object with:
   - One or more search URLs in the `urls` array
   - `ignore_url_failures` set to `true` for uninterrupted runs
   - `max_items_per_url` set to desired limit (e.g., 100 for standard, 200 for bulk)

3. **Start the scraper** — Paste the configuration and run the actor. Monitor the execution log for progress.

4. **Export results** — Download output as JSON, CSV, or Excel. Results are ready to integrate into databases, spreadsheets, or analytics tools.

**Best practices:**

- Start with small `max_items_per_url` (20–50) to test URL validity
- Use locale filters to scope results by region and language
- For large-scale runs, batch URLs into multiple runs to avoid timeouts
- Export to CSV for quick analysis in Excel; use JSON for integration into applications

**Common issues:**

- URLs must be direct search result pages (not category pages)
- Verify URL encoding if special characters appear broken in results
- Set `ignore_url_failures: true` when running bulk operations

***

### Use Cases & Business Value

- **Price monitoring:** Track competitor pricing in real-time and set up price alert systems
- **Market intelligence:** Analyze product availability, merchant presence, and discount trends
- **SEO & content:** Build product comparison content with Redbrain listings as data source
- **Affiliate marketing:** Identify top-performing products and merchants for promotion
- **Inventory planning:** Monitor stock availability across multiple merchants to optimize purchasing

The scraper delivers actionable product data that would take hours to collect manually, enabling data-driven decisions in hours.

***

### Conclusion

The **Redbrain Product Search Scraper** is a powerful tool for anyone needing structured product data from Redbrain.shop at scale. With 17+ fields covering pricing, availability, merchant info, and product media, it transforms search results into intelligence. Whether you're monitoring prices, building aggregator platforms, or conducting market research, this scraper delivers the data you need — fast and reliably.

# Actor input Schema

## `urls` (type: `array`):

Add the URLs of the product search list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.

## `ignore_url_failures` (type: `boolean`):

If true, the scraper will continue running even if some URLs fail to be scraped.

## `max_items_per_url` (type: `integer`):

The maximum number of items to scrape per URL.

## Actor input object example

```json
{
  "urls": [
    "https://www.redbrain.shop/search?q=nike%20shoes&locales=en_GB"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}
```

# 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 = {
    "urls": [
        "https://www.redbrain.shop/search?q=nike%20shoes&locales=en_GB"
    ],
    "ignore_url_failures": true,
    "max_items_per_url": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("stealth_mode/redbrain-product-search-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 = {
    "urls": ["https://www.redbrain.shop/search?q=nike%20shoes&locales=en_GB"],
    "ignore_url_failures": True,
    "max_items_per_url": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("stealth_mode/redbrain-product-search-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 '{
  "urls": [
    "https://www.redbrain.shop/search?q=nike%20shoes&locales=en_GB"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}' |
apify call stealth_mode/redbrain-product-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=stealth_mode/redbrain-product-search-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Redbrain Product Search Scraper",
        "description": "Scrape product listings from Redbrain.shop search results in bulk. Capture pricing, availability, merchant info, images, shipping details, and 17+ product fields — ideal for price monitoring, market research, and competitive intelligence.",
        "version": "0.0",
        "x-build-id": "URTFvUxkbpuBlf1R6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/stealth_mode~redbrain-product-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-stealth_mode-redbrain-product-search-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/stealth_mode~redbrain-product-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-stealth_mode-redbrain-product-search-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/stealth_mode~redbrain-product-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-stealth_mode-redbrain-product-search-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": {
                    "urls": {
                        "title": "URLs of the product search list urls to scrape",
                        "type": "array",
                        "description": "Add the URLs of the product search list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ignore_url_failures": {
                        "title": "Continue running even if some URLs fail to be scraped",
                        "type": "boolean",
                        "description": "If true, the scraper will continue running even if some URLs fail to be scraped."
                    },
                    "max_items_per_url": {
                        "title": "Max items per URL",
                        "type": "integer",
                        "description": "The maximum number of items to scrape per URL."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
