# Hepsiburada Scraper (`automation-lab/hepsiburada-scraper`) Actor

Search Hepsiburada products and extract current prices, stock, promotions, sellers, ratings, review counts, variants, and product details for marketplace monitoring.

- **URL**: https://apify.com/automation-lab/hepsiburada-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.92 / 1,000 product saveds

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

## Hepsiburada Scraper

Extract public Hepsiburada products for marketplace price and seller monitoring.
Search by keyword or provide a Hepsiburada search, category, or product URL.
The Actor returns structured prices, stock status, promotions, winning sellers,
ratings, review counts, and optional product-page enrichment.

The output is designed for recurring comparisons rather than raw HTML archiving.
Every saved row represents one unique Hepsiburada product variant.

### What can you do with this Hepsiburada scraper?

- Track product prices and stock on a schedule.
- Compare the winning seller across repeated runs.
- Export a product assortment to CSV, Excel, Google Sheets, or a database.
- Find promotions and discounts for a category or search term.
- Enrich known product URLs with barcodes, category paths, images, and seller offers.
- Feed current marketplace records into BI tools or an AI agent.

This Actor covers anonymous public marketplace data only.
It does not access accounts, orders, checkout, private customer information,
or the Hepsiburada seller panel.

### Who is this Actor for?

**E-commerce analysts** can compare current prices and availability.

**Brands and distributors** can monitor how products are represented by sellers.

**Retail operations teams** can schedule recurring runs and detect changed rows.

**Data engineers** can consume typed JSON through the Apify API or webhooks.

**Developers and AI agents** can call a focused Hepsiburada data tool through MCP.

### Why use it?

The Actor accepts both discovery inputs and exact source URLs.
It uses Hepsiburada's anonymous server-rendered product state instead of downloading
images or running a full browser, keeping runs lightweight.

It also:

- validates every URL and rejects non-Hepsiburada domains;
- detects security pages as failures instead of returning misleading empty data;
- stops at `maxItems` across all inputs;
- deduplicates products by SKU;
- retries bounded transient network and server failures;
- charges the product event only for rows accepted for output.

### What data is extracted?

| Field | Meaning |
| --- | --- |
| `productId` | Stable Hepsiburada product-family identifier |
| `sku` | Product variant SKU used for deduplication |
| `listingId` | Winning marketplace listing identifier when available |
| `name` | Public product name |
| `brand` | Brand shown by Hepsiburada |
| `url` | Canonical public product URL |
| `price` | Current price in Turkish lira |
| `originalPrice` | Original/reference price when provided |
| `discountPercent` | Reported discount percentage |
| `inStock` | Current procurable or product-page stock state |
| `sellerName` | Winning seller name |
| `sellerId` | Public marketplace merchant identifier |
| `isMultiSeller` | Whether the product indicates multiple sellers |
| `rating` | Aggregate product rating when available |
| `reviewCount` | Aggregate review count when available |
| `promotions` | Public campaign, tag, or purchase-incentive labels |
| `imageUrl` | Product image URL when detail enrichment is enabled |
| `categoryPath` | Category breadcrumb names from the product page |
| `barcode` | Public product barcode when present |
| `sellerOffers` | Seller, price, stock, and listing IDs from enriched pages |
| `searchQuery` | Query that discovered the product, or `null` for URL input |
| `scrapedAt` | UTC extraction timestamp |

Fields that Hepsiburada does not expose for a particular item are returned as
`null` or an empty array rather than guessed.

### Get started

1. Open the Actor input page.
2. Enter one or more Turkish product terms in **Search queries**, or add URLs.
3. Keep `maxItems` small for your first run.
4. Enable **Enrich product details** only when you need barcodes or seller offers.
5. Click **Start**.
6. Open the default dataset to inspect, download, or integrate the records.

A useful first input is:

```json
{
  "queries": ["airfryer"],
  "maxItems": 5,
  "enrichDetails": false
}
```

### Input parameters

#### `queries`

An array of product-focused search terms.
Examples include `airfryer`, `robot süpürge`, and `oyuncu laptop`.
Queries may be combined with URL inputs.

#### `startUrls`

Public URLs on `hepsiburada.com`.
Supported routes are search pages, category pages, and individual product pages.
Other domains are rejected before any scraping begins.

#### `maxItems`

Maximum unique products saved across all sources.
The allowed range is 1–1,000 and the default is 25.
Pagination stops as soon as this limit is reached.

