# Pepper Deals Scraper (`axiomworks/pepper-deals-scraper`) Actor

Scrape hot and new feeds, keyword searches, category or merchant listings, and individual deal pages from seven Pepper sites. The Actor returns normalized deal records with community scores, voucher details, merchant and category data, comments, images and links.

- **URL**: https://apify.com/axiomworks/pepper-deals-scraper.md
- **Developed by:** [Axiom Works](https://apify.com/axiomworks) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.98 / 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Pepper Deals Scraper

**Returns:** one row per deal or voucher with title, price, originalPrice, temperature, voucherCode, merchantName, category, expiresAt and url.
**Input:** `{"sites": ["dealabs", "mydealz"], "feed": "hot", "maxItems": 50}`
**Best for:** deal monitoring across Pepper sites, voucher code lists, price and discount tracking.

```json
{
  "id": "dealabs-3423782",
  "title": "T-shirt Homme Oversize Decathlon Elementals - S à XL Tissu Extensible, Broderie Orbit, Plusieurs Coloris",
  "price": 9.99,
  "originalPrice": 17.99,
  "currency": "EUR",
  "temperature": 118.66,
  "merchantName": "Decathlon",
  "expiresAt": "2026-11-14T22:59:00.000Z",
  "url": "https://www.dealabs.com/bons-plans/t-shirt-homme-oversize-decathlon-elementals-tissu-extensible-broderie-orbit-plusieurs-coloris-3423782"
}
```

### What does Pepper Deals Scraper do?

Pepper Deals Scraper collects deals from the Pepper network of deal-community sites and returns them in one normalized format. It reads public listing pages and single deal pages, so you get the same fields no matter which country you scrape. Supported sites:

| Site key | Site | Country | Currency |
|---|---|---|---|
| dealabs | Dealabs | France | EUR |
| mydealz | MyDealz | Germany | EUR |
| pepper_pl | Pepper.pl | Poland | PLN |
| pelando | Pelando | Brazil | BRL |
| hotukdeals | hotukdeals | United Kingdom | GBP |
| chollometro | Chollometro | Spain | EUR |
| preisjaeger | Preisjaeger | Austria | EUR |

You can scrape the hottest deals, the newest deals, keyword search results, category or merchant listing pages, or individual deal pages. Every record carries the deal title, its temperature (the community vote score), the price, the voucher code when the site shows one, the merchant, the category, the comment count, an image, the posting date and links. The Actor runs without a login and does not need a browser, so runs are fast and light.

This is an independent tool. It is not affiliated with, endorsed by or connected to any of the sites listed above.

Typical uses:

Use case: Track which deals get hot on a given site and how fast.
Use case: Monitor a keyword such as "lego" or "airpods" across several countries at once.
Use case: Build a feed of new vouchers for a shop or a category.
Use case: Compare how the same product is priced on different national sites.
Use case: Feed deal data into a spreadsheet, a database, a newsletter or an AI agent.

### What data can you get?

Each record is one deal or voucher. Fields that a site does not provide are returned as `null`, so every record has the same keys.

| Field | Type | Description |
|---|---|---|
| id | string | Stable record id, `<platform>-<dealId>` |
| sourceUrl | string | Deal page URL the record came from |
| platform | string | dealabs, mydealz, pepper_pl, pelando, hotukdeals, chollometro or preisjaeger |
| country | string | FR, DE, PL, BR, GB, ES or AT |
| dealId | string | Pepper thread id or Pelando deal UUID |
| title | string | Deal title as posted |
| url | string | Deal page on the community site |
| type | string | `deal` or `voucher` |
| temperature | number | Community vote score in degrees; can be negative |
| isHot | boolean | Pepper hot flag; `null` on Pelando |
| isExpired | boolean | Whether the deal is marked expired |
| status | string | Status text reported by the site |
| price | number | Deal price; `null` for vouchers and freebies |
| originalPrice | number | Next best or previous price when the site shows one |
| discountPercent | number | Discount percentage when shown |
| discountAmount | number | Fixed discount (Pelando) when shown |
| currency | string | EUR, PLN, GBP or BRL |
| shippingPrice | number | Shipping cost when shown |
| freeShipping | boolean | Whether shipping is free |
| voucherCode | string | Promo code shown on the card; `null` when empty or hidden behind a click |
| merchantName | string | Shop name |
| merchantId | string | Shop id on the community site |
| merchantDomain | string | Shop domain |
| category | string | Category name |
| categorySlug | string | Category slug |
| commentCount | integer | Number of comments |
| imageUrl | string | Main image URL |
| postedAt | string | Posting time, ISO 8601 |
| hotAt | string | Time the deal turned hot, when shown |
| authorName | string | Username of the poster (public) |
| dealLink | string | Click-out link to the shop through the community redirect; the Actor never follows it |
| productUrl | string | Merchant product URL (Pelando only) |
| description | string | Deal description, only for single deal page URLs |
| listingUrl | string | The listing, search or API URL the item was read from |
| searchTerm | string | Search term when the item came from a search |
| feed | string | hot, new, search or url |
| scrapedAt | string | Scrape time, ISO 8601 |
| expiresAt | string | Deal end date, ISO 8601, when the poster set one (Pepper sites; `null` on Pelando) |
| startsAt | string | Deal start date, ISO 8601, when set (Pepper sites) |
| isExclusive | boolean | Exclusive flag (Pepper sites) |
| isPinned | boolean | Pinned by moderators (Pepper sites) |
| isTopDeal | boolean | Top deal flag (Pepper sites) |
| isLocal | boolean | Local rather than national deal (Pepper sites) |
| merchantSlug | string | Shop URL name on the community site (Pepper sites) |
| authorId | string | Numeric poster id on the community site (Pepper sites) |

Temperatures are not comparable between the Pepper sites and Pelando, which uses its own scale. Pelando's list data does not include voucher codes, so `voucherCode` is only filled there for single deal pages when the page exposes one. Discussion threads are skipped; only deals and vouchers are returned.

### How to use

1. Open the Actor in Apify Console and go to the Input tab.
2. Pick one or more sites. The default is Dealabs.
3. Choose a feed (hottest or newest), or enter search terms to search each selected site.
4. Alternatively, paste listing URLs or deal URLs into Start URLs.
5. Set Max items and start the run.
6. Open the Output tab to view the table, or export JSON, CSV, Excel or XML.

If you give only Start URLs, exactly those URLs are scraped and the site selection is ignored. If you give search terms as well, the terms are searched on the selected sites in addition to the URLs.

The item limit is shared between all sources. With a limit of 60 and two sources, each source gets about 30 items; if one source has fewer deals than its share, the unused part goes to the sources that follow. The run stops as soon as the limit is reached.

Supported Start URLs:

| Site | URL forms |
|---|---|
| Pepper sites | Hot, new, search, category (group) or merchant listing pages, any page number, and single deal URLs |
| Pelando | The home page or `/mais-quentes` (hot), `/recentes` (new), `/busca/<term>` (search), `/c/<community>` (community feed), `/d/<slug>` (single deal) |

Search terms that find nothing finish the run with zero items and a clear status message instead of failing. A dead URL is logged and skipped. The Actor only fails when the input selects nothing usable, for example an unknown site and no valid URL.

### Input

| Field | Type | Description |
|---|---|---|
| sites | array | Site keys to scrape; default `["dealabs"]` |
| feed | string | `hot` or `new`; default `hot`; ignored when search terms are given |
| searchTerms | array | Keywords to search on every selected site |
| startUrls | array | Listing or deal URLs on the supported sites |
| maxItems | integer | Maximum deals to save in total, 1 to 10000, default 50 |
| maxPagesPerSource | integer | Maximum pages (30 deals each) or Pelando API calls (20 deals each) per source, default 10 |
| hideExpired | boolean | Drop deals marked expired; default false |
| minTemperature | integer | Drop deals colder than this value |
| dealTypes | array | `deal`, `voucher` or both; default both |
| proxyConfiguration | object | Apify Proxy settings; datacenter proxy by default |

Example input:

```json
{
  "sites": ["dealabs", "mydealz", "pepper_pl", "pelando"],
  "searchTerms": ["lego"],
  "maxItems": 80,
  "hideExpired": true,
  "minTemperature": 50
}
```

Example with Start URLs:

```json
{
  "startUrls": [
    "https://www.mydealz.de/hot",
    "https://www.pelando.com.br/c/tech-lover"
  ],
  "maxItems": 60
}
```

### Output

Results are stored in the default dataset. This is a real record from a run on Dealabs:

```json
{
  "id": "dealabs-3423437",
  "sourceUrl": "https://www.dealabs.com/bons-plans/lits-de-camp-pliant-amazon-basics-adultes-2070-cm-x-772-cm-sac-de-transport-noir-3423437",
  "platform": "dealabs",
  "country": "FR",
  "dealId": "3423437",
  "title": "Lits de Camp Pliant Amazon Basics - Adultes, 207.0 cm x 77.2 cm, Sac de transport, Noir",
  "type": "deal",
  "temperature": 101.58,
  "isHot": true,
  "isExpired": false,
  "status": "Activated",
  "price": 31.49,
  "originalPrice": 56.64,
  "currency": "EUR",
  "shippingPrice": 3.99,
  "freeShipping": false,
  "voucherCode": null,
  "merchantName": "Amazon",
  "merchantId": "36",
  "merchantDomain": "www.amazon.fr",
  "category": "Sports & Plein air",
  "categorySlug": "sports-plein-air",
  "commentCount": 6,
  "postedAt": "2026-10-01T17:46:49.000Z",
  "authorName": "Dada42000",
  "expiresAt": "2026-11-14T22:59:00.000Z",
  "isExclusive": false,
  "dealLink": "https://www.dealabs.com/visit/threadmain/3423437",
  "listingUrl": "https://www.dealabs.com/hot",
  "feed": "hot"
}
```

A Pelando record has the same keys. Here `price` is in BRL, `merchantName` and `merchantId` come from the store, `productUrl` holds the shop product URL, and `isHot` is `null`:

```json
{
  "id": "pelando-10e0cccc-3391-4cf7-995a-82b7d6561048",
  "platform": "pelando",
  "country": "BR",
  "title": "LEGO Set Disney Stitch 43249",
  "type": "deal",
  "temperature": 101,
  "isHot": null,
  "status": "active",
  "price": 237,
  "currency": "BRL",
  "merchantName": "Amazon",
  "merchantId": "367",
  "merchantDomain": "amazon.com.br",
  "commentCount": 0,
  "feed": "search",
  "searchTerm": "lego"
}
```

Besides the dataset, each run stores a `RUN_SUMMARY` object in the key-value store. It lists every source with its pages read, items saved, whether the site showed an empty-result page, how many blocked responses were retried and any error. The run's status message names the cause whenever a source returned zero items.

### How much does it cost?

The Actor is charged per result: you pay for each deal saved to the dataset and nothing for pages that return no deals. The exact rate is shown on the Pricing tab of the Actor page in Apify Console. Because the item limit is exact, you can cap spending by setting Max items. Platform usage such as proxy traffic is billed by Apify under your plan.

### Use with AI agents (MCP)

You can call this Actor from an AI agent through the Apify MCP server. Add it to your MCP client configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=axiomworks/pepper-deals-scraper"
    }
  }
}
```

Example prompts:

Prompt: "Find the 20 hottest deals on Dealabs right now and list price, merchant and temperature."

Prompt: "Search MyDealz and Pepper.pl for 'lego' and show deals with a voucher code."

Prompt: "Get the newest deals from hotukdeals, Chollometro and Preisjaeger, 15 each."

Prompt: "Read this Pelando deal page and summarise the offer."

The agent sees the input fields described above, so it can choose sites, a feed, search terms and an item limit by itself.

### Integrations and API

You can start the Actor from code, schedule it, or connect it to other tools through Apify integrations such as webhooks, Make, Zapier, Google Sheets and n8n.

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("axiomworks/pepper-deals-scraper").call(run_input={
    "sites": ["dealabs"],
    "searchTerms": ["airpods"],
    "maxItems": 50,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["price"], item["currency"], item["temperature"])
```

