# Trendyol Scraper | Prices, All Sellers, Reviews & Monitor (`atesen-software/trendyol-scraper`) Actor

Trendyol scraper for TRY prices with cart discounts, every seller offer (buy-box), stock, variants and reviews. Paste any category, brand, store, search or product URL. Changes-only mode makes it a daily price and stock monitor. Pay per result.

- **URL**: https://apify.com/atesen-software/trendyol-scraper.md
- **Developed by:** [Atesen Software](https://apify.com/atesen-software) (community)
- **Categories:** E-commerce, Marketing, Automation
- **Stats:** 11 total users, 8 monthly users, 73.3% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 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.

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

## Trendyol Scraper: Prices, Sellers, Stock & Reviews (TRY)

Scrape **Trendyol product prices, seller offers, stock and reviews** from any category, brand, store, search or product URL, and get clean JSON, CSV or Excel. No login and no coding.
Turn on **changes-only mode**, put the Actor on a schedule, and receive a daily feed of new, re-priced, sold-out and removed products (Trendyol fiyat takibi).

- Real Turkish-lira prices: displayed price, seller price, struck-through price, discount percent, cart-discount label (for example "Sepette %40 İndirim"), "lowest price in N days" label
- Every seller of a product with price, seller score, stock, free shipping and the **buy-box winner**
- Review analytics: 1-5 star distribution, aspect sentiment (for example *Kalite 94% positive*), size feedback, Trendyol's AI summary, plus individual reviews
- Built-in price and stock monitoring: unchanged products are not saved and not charged
- Pay per result with a hard cost cap. See the **Pricing** tab for current prices

### Quick start (about 30 seconds)

1. Open the **Input** tab and click **Start**. The prefilled input collects the 20 best-selling air fryers from the *Fritöz* category: listing data only, no proxy, the cheapest and fastest kind of run. On the platform with the default 1 GB it finished in 26 seconds.
2. Open the **Output** tab and the **Products** view: name, brand, TRY price, discount, rating, seller, position and URL for each product.
3. Run it again with **Add product details** switched on to see every seller's offer, barcode, attributes and sizes with stock. The same 20 products with details and review summary took 41 seconds in our test run.

Replace the URL with any Trendyol category, brand, store or product page, or add keywords under **Search keywords**.

### Set up a daily schedule (turn one run into a price monitor)

One run is a snapshot. A schedule turns it into a monitor that tells you every morning what changed on Trendyol. It takes about two minutes and no code:

1. **Save your input as a task.** On the **Input** tab fill in your URLs or keywords, switch on **Changes only (price & stock monitor)**, give it a **Price monitor name** (for example `airfryer-watch`) and click **Save as a new task** (or **Create task**).
2. **Create the schedule.** In Apify Console open **Schedules**, click **Create new**, choose how often it runs, set your time zone (for example `Europe/Istanbul`) and add the task as the action. Examples: `0 7 * * *` every day at 07:00, `0 7 * * 1` every Monday, `0 */6 * * *` every 6 hours.
3. **Choose where the changes go.** Open the task, then **Integrations**, and add Google Sheets, Slack, email or a webhook for *run succeeded*. Each delivery contains only the rows that changed.

What you get each time: the first run saves every product as `new`. Every later run saves only products with a `changeType` (`price_changed`, `stock_changed`, `unavailable`, `back_in_stock`, `variants_changed`, plus free `removed` rows) and skips unchanged products, which are free. A quiet day costs almost nothing. Keep the input and the monitor name the same between runs; a different input or name starts a new watch list.

Read the newest result from your own code with one request (token in the `Authorization` header):

```bash
curl -H "Authorization: Bearer $APIFY_TOKEN" \
  "https://api.apify.com/v2/acts/atesen-software~trendyol-scraper/runs/last/dataset/items?status=SUCCEEDED&clean=true"
```

A ready input for a daily watch of one category:

```json
{
  "startUrls": [{ "url": "https://www.trendyol.com/fritoz-x-c1055" }],
  "maxProductsPerSource": 300,
  "sortBy": "BEST_SELLER",
  "changesOnly": true,
  "priceMonitorKey": "airfryer-watch",
  "includeProductDetails": true
}
```

Set **Maximum cost per run** in the task's run options as a safety cap. Console screens change between versions, so follow the labels above rather than exact positions.

### Three ways people use it

#### 1. Daily price and stock monitoring for a Turkish-market seller

Watch the category you sell in and get only what changed since yesterday: new competitors, price drops, sold-out items, products that came back in stock.

```json
{
  "startUrls": [{ "url": "https://www.trendyol.com/fritoz-x-c1055" }],
  "maxProductsPerSource": 300,
  "changesOnly": true,
  "priceMonitorKey": "airfryer-watch"
}
```

Save the input as a task and add a schedule (for example cron `0 7 * * *`, every day at 07:00). The first run saves every product as `new`; later runs save only rows with a `changeType` such as `price_changed` (with `previousPrice`, `priceChange`, `priceChangePercent`). Send the rows to Google Sheets, Slack or a webhook with an Apify integration. Details: [Price & stock monitoring](#price--stock-monitoring).

#### 2. Competitor buy-box and seller comparison

Find out who wins the buy-box on your products and how far apart the other sellers are.

```json
{
  "startUrls": [{ "url": "https://www.trendyol.com/fritoz-x-c1055" }],
  "maxProductsPerSource": 50,
  "sortBy": "BEST_SELLER",
  "includeProductDetails": true
}
```

With **Add product details** every row has `sellers` (price, seller score, stock, shipping, `isBuyBoxWinner` for each offer), `sellerCount` and `lowestSellerPrice`. To check specific products, paste their product URLs; a URL with `?merchantId=...` keeps that seller's offer.

#### 3. Review mining for product research and sentiment

Before you list a product, read what buyers praise and complain about.

```json
{
  "searchQueries": ["airfryer"],
  "maxProductsPerSource": 20,
  "includeReviewSummary": true,
  "includeReviews": true,
  "maxReviewsPerProduct": 30,
  "reviewSort": "NEWEST"
}
```

`reviewSummary` gives the star split, aspect sentiment and Trendyol's AI summary; `reviews` holds the newest reviews with rating, text, date, likes, seller, variant and photo links. Reviewer names, height and weight are not collected. If you only need reviews for a list of products, the separate [Trendyol Reviews Scraper](https://apify.com/atesen-software/trendyol-reviews-scraper) is built for that.

### Input

This is the prefilled input of the Quick start:

```json
{
  "startUrls": [{ "url": "https://www.trendyol.com/fritoz-x-c1055" }],
  "searchQueries": [],
  "maxProductsPerSource": 20,
  "sortBy": "BEST_SELLER",
  "proxyConfiguration": { "useApifyProxy": false }
}
```

| Field | What it does |
| --- | --- |
| **Trendyol URLs** (`startUrls`) | Category (`/fritoz-x-c1055`), brand (`/schafer-x-b373`), brand + category, store (`/magaza/...-m-123`), search (`/sr?q=...`) or product (`...-p-123`) URLs. Filters already in the URL are kept. Share links copied from the Trendyol mobile app (`https://ty.gl/...`) are opened and resolved to the real page first. |
| **Search keywords** (`searchQueries`) | Keywords searched on Trendyol, one per line. |
| **Max products per URL / keyword** | A limit per source, not per run. Trendyol shows 36 products per page; the Actor paginates up to 300 pages per source. The prefill uses 20; if you leave it out in an API call, 50 is used. |
| **Sort listings by** | Recommended, lowest/highest price, newest, best sellers, most favourited, most reviewed. |
| **Skip sponsored products** | Leaves out the ads Trendyol mixes into listings. |
| **Add product details** | Opens each product page: all sellers, barcode, attributes, variants with stock, exact favourites, category path. |
| **Add review summary** | Star distribution, aspect sentiment, size feedback, AI summary. No extra charge event. |
| **Scrape reviews / Max reviews per product / Review order** | Individual reviews, nested in the product. |
| **Price monitor name** | Compare prices with the previous run that used the same name. |
| **Changes only (price & stock monitor)** | Off by default. On: only new and changed products are saved and charged. |
| **Proxy** | Default: no proxy. Set Apify Proxy RESIDENTIAL with country TR if a run reports many `blocked` rows. |

### Output

One dataset item per product. Real record from a run of the prefilled input above (shortened, one product, listing data only):

```json
{
  "productId": 838129892,
  "name": "Gourmet XXXL Smart Screen İnox Cam Hazneli Airfryer",
  "brand": "Karaca",
  "category": "Fritöz",
  "url": "https://www.trendyol.com/karaca/gourmet-xxxl-smart-screen-inox-cam-hazneli-airfryer-p-838129892?merchantId=253958&boutiqueId=61",
  "price": 3999,
  "sellingPrice": 3999,
  "originalPrice": 4799,
  "discountPercent": 17,
  "currency": "TRY",
  "lowestPriceInDays": 14,
  "rating": 4.44,
  "ratingCount": 244,
  "sellerId": 253958,
  "inStock": true,
  "freeShipping": true,
  "position": 2,
  "sourceType": "category",
  "scrapedAt": "2026-10-24T14:09:37.288Z"
}
```

With **Add product details** the same product also gets seller offers, barcode, category path and attributes. Real record from a run on 29 Oct 2026 (shortened: 3 of 11 sellers, 3 attributes):

```json
{
  "productId": 891694049,
  "name": "3000 Serisi Airfryer, RapidAir Plus Teknolojisi, 4.2 Litre, Kolay Temizlik, NA322/00",
  "brand": "Philips",
  "price": 4980,
  "currency": "TRY",
  "sellerName": "Buevin",
  "sellerCount": 11,
  "lowestSellerPrice": 4980,
  "sellers": [
    { "sellerName": "Buevin", "sellerScore": 9.4, "price": 4980, "inStock": true, "freeShipping": true, "isBuyBoxWinner": true },
    { "sellerName": "SATÜRN", "sellerScore": 8.8, "price": 4981, "inStock": true, "freeShipping": true, "isBuyBoxWinner": false },
    { "sellerName": "Torix Store", "sellerScore": 9.2, "price": 5394, "inStock": true, "freeShipping": true, "isBuyBoxWinner": false }
  ],
  "barcode": "8720389034626",
  "categoryPath": "Elektronik > Elektrikli Ev Aletleri > Yiyecek & İçecek Hazırlama > Yiyecek Hazırlama > Fritöz",
  "attributes": { "Frekans": "50 Hz / 60 Hz", "Materyal": "Metal", "Renk": "Siyah" }
}
```

With **Add review summary** a product also has `reviewSummary` (average rating, `ratingDistribution`, `aspects`, `aiSummary`). With **Scrape reviews** it has a `reviews` array; each review has `reviewId`, `reviewRating`, `reviewText`, `reviewDate`, `reviewLikes`, `reviewSellerName`, `reviewVariant`, `reviewMediaUrls`.

| Output fields | Availability |
| --- | --- |
| `productId`, `name`, `url`, `brand`, `price`, `sellingPrice`, `originalPrice`, `currency`, `rating`, `ratingCount`, `sellerId` | Every product row. A missing source value is `null`. |
| `sellerName`, `sellers`, `variants`, `attributes`, `barcode` | Needs **Add product details**. |
| `reviewSummary` | Needs **Add review summary**. |
| `reviews` | Needs **Scrape reviews**; nested per product, capped by `maxReviewsPerProduct`. |
| `type`, `status`, `message`, `reviewsError` | Status rows and review errors; check them before treating a dataset as complete. |

**Price fields.** `price` is what Trendyol displays (including cart promotions; listings sort by it), `sellingPrice` is the seller's price before cart promotions, `originalPrice` is the crossed-out price. When a product page supplies a price, `price`, `sellingPrice`, `originalPrice` and `discountPercent` replace the listing snapshot together. A missing reference price or discount is `null`.

### Export to CSV or Excel

In the **Output** tab choose the **Products** view and click **Export**, then pick CSV, Excel or JSON. The same works through the API: `https://api.apify.com/v2/datasets/<datasetId>/items?format=csv&view=products` (add `format=xlsx` for Excel).

For one row per review use `?unwind=reviews&fields=productId,name,reviewId,reviewRating,reviewText,reviewDate,url&format=csv`. Apify merges each review into its parent product, so review columns are top-level only after expansion, and products without reviews stay as rows with blank review columns. Filter `reviewId` to non-blank before saving a review-only sheet.

### Price & stock monitoring

**Changes only (recommended for schedules).** Turn on **Changes only** and schedule the Actor. Open the **Changes** view, or connect a webhook, Google Sheets or Slack integration, to receive only the changes. Every run is compared with the previous run of the same input (or of the same **Price monitor name**) and only what changed is saved:

| `changeType` | Meaning | Charged |
| --- | --- | --- |
| `new` | first time this product is seen (every product on the first run) | yes, as a normal product |
| `price_changed` | price went up or down (`previousPrice`, `priceChange`, `priceChangePercent`) | yes |
| `unavailable` | still listed but sold out, temporarily unavailable | yes |
| `back_in_stock` | sold out last time, buyable again | yes |
| `stock_changed` / `variants_changed` | a size or variant sold out, came back, appeared or disappeared (needs **Add product details**) | yes |
| `removed` | product is gone: its page returns 404 (`removedReason: not_found`), or it was missing from a fully crawled listing two runs in a row (`not_listed`) | **free** |
| unchanged | not saved | **free** |

Each changed row also has a `changes` list (for example `{"field": "price", "from": 1299, "to": 1149}`), `previousInStock`, `previousSeenAt` and `firstSeenAt`. Products are matched by Trendyol's stable `productId`, so renamed products are not reported as new. Keep the input the same between runs: a different input or monitor name starts a new watch list and every product is `new` again.

**Price fields on every row.** Without changes-only, set **Price monitor name** and schedule the Actor with the same input. Each product gets `previousPrice`, `priceChange`, `priceChangePercent` and `isNewInMonitor`.

### Pricing

Pay per event: you are charged when a result is saved. The prices are on the **Pricing** tab.

| Event | Charged when |
| --- | --- |
| Product | a product is saved |
| Product details | a product is saved with **Add product details** on (in addition to Product) |
| Review | each saved review |

The review summary has no extra charge. Set **Maximum cost per run** in the run options: the Actor checks the remaining budget before each product and stops cleanly, so you are not charged for data you do not receive. In **Changes only** mode, unchanged and removed products are free. Status rows are free. The default run uses no proxy; if you switch on Apify Proxy, check Apify's proxy pricing.

### Use with the API, n8n, Make and Zapier

**API.** One request starts the Actor, waits for it and returns the dataset items as JSON. The token goes in the `Authorization` header (never in a URL or a shared file):

```bash
curl -X POST "https://api.apify.com/v2/acts/atesen-software~trendyol-scraper/run-sync-get-dataset-items?timeout=120" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "searchQueries": ["airfryer"], "maxProductsPerSource": 10 }'
```

The synchronous endpoint waits at most 300 seconds. For bigger jobs start the run with `POST https://api.apify.com/v2/acts/atesen-software~trendyol-scraper/runs`, wait for it (or use a webhook), then read `https://api.apify.com/v2/datasets/<datasetId>/items`. To cap spend add `maxTotalChargeUsd=<amount>` to the query string.

**n8n.** Use the official Apify node (`@apify/n8n-nodes-apify`: *Run Actor and get dataset*), or an **HTTP Request** node with Method `POST`, the URL above, a *Header Auth* credential (name `Authorization`, value `Bearer <your token>`), and the JSON input as body. Guide: [Apify n8n integration](https://docs.apify.com/integrations/n8n).

**Make.** Use the Apify app modules *Run an Actor* and *Get Dataset Items*, or the **HTTP, Make a request** module with the same URL, method, `Authorization` header and JSON body. For long runs use the Apify app's watch module instead of waiting inside one step. Guide: [Apify Make integration](https://docs.apify.com/integrations/make).

**Zapier.** Use the Apify app to run this Actor or a saved task, trigger a Zap when a run finishes, and fetch the dataset items. Guide: [Apify Zapier integration](https://docs.apify.com/integrations/zapier).

The HTTP request above is the same one every tool sends. Connector screens change between versions, so follow the linked guides for the current clicks. Google Sheets, Slack, email and webhook delivery for scheduled runs can also be set up under **Integrations** in Apify Console.

### Use with AI agents (MCP)

Connect an MCP-compatible AI client to the [Apify MCP server](https://docs.apify.com/mcp) with this URL and authorize through Apify OAuth:

```text
https://mcp.apify.com?tools=atesen-software/trendyol-scraper
```

Ask your agent: "Run atesen-software/trendyol-scraper for the 20 best-selling air fryers, then return productId, name, price, currency, rating and url. Report blocked or incomplete results." Use the prefilled input from the Input section. A successful run status alone does not guarantee 20 products: check the dataset and the `RUN_SUMMARY` record in the run's key-value store.

### FAQ

**Is it legal to scrape Trendyol?** The Actor collects publicly visible product, price and review data and does not log in. Reviewer names, height and weight, and sellers' tax and address details are deliberately not collected. Trendyol's robots.txt disallows search-result URLs (`/sr?...`), which keyword searches and store pages use, and several query-string patterns; category, brand and product URLs are a closer fit where that matters to you. You are responsible for using the data in line with Trendyol's terms, the Turkish personal-data law (KVKK) and other laws that apply to you. This is not legal advice, and the Actor is not affiliated with Trendyol.

**How many results can I get, and how fast?** You can set the limit up to 10,000 products per URL or keyword (the Actor paginates through up to 300 listing pages of 36 products); how deep a listing goes is up to Trendyol. Listing-only runs are the fastest: 20 products took 26 seconds in our platform test. Product details and reviews need one extra request per product, are paced to respect Trendyol's rate limits, and take longer: 20 products with details and review summary took 41 seconds. Start with 20-50 products, check the fields, then scale up.

**Why did I get fewer items than I asked for?** The limit is a maximum, not a promise. Common reasons: Trendyol lists fewer products for that URL or keyword (the log shows "Trendyol reports N products"); the same product matched two sources and is saved once; **Skip sponsored products** is on; the **Maximum cost per run** was reached; the run time limit was about to be reached; or Trendyol blocked some pages. The run's status message and the `RUN_SUMMARY` record say which one happened.

**Do I need a proxy?** No. The default runs without one, and search, store and category listings usually work. If a run reports many `blocked` rows, set the proxy to Apify Proxy RESIDENTIAL with country TR, or switch on **Retry blocked pages with another connection**. Both can add proxy cost.

**How do I schedule it?** Save your input as a task, then in Apify Console open **Schedules**, create a schedule (for example `0 7 * * *` for 07:00 every day) and add the task. Use **Changes only** and a **Price monitor name** so each run saves only what changed.

**How do I export to CSV or Excel?** Open the **Output** tab, choose the **Products** view and click **Export**. See [Export to CSV or Excel](#export-to-csv-or-excel) for the API form and one row per review.

**How do I see every seller of a product, not only the buy-box winner?** Turn on **Add product details**. The `sellers` array lists every offer Trendyol shows on the product page and flags the buy-box winner. Completeness of all marketplace sellers is not guaranteed.

**Why are some reviews missing?** `maxReviewsPerProduct` caps them, a product may have no reviews, and if Trendyol rate-limits its review API repeatedly the product is delivered with `reviewsError` set instead of being lost. An empty `reviews` array alone does not prove there are no reviews.

**What happens with a wrong URL or empty input?** The run does not fail and nothing is charged. You get a free row with `"type": "status"` explaining it. The status values are `invalid_input` (no URL or keyword), `unsupported_url` (not a Trendyol address, or a `ty.gl` share link that cannot be opened), `not_found` (404), `blocked` (Cloudflare challenge; Trendyol also answers this way for a brand or category link that no longer exists, so open the link in a browser to check) and `failed` (after retries; `message` says why). Filter them out with `type != "status"`. Wrong types in the input (for example text where a list is expected) are rejected by Apify before the run starts.

**Can I paste a link from the Trendyol app?** Yes. Share links such as `https://ty.gl/...` are resolved to the product, store or listing page they point to; tracking parameters are removed. If a link only opens inside the app, you get an `unsupported_url` row: open it in a browser and paste the trendyol.com address instead.

**How does a run end?** *Succeeded with data* is the normal case. *Succeeded, stopped early* keeps everything saved and says why in the status message (cost cap reached, time limit about to be reached, Trendyol kept blocking new browser sessions, or an unexpected error after some products were saved). *Failed* happens only when something unexpected goes wrong and nothing was saved, for example the browser cannot start after three attempts.

**Why does it use a browser?** Trendyol answers plain HTTP scrapers with a Cloudflare "Just a moment" challenge. The Actor uses a real Chromium browser only as an HTTP client: each session opens one Trendyol page and every listing, product and review request is then fetched from inside that page. Images and styles are not downloaded.

**Found a problem?** Open an issue on the Actor's **Issues** tab with the run ID and the URL.

### Limitations

- Product descriptions (the "Ürün Açıklaması" HTML block) are not included because Trendyol loads them separately.
- Sizes and variants include stock and barcode but not a separate price per size (Trendyol prices the selected offer).
- Trendyol can change its pages at any time. When a page cannot be read, the Actor says so in a status row and in the run's status message instead of returning silent empty results.
- Only the Turkish storefront (TRY) is supported; `/en/` URLs are mapped to it.

# Actor input Schema

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

Trendyol category (e.g. https://www.trendyol.com/fritoz-x-c1055), brand, brand + category, store (/magaza/...-m-123), search (/sr?q=...) or product (...-p-123) URLs. In JSON, use objects such as {"url":"https://www.trendyol.com/fritoz-x-c1055"}. Supply URLs, searchQueries, or both. Category, brand and search URL filters and sorting are preserved; store URLs preserve seller ID and sorting. Product URLs retain merchantId and boutiqueId. Only the Turkish storefront is supported.

## `searchQueries` (type: `array`):

Keywords to search on Trendyol, one per line in Console or as a JSON string array (e.g. \["airfryer", "kahve makinesi"]). Can be combined with startUrls. Empty and duplicate keywords are ignored; at least one non-empty keyword or URL is required.

## `maxProductsPerSource` (type: `integer`):

Maximum products collected per listing URL or search keyword, not a run-wide limit. Range: 1–10000; API default: 50; Console prefill: 20. Listing pages contain up to 36 products. Products are deduplicated across the run, so overlapping sources, empty listings or blocked requests may return fewer products. A product URL selects one product.

## `sortBy` (type: `string`):

Listing order for keyword searches and URLs without an existing sst sorting parameter. An explicit sort in the URL takes precedence. API default: RELEVANCE; Console prefill: BEST_SELLER. Does not sort product URLs or reviews.

## `skipSponsored` (type: `boolean`):

Exclude listing cards identified as sponsored ads. Default: false, including sponsored cards. Applies to listings, not direct product URLs.

## `includeProductDetails` (type: `boolean`):

Fetch product-page data: available seller offers and ratings (including the buy-box winner), barcode, attributes, variants with stock, favourite count and category path. Missing source fields remain null or empty; completeness of all marketplace sellers is not guaranteed. Adds a product-details event per saved product. Does not enable individual reviews or review analytics.

## `includeReviewSummary` (type: `boolean`):

Fetch review analytics into reviewSummary: available 1–5 star distribution, aspect sentiment (e.g. 'Kalite 94% positive'), size feedback and Trendyol's AI summary. Requires product/review requests, but adds no review-summary billing event. Does not enable individual reviews. Missing or unavailable summaries may be null.

## `includeReviews` (type: `boolean`):

Fetch individual reviews into each product's nested reviews array, capped by maxReviewsPerProduct and ordered by reviewSort. Each saved review adds a review event. Does not enable reviewSummary. Expand reviews for CSV/Excel; filter blank reviewId rows for a review-only sheet. Reviewer names, height and weight are omitted. If the review API is unavailable, inspect reviewsError; an empty array does not prove there are no reviews.

## `maxReviewsPerProduct` (type: `integer`):

Maximum individual reviews saved per product when includeReviews is true. Range: 1–5000; default: 20. Ignored when reviews are disabled. Products with fewer available reviews return fewer; this is not a run-wide limit.

## `reviewSort` (type: `string`):

Order requested from the review API when includeReviews is true: RELEVANCE (default) or NEWEST. Independent of the product listing sortBy option.

## `priceMonitorKey` (type: `string`):

Optional monitor name, e.g. "airfryer-watch". Adds previousPrice, priceChange, priceChangePercent and isNewInMonitor using the last observed price for each product under that name. Reuse the same name for the same watch list. Spaces and unsupported characters become hyphens; names are limited to 100 characters. Empty disables price-history fields; changesOnly can still derive its own snapshot key from URLs and keywords. Scheduling is configured separately in Apify Console.

## `changesOnly` (type: `boolean`):

Default false: save the full product output. True: compare against the saved snapshot selected by priceMonitorKey, or a key derived from URLs and keywords, and save only new, price_changed, stock_changed, variants_changed, unavailable or back_in_stock products. The first run saves all products as new. Removed products produce free removed rows after a 404 or absence from two complete listing runs. Unchanged products are skipped and not charged. Enable product details to compare variants; configure a schedule separately.

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

Default: {"useApifyProxy":false}, using a direct connection. Requests use Chromium. A proxy is used only when explicitly configured. Apify Proxy can incur additional charges; useApifyProxy:false disables it, but custom proxyUrls, if supplied, are still used. Automatic fallback is controlled separately by autoProxyFallback.

## `autoProxyFallback` (type: `boolean`):

Default false. On Apify, true allows one retry of blocked requests through paid Apify Proxy RESIDENTIAL (TR) when the initial connection is direct, or through a direct connection when the configured proxy was blocked. May incur proxy charges. Keep false when paid proxy usage is not authorized. Has no effect in local runs.

## `maxConcurrency` (type: `integer`):

Maximum concurrent crawler requests (1–16; default 4). Higher values may increase rate limiting and memory usage. Actual parallelism also depends on available browser sessions and run memory.

## `maxBrowserSessions` (type: `integer`):

Maximum browser sessions (1–10; default 3), capped by available run memory (about 200 MB per session plus overhead). Sessions have separate browser contexts; a proxy connection is assigned per session only when a proxy is explicitly configured. Direct sessions do not provide distinct proxy IPs.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.trendyol.com/fritoz-x-c1055"
    }
  ],
  "searchQueries": [],
  "maxProductsPerSource": 20,
  "sortBy": "BEST_SELLER",
  "skipSponsored": false,
  "includeProductDetails": false,
  "includeReviewSummary": false,
  "includeReviews": false,
  "maxReviewsPerProduct": 20,
  "reviewSort": "RELEVANCE",
  "changesOnly": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "autoProxyFallback": false,
  "maxConcurrency": 4,
  "maxBrowserSessions": 3
}
```

# Actor output Schema

## `products` (type: `string`):

No description

## `changes` (type: `string`):

No description

## `reviews` (type: `string`):

No description

## `priceChanges` (type: `string`):

No description

## `runSummary` (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 = {
    "startUrls": [
        {
            "url": "https://www.trendyol.com/fritoz-x-c1055"
        }
    ],
    "searchQueries": [],
    "maxProductsPerSource": 20,
    "sortBy": "BEST_SELLER",
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("atesen-software/trendyol-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 = {
    "startUrls": [{ "url": "https://www.trendyol.com/fritoz-x-c1055" }],
    "searchQueries": [],
    "maxProductsPerSource": 20,
    "sortBy": "BEST_SELLER",
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("atesen-software/trendyol-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 '{
  "startUrls": [
    {
      "url": "https://www.trendyol.com/fritoz-x-c1055"
    }
  ],
  "searchQueries": [],
  "maxProductsPerSource": 20,
  "sortBy": "BEST_SELLER",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call atesen-software/trendyol-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,atesen-software/trendyol-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/OvQfJfLaxERNsd6Re/builds/vHdp6T4UXdK5RrMPi/openapi.json