# Hepsiburada Scraper - Turkish E-Commerce Products (`studio-amba/hepsiburada-scraper`) Actor

Scrape product data from Hepsiburada.com, Turkey's leading e-commerce platform with 100M+ monthly visits. Extract product names, prices, brands, ratings, reviews, seller info, stock status, and images from search results and category pages. No login required.

- **URL**: https://apify.com/studio-amba/hepsiburada-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 50.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

## Hepsiburada Scraper

Scrape product data from Hepsiburada.com — Turkey's leading e-commerce platform with 100M+ monthly visits, selling electronics, fashion, home goods, beauty, sports, and more across thousands of sellers.

### How to scrape Hepsiburada data

Hepsiburada is one of Turkey's top 2 e-commerce platforms (alongside Trendyol), offering millions of products from thousands of sellers. This actor lets you extract structured product data from Hepsiburada search results and category pages without any login or cookies.

1. Go to the actor's input page.
2. Enter a search query in Turkish or English (e.g., "laptop", "iPhone 16", "kulaklık", "ayakkabı").
3. Set the maximum number of results you want.
4. Click "Start" and wait for the run to finish.
5. Download your data in JSON, CSV, or Excel format.

The actor searches Hepsiburada just like a regular user would, extracts product data from search results, and returns clean, structured data ready for analysis.

### Features

- Search by keyword across all Hepsiburada product categories
- Browse specific category pages for targeted scraping
- Extract current prices and original prices (discount detection)
- Get brand names, seller information, and stock status
- Extract ratings and review counts
- Multi-strategy extraction: API interception, JSON-LD, hydration data, and DOM fallback
- Automatic pagination to collect large result sets
- Zero-item safety guard — fails explicitly instead of returning empty results
- No cookies or login required
- Residential proxy support for reliable access with Turkish IP

### Input options

| Field | Type | Description | Default |
|-------|------|-------------|---------|
| `searchQuery` | String | Product search term (e.g., "laptop", "kulaklık") | `"laptop"` |
| `categoryUrl` | String | Optional Hepsiburada category URL to scrape directly | — |
| `maxResults` | Integer | Maximum number of products to return (1–10,000) | `100` |
| `proxyConfiguration` | Object | Proxy settings — Turkish residential proxies recommended | TR residential |

#### Example input

