# Hepsiburada Product Scraper - Turkey Price Data (`midnight_static/hepsiburada-product-scraper`) Actor

Scrape product and price data from Hepsiburada, a Turkish e-commerce marketplace. Give it category URLs; get 31 fields per product: name, SKU, brand, color, TRY price, stock, shipping cost, return window, images, category path and rank. For competitor price monitoring and catalogue tracking.

- **URL**: https://apify.com/midnight\_static/hepsiburada-product-scraper.md
- **Developed by:** [Midnight Static](https://apify.com/midnight_static) (community)
- **Categories:** E-commerce, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.35 / 1,000 products

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

## Hepsiburada Product Scraper

Point it at Hepsiburada category pages, or let it find them itself. Get back every product with its price, brand, stock status, shipping cost, return window and the position it held in the category listing. **31 fields per product**, as JSON, CSV or Excel.

### Three things that are different here

**1. You pay only for records that contain data.**
A page that comes back blocked, failed or empty is written to a free skipped-pages list with the reason, and then dropped. It never reaches your dataset and never reaches your bill.

**2. Every skipped page tells you why it was skipped.**
`ROBOTS_DISALLOW`, `HTTP_403`, `NO_STRUCTURED_DATA`, `NO_PRODUCT_LIST`, `NETWORK_ERROR`. If you hand it 500 categories and get 430 back, the remaining 70 are listed by URL with a reason code, free of charge. You never have to guess what happened to the difference.

**3. It reads the structured data the site publishes for search engines.**
Not a rendered browser, not a private endpoint. Hepsiburada embeds schema.org product data in every category page for Google, and that is what this Actor parses. One page request returned a median of 36 complete products in the measured run, which is why it costs almost nothing to run.

### What you get

**Product**
Name, stock keeping unit, product URL, brand, colour, description, and up to ten image URLs with a count.

**Price and availability**
Price, currency, stock status and item condition, exactly as the merchant publishes them.

**Shipping and returns**
Shipping cost and currency, destination country, return window in days, whether returns are free, and the country the return policy applies to.

**Category context**
Which category the product was listed in, the full breadcrumb path, the position it held in the listing, plus that category's average rating, rating count, lowest and highest price and total offer count. This lets you see not just what a product costs, but where it sits among its competitors.

**Provenance**
`sourceUrl`, `fetchedAt`, `httpStatus` and `filledFieldCount` travel with every record.

### Typical uses

Price monitoring across a competitor's catalogue. Tracking which brands dominate a category and at what price points. Watching stock status on products you resell. Building a price index for a product segment. Checking where your own listing ranks inside a category page.

### Example record (trimmed)

```json
{
  "name": "Philips 7500 Series Azur Steam Iron 3200W",
  "sku": "HBCV00003XBZIS",
  "brand": "Philips",
  "color": "Black",
  "price": 3299,
  "currency": "TRY",
  "availability": "InStock",
  "itemCondition": "NewCondition",
  "shippingCost": 49.99,
  "shippingCurrency": "TRY",
  "returnDays": 14,
  "returnFees": "FreeReturn",
  "imageCount": 4,
  "listPosition": 2,
  "categoryName": "Home Electronics",
  "categoryRatingValue": 4.27,
  "categoryRatingCount": 85409,
  "categoryLowPrice": 2,
  "categoryHighPrice": 8051987.59,
  "categoryOfferCount": 10000,
  "filledFieldCount": 29,
  "httpStatus": 200,
  "fetchedAt": "2026-09-17T09:14:02.118Z",
  "sourceUrl": "https://www.hepsiburada.com/ev-elektronik-urunleri-c-2147483638"
}
```

### Input

Paste category URLs one per line, or leave the field empty and the Actor starts from the homepage and finds categories itself. Paths and full URLs both work.

`maxItems` caps how many products are written so a long run cannot produce an unexpected charge. `maxPages` caps how many pages are fetched. `followSubcategories` turns discovery off when you want only the URLs you listed.

### Failures are loud

The run fails with an explanation rather than finishing quietly with less data than you expected. If the page structure changes, you get a parse error naming the affected pages, not an empty dataset. Counters are reconciled at the end of every run: pages fetched, products written, robots-blocked, HTTP failures, parse failures, empty pages. The full breakdown is written to the `RUN_STATS` key, and every skipped page to `SKIPPED`.

Transient gateway errors are retried up to three times before a page is given up on.

### Limits and compliance

`robots.txt` is checked before every request and a disallowed path is never fetched. If `robots.txt` itself cannot be read, the run stops before making a single data request rather than guessing.

No personal data is collected. The output is built from an explicit list of known fields, so nothing outside that list can reach your dataset. Product listings, prices, shipping terms and return policies are commercial data, not personal data.

Prices change constantly. Every record carries `fetchedAt` so you always know when the figure was true.

### Pricing

**$0.50 per 1,000 products, everything included.** No start fee, no minimum charge per run, and no separate platform usage line on your bill. The number on this page is the number you pay.

Paid Apify plans pay less, automatically — there is nothing to apply for: Bronze $0.45, Silver $0.40, Gold and above $0.35 per 1,000 products. The Free plan price is unchanged at $0.50.

You are charged per record written, and a record is only written when it contains data. Pages skipped by robots.txt, failed after three retries, or carrying no product list are reported in the run statistics and in the free `SKIPPED` list, and cost you nothing.

### Measured performance

Run on 16 September 2026 from Apify's own network, no proxy:

| | |
|---|---|
| Category pages fetched | 400 |
| Pages returning HTTP 200 | 400 |
| Pages blocked | 0 |
| Products extracted | 13,734 |
| Median products per page request | 36 |
| Average response time | 2.3 seconds |
| Categories discovered while crawling | 2,056 |

Four hundred requests over seventeen minutes, not one blocked.

# Actor input Schema

## `categoryUrls` (type: `array`):

Hepsiburada category pages to scrape, one per line. Leave empty to start from the homepage and discover categories automatically. Full URLs and paths both work.

## `followSubcategories` (type: `boolean`):

Follow category links found on each page. Turn this off to scrape only the URLs you listed.

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

Hard cap on how many product records are written, so a long run cannot produce an unexpected charge.

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

Hard cap on how many category pages are fetched.

## `concurrency` (type: `integer`):

How many pages are fetched in parallel. Each page takes about two seconds.

## Actor input object example

```json
{
  "categoryUrls": [
    "https://www.hepsiburada.com/laptop-notebook-dizustu-bilgisayarlar-c-98",
    "https://www.hepsiburada.com/ev-elektronik-urunleri-c-2147483638"
  ],
  "followSubcategories": true,
  "maxItems": 1000,
  "maxPages": 200,
  "concurrency": 5
}
```

# Actor output Schema

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

One record per product: price, brand, stock, shipping, returns and category context.

## `runStats` (type: `string`):

Counters for the run: pages fetched, products written, robots-blocked, HTTP failures, parse failures.

## `skipped` (type: `string`):

Every page that produced no record, with the reason. Free, never charged.

# 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 = {
    "categoryUrls": [
        "https://www.hepsiburada.com/laptop-notebook-dizustu-bilgisayarlar-c-98",
        "https://www.hepsiburada.com/ev-elektronik-urunleri-c-2147483638"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("midnight_static/hepsiburada-product-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 = { "categoryUrls": [
        "https://www.hepsiburada.com/laptop-notebook-dizustu-bilgisayarlar-c-98",
        "https://www.hepsiburada.com/ev-elektronik-urunleri-c-2147483638",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("midnight_static/hepsiburada-product-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 '{
  "categoryUrls": [
    "https://www.hepsiburada.com/laptop-notebook-dizustu-bilgisayarlar-c-98",
    "https://www.hepsiburada.com/ev-elektronik-urunleri-c-2147483638"
  ]
}' |
apify call midnight_static/hepsiburada-product-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,midnight_static/hepsiburada-product-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/Zc7zTus00HB6ODPG4/builds/pmgmWGFvSNEzFBgKL/openapi.json