# Pepper Scraper (`trev0n/pepper-scraper`) Actor

Extract deal data from Pepper.pl, most popular deal-sharing platform. Get comprehensive information including prices, discounts, deal temperatures (vote scores), merchant details, user comments, and timestamps.

- **URL**: https://apify.com/trev0n/pepper-scraper.md
- **Developed by:** [Paweł](https://apify.com/trev0n) (community)
- **Categories:** E-commerce, Automation, Lead generation
- **Stats:** 3 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$15.00/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

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

## Pepper.pl Deals Scraper

An Apify Actor for scraping deal data from Pepper.pl - Poland's largest deal-sharing community. Extract comprehensive deal information including prices, discounts, temperatures, merchants, and user data.

### Features

- **Rich Deal Data** - Complete deal information including prices, discounts, temperatures, and descriptions
- **GraphQL API** - Uses Pepper's GraphQL API for fast and reliable data extraction
- **Smart Filtering** - Filter deals by minimum temperature to get only hot deals
- **Category Support** - Scrape all deals, hot deals, or new deals
- **Search Support** - Search for specific deals using keywords
- **Pagination** - Automatically handles pagination across multiple pages
- **Real-Time Data** - Get current prices, temperatures, and deal status

### Input Configuration

The actor accepts the following input parameters:

| Parameter | Type | Description | Required | Default |
|-----------|------|-------------|----------|---------|
| `maxPages` | Integer | Maximum number of pages to scrape | No | 10 |
| `category` | String | Category to scrape: "all", "hot", or "new" | No | "all" |
| `minTemperature` | Integer | Minimum deal temperature to include | No | 0 |
| `searchQuery` | String | Search query to filter deals | No | "" |

#### Example Input - Basic Scraping

```json
{
  "maxPages": 5,
  "category": "hot",
  "minTemperature": 100
}
````

#### Example Input - Search for Specific Deals

```json
{
  "searchQuery": "PlayStation",
  "maxPages": 3,
  "minTemperature": 50
}
```

#### Example Input - New Deals Only

```json
{
  "category": "new",
  "maxPages": 10,
  "minTemperature": 0
}
```

### Output Format

Each deal contains comprehensive data:

```json
{
  "dealId": "1172441",
  "dealType": "Deal",
  "dealTitle": "Klocki F1 Mercedes",
  "slug": "klocki-f1-mercedes",
  "dealDescription": "Sam zamówiłem i mega zajawka, więc na święta jak znalazł",
  "url": "https://www.pepper.pl/promocje/klocki-f1-mercedes-1172441",

  "price": 141.44,
  "displayPrice": "141,44zł",
  "originalPrice": 173.78,
  "discountPercent": 19,

  "temperature": 250,
  "temperatureLevel": "Hot2",
  "commentCount": 15,
  "shareCount": 3,

  "publishedAt": "2025-12-01T12:11:54.000Z",
  "createdAt": "2025-12-01T12:11:53.000Z",
  "updatedAt": "2025-12-01T12:11:53.000Z",

  "isExpired": false,
  "isLocal": false,
  "isHot": true,
  "isNew": false,
  "isPinned": false,

  "merchant": {
    "id": "435",
    "name": "AliExpress",
    "urlName": "aliexpress.com"
  },

  "postedBy": "Kredka53",
  "groupIds": ["132", "109"],

  "imageUrl": "https://static.pepper.pl/threads/raw/dlK6a/re/730x575/qt/60/1172441_1.jpg",

  "shipping": {
    "isFree": true,
    "price": 0
  },

  "scrapedAt": "2025-12-01T12:13:47.828Z"
}
```

### Output Fields Reference

#### Basic Deal Information

- `dealId` - Unique deal ID (threadId)
- `dealType` - Always "Deal"
- `dealTitle` - Deal title
- `slug` - URL-friendly title slug
- `dealDescription` - Deal description (HTML stripped)
- `url` - Direct link to the deal page

#### Pricing

- `price` - Current/deal price
- `displayPrice` - Formatted price with currency
- `originalPrice` - Original price before discount
- `displayOriginalPrice` - Formatted original price
- `discount` - Discount amount
- `discountPercent` - Discount percentage

#### Popularity & Engagement

- `temperature` - Deal temperature (vote score)
- `temperatureLevel` - Temperature tier (Hot1, Hot2, Hot3, etc.)
- `commentCount` - Number of comments
- `shareCount` - Number of shares

#### Timestamps

- `publishedAt` - When the deal was published (ISO 8601)
- `createdAt` - When the deal was created (ISO 8601)
- `updatedAt` - When the deal was last updated (ISO 8601)

#### Status Flags

- `isExpired` - Whether the deal has expired
- `isLocal` - Whether it's a local/in-store deal
- `isHot` - Whether the deal is currently hot
- `isNew` - Whether the deal is new
- `isPinned` - Whether the deal is pinned
- `expirable` - Whether the deal can expire
- `nsfw` - Whether the deal is marked NSFW

#### Merchant Information

- `merchant.id` - Merchant ID
- `merchant.name` - Merchant name (e.g., "Amazon", "Allegro")
- `merchant.urlName` - Merchant URL slug

#### User & Categories

- `postedBy` - Username of deal poster
- `groupIds` - Array of category/group IDs

#### Media & Shipping

- `imageUrl` - Deal image URL
- `shipping.isFree` - Whether shipping is free
- `shipping.price` - Shipping cost (if applicable)

#### Metadata

- `scrapedAt` - When the deal was scraped (ISO 8601)

### Use Cases

- **Deal Monitoring** - Track the hottest deals in real-time
- **Price Intelligence** - Monitor prices across multiple merchants
- **Market Research** - Analyze deal trends and popular products
- **Deal Aggregation** - Build deal aggregator services
- **Notifications** - Power deal alert systems
- **Analytics** - Analyze merchant activity and deal patterns

### Categories

| Category | URL | Description |
|----------|-----|-------------|
| `all` | `https://www.pepper.pl` | All deals (homepage) |
| `hot` | `https://www.pepper.pl/promocje` | Hot/trending deals |
| `new` | `https://www.pepper.pl/nowe` | Newest deals |

### Temperature Guide

Pepper.pl uses a temperature system to rank deals:

| Temperature | Meaning |
|-------------|---------|
| < 0° | Cold deal (negative votes) |
| 0° - 100° | Lukewarm deal |
| 100° - 200° | Warm deal |
| 200° - 500° | Hot deal |
| 500°+ | Very hot deal |

### Best Practices

- **Set `minTemperature`** to filter out low-quality deals
- **Use `category: "hot"`** to get only trending deals
- **Limit `maxPages`** to control run time and costs
- **Use search** when looking for specific products or brands

### Technical Details

The scraper uses two data extraction methods:

1. **GraphQL API** (Primary) - Fast and reliable, provides all fields
2. **HTML Parsing** (Fallback) - Used when GraphQL fails, some fields may be empty

When using the fallback HTML parser, the following fields may be empty:

- `publishedAt`, `createdAt`, `updatedAt`
- `groupIds`
- `dealDescription` (partial extraction)

***

### Related Actors

Check out other scrapers from the same developer:

- **[Mohito Scraper](https://apify.com/trev0n/mohito-scraper)** - Scrape product data from Mohito.com fashion store
- **[Sinsay Scraper](https://apify.com/trev0n/sinsay-scraper)** - Fast scraper for Sinsay.com product data
- **[Ceneo Product Scraper](https://apify.com/trev0n/ceneo-scraper)** - Extract product data from Poland's largest price comparison website

***

### Your Feedback

We are always working to improve our scrapers. If you have any technical feedback or found a bug, please create an issue in the repository or contact us through Apify Console.

# Actor input Schema

## `maxPages` (type: `integer`):

Ile stron z ofertami przeskanować (każda strona zawiera ok. 20 ofert)

## `category` (type: `string`):

Która kategoria ofert ma być pobrana

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

Pobieraj tylko oferty z temperaturą wyższą lub równą tej wartości (0 = wszystkie)

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

Opcjonalnie - szukaj ofert zawierających tę frazę

## Actor input object example

```json
{
  "maxPages": 10,
  "category": "all",
  "minTemperature": 0,
  "searchQuery": ""
}
```

# Actor output Schema

## `overview` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("trev0n/pepper-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("trev0n/pepper-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 '{}' |
apify call trev0n/pepper-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pepper Scraper",
        "description": "Extract deal data from Pepper.pl, most popular deal-sharing platform. Get comprehensive information including prices, discounts, deal temperatures (vote scores), merchant details, user comments, and timestamps.",
        "version": "1.0",
        "x-build-id": "tHpZKZIrhQ4BkvHeY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/trev0n~pepper-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-trev0n-pepper-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/trev0n~pepper-scraper/runs": {
            "post": {
                "operationId": "runs-sync-trev0n-pepper-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/trev0n~pepper-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-trev0n-pepper-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": {
                    "maxPages": {
                        "title": "Maksymalna liczba stron",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Ile stron z ofertami przeskanować (każda strona zawiera ok. 20 ofert)",
                        "default": 10
                    },
                    "category": {
                        "title": "Kategoria ofert",
                        "enum": [
                            "all",
                            "hot",
                            "new"
                        ],
                        "type": "string",
                        "description": "Która kategoria ofert ma być pobrana",
                        "default": "all"
                    },
                    "minTemperature": {
                        "title": "Minimalna temperatura",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Pobieraj tylko oferty z temperaturą wyższą lub równą tej wartości (0 = wszystkie)",
                        "default": 0
                    },
                    "searchQuery": {
                        "title": "Fraza wyszukiwania",
                        "type": "string",
                        "description": "Opcjonalnie - szukaj ofert zawierających tę frazę",
                        "default": ""
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