```json
{
    "searchQuery": "laptop",
    "maxResults": 50,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "TR"
    }
}
````

#### Scraping a specific category

You can also scrape a specific Hepsiburada category page by providing the `categoryUrl` instead of a search query:

```json
{
    "categoryUrl": "https://www.hepsiburada.com/laptop-c-98",
    "maxResults": 200
}
```

#### Minimal input (uses defaults)

```json
{}
```

When no input is provided, the actor defaults to searching "laptop" with 100 max results.

### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `productName` | String | Full product name |
| `brand` | String | Brand or manufacturer name |
| `price` | Number | Current selling price in TRY |
| `originalPrice` | Number | Original price before discount (if discounted) |
| `currency` | String | Currency code (TRY) |
| `rating` | Number | Average product rating (0–5 scale) |
| `reviewCount` | Integer | Number of user reviews |
| `seller` | String | Name of the seller or merchant |
| `inStock` | Boolean | Whether the product is currently in stock |
| `imageUrl` | String | Product image URL |
| `url` | String | Full Hepsiburada product page URL |
| `scrapedAt` | String | ISO 8601 timestamp of when the data was collected |

### Example output

```json
{
    "productName": "Apple MacBook Air M4 16 GB 256 GB SSD 13.6\" Notebook",
    "brand": "Apple",
    "price": 42999.00,
    "originalPrice": 49999.00,
    "currency": "TRY",
    "rating": 4.8,
    "reviewCount": 342,
    "seller": "Hepsiburada",
    "inStock": true,
    "imageUrl": "https://productimages.hepsiburada.net/s/123/550/abc.jpg",
    "url": "https://www.hepsiburada.com/apple-macbook-air-m4-p-HBCV00001ABC",
    "scrapedAt": "2026-06-09T14:30:00.000Z"
}
```

### Cost estimate

The actor uses PlaywrightCrawler (headless browser) for reliable rendering of Hepsiburada pages.

- \~50 results: approximately $0.05–0.15 in platform costs
- \~100 results: approximately $0.10–0.30 in platform costs
- \~1,000 results: approximately $0.50–2.00 in platform costs
- Residential proxy usage adds to the cost depending on data transfer

For most use cases, a single run costs well under $1.00.

### How it works

The scraper uses four extraction strategies in priority order:

1. **API interception** — intercepts XHR/fetch responses for internal JSON API data (fastest, most reliable)
2. **JSON-LD structured data** — parses schema.org markup embedded in the page
3. **Hydration data** — extracts product arrays from `__NEXT_DATA__` or similar client-side state
4. **DOM extraction** — falls back to parsing HTML product cards when no structured data is available

This multi-strategy approach makes the scraper resilient to site changes and ensures data quality.

### Limitations

- Hepsiburada uses anti-bot protection — Turkish residential proxies are strongly recommended.
- Product availability and pricing data reflects what Hepsiburada shows at the time of scraping. Prices change frequently.
- Very broad search queries may return many results across categories. Use specific queries or category URLs for focused data.
- The HTML structure of Hepsiburada may change without notice, which could temporarily affect data extraction.
- Some product detail fields (brand, seller, rating) may not be available on all listing cards.

### Tips for best results

- **Use specific queries** — "Samsung Galaxy S25 Ultra" works better than "telefon"
- **Use category URLs** — for comprehensive category scraping, provide the category URL directly
- **Use Turkish proxies** — Turkish residential proxies give the most reliable results
- **Start small** — test with `maxResults: 10` before running large scrapes
- **Turkish keywords** — use Turkish search terms for more relevant results (e.g., "dizüstü bilgisayar" instead of "laptop")

### Use cases

- **Price monitoring** — track product prices across Turkey's largest e-commerce platform
- **Competitive analysis** — compare your prices against Hepsiburada marketplace data
- **Market research** — analyze product availability and pricing trends in the Turkish market
- **Brand monitoring** — track how your brand's products are listed and priced
- **Seller intelligence** — monitor which sellers carry which products
- **Discount tracking** — detect price drops by comparing current vs. original prices
- **Review analysis** — gauge product sentiment from ratings and review counts
- **Data enrichment** — enhance product databases with up-to-date Turkish e-commerce pricing

# Actor input Schema

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

Search term to find products on Hepsiburada (e.g., 'laptop', 'iPhone 16', 'kulaklık'). If empty, defaults to 'laptop'.

## `categoryUrl` (type: `string`):

Optional: a Hepsiburada category page URL to scrape instead of searching. Example: https://www.hepsiburada.com/laptop-c-98

## `maxResults` (type: `integer`):

Maximum number of products to return.

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

Proxy settings. Residential proxies with Turkish IP are recommended for best results.

## Actor input object example

```json
{
  "searchQuery": "laptop",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "TR"
  }
}
```

# 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 = {
    "searchQuery": "laptop",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "TR"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/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 = {
    "searchQuery": "laptop",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "TR",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/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 '{
  "searchQuery": "laptop",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "TR"
  }
}' |
apify call studio-amba/hepsiburada-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hepsiburada Scraper - Turkish E-Commerce Products",
        "description": "Scrape product data from Hepsiburada.com, Turkey's leading e-commerce platform with 100M+ monthly visits. Extract product names, prices, brands, ratings, reviews, seller info, stock status, and images from search results and category pages. No login required.",
        "version": "0.1",
        "x-build-id": "4hGugxvD77Pmj7KHW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~hepsiburada-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-hepsiburada-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/studio-amba~hepsiburada-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-hepsiburada-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/studio-amba~hepsiburada-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-hepsiburada-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": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search term to find products on Hepsiburada (e.g., 'laptop', 'iPhone 16', 'kulaklık'). If empty, defaults to 'laptop'."
                    },
                    "categoryUrl": {
                        "title": "Category URL",
                        "type": "string",
                        "description": "Optional: a Hepsiburada category page URL to scrape instead of searching. Example: https://www.hepsiburada.com/laptop-c-98"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of products to return.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Residential proxies with Turkish IP are recommended for best results."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