#### `enrichDetails`

When `false`, the Actor uses fast listing-page records.
When `true`, it opens each product URL and adds barcode, category path, image,
and available seller offers.
Enrichment takes longer because it performs one extra public request per product.

#### `minPrice` and `maxPrice`

Optional inclusive price filters in Turkish lira.
Items without a usable price do not pass an active price filter.

#### `includeOutOfStock`

Keep this enabled to preserve unavailable products in monitoring datasets.
Disable it when only currently procurable products are useful.

### Output example

A current listing-only row has this shape:

```json
{
  "productId": "HBC00002T6UNE",
  "sku": "HBCV00002T6UNF",
  "listingId": "e3cc3eb7-9841-4982-8f8b-bf56ba2baaf8",
  "name": "Schafer Fit Fry XL 5 lt Yağsız Fritöz - Siyah",
  "brand": "Schafer",
  "url": "https://www.hepsiburada.com/schafer-xl-airfryer-sicak-hava-fritozu-siyah-pm-HBC00002T6UNE",
  "price": 3014,
  "originalPrice": 3014,
  "currency": "TRY",
  "discountPercent": 0,
  "inStock": true,
  "sellerName": "Schafer",
  "isMultiSeller": true,
  "rating": 4.7,
  "reviewCount": 68,
  "promotions": [],
  "categoryPath": [],
  "barcode": null,
  "sellerOffers": [],
  "sourceType": "search",
  "searchQuery": "airfryer",
  "scrapedAt": "2026-07-30T05:20:00.000Z"
}
```

Values change with the live marketplace.
Treat the example as a field guide, not a current price quote.

### Search, URL, and enrichment workflows

Use keyword search for assortment discovery and broad price comparisons.
Use a category or search URL when you need Hepsiburada's exact public scope.
Use product URLs for a stable monitoring list.

For repeated monitoring, keep the same input and schedule the Actor daily or weekly.
Compare rows by `sku` and sort snapshots by `scrapedAt`.
A webhook can send each completed dataset to your own pipeline.

### How much does it cost to monitor Hepsiburada products?

Pricing uses one `start` event per run plus one `item` event per product saved.
The start event is **$0.004**.
The current per-product tiers are:

| Tier | Price per saved product |
| --- | ---: |
| FREE | $0.00368 |
| BRONZE | $0.00320 |
| SILVER | $0.002496 |
| GOLD | $0.00192 |
| PLATINUM | $0.00128 |
| DIAMOND | $0.000896 |

At the BRONZE item rate, 25 products cost about **$0.084** including the start event.
At the same rate, 100 products cost about **$0.324** including the start event.
The Apify platform applies the tier associated with the user's plan.
Failed or filtered products do not trigger an item event.

Detail enrichment has no separate event; each accepted product still uses one
`item` event.

### Scheduling a price and seller monitor

1. Save an Actor task with stable queries or product URLs.
2. Enable enrichment if alternate seller offers are required.
3. Create an Apify schedule for the desired interval.
4. Export each dataset or handle the run webhook.
5. Join snapshots by `sku`.
6. Compare `price`, `inStock`, `sellerName`, `promotions`, and `sellerOffers`.

The Actor reports current public state.
It does not maintain historical state or send alerts by itself.

### API usage with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~hepsiburada-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["robot süpürge"],"maxItems":10,"enrichDetails":true}'
```

To wait for results synchronously:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~hepsiburada-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["airfryer"],"maxItems":5}'
```