JavaScript:

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('axiomworks/pepper-deals-scraper').call({
    sites: ['mydealz'],
    feed: 'hot',
    maxItems: 30,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
process.stdout.write(`${items.length}\n`);
```

cURL:

```bash
curl -X POST "https://api.apify.com/v2/acts/axiomworks~pepper-deals-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"sites": ["pelando"], "feed": "hot", "maxItems": 40}'
```

### FAQ

**How many deals can I get per run?**
Up to 10,000 in total. Pepper listing pages hold 30 deals and Pelando calls return 20, and Max pages per source limits how deep each source goes. Hot lists reorder while you read them, so the Actor removes duplicates by id.

**Why is `voucherCode` often empty?**
Only some deals have a code, and some codes are hidden behind a click on the site. Hidden codes are returned as `null`.

**Why is `price` empty for some deals?**
Vouchers, freebies and deals without a stated price have no price on the site, so the field is `null`.

**Can I scrape a single category or merchant?**
Yes. Paste the category or merchant listing URL into Start URLs. For Pelando, use a `/c/<community>` URL.

**Which proxy should I use?**
The default Apify datacenter proxy works for these sites. If a site keeps answering with a block page, the Actor retries with a fresh proxy session and then switches that site to residential proxy for the rest of the run.

**Why did my search return zero items?**
The site had no results for that term. Pepper sites show recommended deals on an empty search page, and the Actor detects this and returns nothing rather than unrelated deals.

**Are Pepper.it and other Pepper sites supported?**
Only the seven sites in the table above are supported.

**Does it return personal data?**
Records include the public username of the poster. No other personal data is collected.

### Is it legal to scrape Pepper sites?

The Actor reads only public pages that load without logging in, and it does not bypass logins or CAPTCHAs. Courts in several jurisdictions have treated the collection of public web data as lawful, but the rules depend on your country, on how you use the data and on the terms of each site. Deal titles, images and descriptions may be protected by copyright, and usernames are personal data under laws such as the GDPR. Use the data responsibly, keep request volumes modest, respect the rights of the sites and their users, and get legal advice for commercial or large-scale use.

### Feedback

If a field is missing, a site changes its layout or you need another source, open an issue from the Actor page in Apify Console. Include the input you used and the run ID so the problem can be reproduced.

# Actor input Schema

## `sites` (type: `array`):

Pepper-network sites to scrape: dealabs (FR), mydealz (DE), pepper_pl (PL), pelando (BR), hotukdeals (GB), chollometro (ES), preisjaeger (AT). Used with feed or searchTerms; ignored when only startUrls are given.

## `feed` (type: `string`):

Which listing to read on each selected site: 'hot' (hottest deals) or 'new' (newest deals). Ignored when searchTerms are given.

## `searchTerms` (type: `array`):

Optional keywords to search on every selected site instead of the feed, e.g. 'airpods' or 'lego'. One search per term and site.

## `startUrls` (type: `array`):

Optional Pepper-network listing URLs (hot, new, search, category, merchant, page N) or single deal URLs, e.g. https://www.mydealz.de/hot. Pelando: /mais-quentes, /recentes, /busca/<term>, /c/<community>, /d/<slug>. If set without searchTerms, only these URLs are scraped.

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

Maximum number of deals to save in total, 1-10000, default 50. Split across all sources; the run stops once this many are saved.

## `maxPagesPerSource` (type: `integer`):

Maximum listing pages (30 deals each) or Pelando API calls (20 deals each) read per source, 1-100, default 10.

## `hideExpired` (type: `boolean`):

If true, deals marked expired are dropped. Default false.

## `minTemperature` (type: `integer`):

Optional. Drop deals whose temperature (community vote score) is below this number, e.g. 100. Pelando uses a different scale than Pepper sites.

## `dealTypes` (type: `array`):

Which record types to keep: 'deal' and/or 'voucher'. Default both.

## `proxyConfiguration` (type: `object`):

Apify Proxy settings. Datacenter proxy is the default; a site that keeps blocking requests is switched to residential proxy automatically.

## Actor input object example

```json
{
  "sites": [
    "dealabs"
  ],
  "feed": "hot",
  "searchTerms": [],
  "startUrls": [],
  "maxItems": 20,
  "maxPagesPerSource": 10,
  "hideExpired": false,
  "dealTypes": [
    "deal",
    "voucher"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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 = {
    "sites": [
        "dealabs"
    ],
    "feed": "hot",
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("axiomworks/pepper-deals-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 = {
    "sites": ["dealabs"],
    "feed": "hot",
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("axiomworks/pepper-deals-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 '{
  "sites": [
    "dealabs"
  ],
  "feed": "hot",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call axiomworks/pepper-deals-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,axiomworks/pepper-deals-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/ophcSbxFn40TUXsvs/builds/sKzZ7Z6jqa51wbvri/openapi.json