### API usage with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/hepsiburada-scraper').call({
  queries: ['oyuncu laptop'],
  maxItems: 25,
  enrichDetails: false,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("automation-lab/hepsiburada-scraper").call(run_input={
    "queries": ["kahve makinesi"],
    "maxItems": 25,
    "enrichDetails": True,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use with MCP and AI agents

Add the Actor to Claude Code through Apify MCP:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/hepsiburada-scraper"
```

**Claude Desktop, Cursor, and VS Code setup:**

Desktop and editor clients can use:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/hepsiburada-scraper"
    }
  }
}
```

Example prompts:

- "Search Hepsiburada for 10 robot vacuum products and compare sellers."
- "Extract this Hepsiburada product URL with all available seller offers."
- "Prepare a dataset of current airfryer prices and stock for my weekly monitor."

### Integrations

Default dataset records work with Apify's Google Sheets, Make, Zapier, Slack,
webhook, and cloud-storage integrations.
You can also download JSON, CSV, Excel, XML, or RSS from the dataset page.

For a data warehouse, retain `productId`, `sku`, and `scrapedAt` as snapshot keys.
For alerting, compare the current dataset with your previously stored snapshot.

### Limits

Hepsiburada can change its public page structure or anti-bot controls.
The Actor explicitly fails on a recognized security page instead of silently
returning an empty dataset.
Retry later if the source is temporarily unavailable.

Large enriched runs generate more requests and take longer than listing-only runs.
The Actor caps output at 1,000 products per run and uses conservative sequential
requests to reduce source load.

A search can naturally return no products.
That is different from a challenge page and completes with an empty dataset.

### Legality and responsible use

Use public data lawfully and follow applicable website terms, database rights,
consumer law, and privacy rules.
Do not use this Actor to collect personal data or bypass account controls.
The Actor intentionally excludes accounts, orders, checkout, customer contacts,
and individual review authors.

### Troubleshooting

#### The run says I must provide a query or URL

Add at least one non-empty string to `queries` or one supported Hepsiburada URL
to `startUrls`.

#### A URL is rejected

Only `hepsiburada.com` and its subdomains are accepted.
Copy the full public search, category, or product URL from Hepsiburada.

#### The dataset is empty

Check that the query has live public results and that price/stock filters are not
too restrictive.
The logs distinguish a valid no-result page from a source security challenge.

#### The run is slower with enrichment

That is expected: every accepted listing requires a product-page request.
Disable `enrichDetails` when listing prices, stock, seller, ratings, and review
counts are sufficient.

### Related Automation Lab Actors

- [Trendyol Scraper](https://apify.com/automation-lab/trendyol-scraper) for another Turkish marketplace.
- [Amazon Scraper](https://apify.com/automation-lab/amazon-scraper) for Amazon product research.
- [Dataset Dedup](https://apify.com/automation-lab/dataset-dedup) for cleaning merged snapshot exports.

### FAQ

#### Does this Actor use the Hepsiburada seller API?

No. It reads anonymous public marketplace pages and does not need seller credentials.

#### Can it scrape a specific product?

Yes. Add the public product URL to `startUrls`.
Product URLs are automatically parsed as enriched product records.

#### Can it return every seller?

When Hepsiburada includes alternate listings in the public product state,
`enrichDetails: true` returns them in `sellerOffers`.
Availability can vary by product and marketplace response.

#### Does it monitor changes automatically?

The Actor creates a current snapshot.
Save it as an Apify task and attach a schedule to collect recurring snapshots.
Change detection or alerts belong in your downstream workflow.

#### Are prices always in Turkish lira?

The public Hepsiburada marketplace records handled by this Actor are normalized
with `currency: "TRY"`.

#### Are reviews included?

The default row includes aggregate rating and review count when available.
It does not collect individual review authors or review text.

#### Are filtered products charged?

No. The per-item event is charged only after a unique product passes the active
stock and price filters and is accepted for output.

# Actor input Schema

## `queries` (type: `array`):

Turkish product keywords to search on Hepsiburada. You may combine queries with start URLs.

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

Public Hepsiburada search, category or product URLs. Other domains are rejected.

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

Maximum number of unique product records saved across all inputs.

## `enrichDetails` (type: `boolean`):

Open each product page to add barcode, category path, image and available seller offers. This is slower than listing-only extraction.

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

Only save products priced at or above this amount in Turkish lira.

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

Only save products priced at or below this amount in Turkish lira.

## `includeOutOfStock` (type: `boolean`):

When disabled, only currently procurable or in-stock products are saved.

## Actor input object example

```json
{
  "queries": [
    "airfryer"
  ],
  "maxItems": 20,
  "enrichDetails": false,
  "includeOutOfStock": true
}
```

# Actor output Schema

## `overview` (type: `string`):

Default dataset containing all accepted unique Hepsiburada product records.

# 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 = {
    "queries": [
        "airfryer"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/hepsiburada-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 = {
    "queries": ["airfryer"],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/hepsiburada-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 '{
  "queries": [
    "airfryer"
  ],
  "maxItems": 20
}' |
apify call automation-lab/hepsiburada-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/iNzlVvoYvhwLYw8v9/builds/rDYV6UiCogsHHy92L/openapi.json