# Amazon TR İndirimleri API | İndirim, Discounts & Lowest Prices (`muzafferkadir/amazon-tr-deals-scraper`) Actor

Amazon.com.tr'deki gerçek indirimleri toplar: yüzde indirim rozeti veya 30/60/90/365 günün en düşük fiyatı işareti olanlar. 33 kategori, tasarruf tutarıyla.

Amazon Turkey deals API — real discounts only, all 33 categories, with current price, previous price and exact savings.

- **URL**: https://apify.com/muzafferkadir/amazon-tr-deals-scraper.md
- **Developed by:** [Muzaffer Kadir YILMAZ](https://apify.com/muzafferkadir) (community)
- **Categories:** E-commerce, Automation, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 discounted 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/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

## Amazon TR Deals Scraper

Get the products on Amazon.com.tr that are actually discounted right now — with the real price, the price before the deal, and how much is saved.

Amazon's deals pages mix genuine price cuts with items labelled only "Fırsat" or "Prime Fırsatı" that often cost the same as yesterday. This scraper keeps the ones a shopper would call a discount: a product carrying a discount percentage, or one Amazon itself marks as the lowest price of the last 30, 60, 90 or 365 days.

### Features

- **Real discounts by default** — plain "deal of the day" filler is filtered out, so you review a short list instead of a long one
- **Lowest-price signal** — see which products are at their cheapest in 30, 60, 90 or 365 days, straight from Amazon
- **Every category** — 33 collections, from Bilgisayar and Cep Telefonları to Mutfak, Oyuncak and price bands like "500 TL altı"
- **Minimum discount threshold** — ask for 25%+ only and skip the rest
- **Exact savings** — deal price, previous price and the amount saved, calculated from the two prices rather than a rounded badge
- **No duplicates** — the same product listed in several collections is returned once

### How it works

1. Opens the Amazon.com.tr deals page and reads the live list of categories
2. Walks each category you selected, page by page
3. Reads each product's price, previous price and deal badge
4. Keeps the genuinely discounted ones (or everything, if you ask)
5. Writes results as it goes, so a stopped run still returns what it found

### Getting more results

Amazon rotates its deals throughout the day, and a category holds as much as it holds — usually 100-200 active deals. A few things worth knowing:

- Leaving **Categories** empty sweeps all 33 collections, which is the widest sweep available
- Setting **Minimum discount %** excludes products with no advertised percentage, even genuinely cheap ones flagged as a lowest price — leave it empty if you want those too
- Amazon's own categorisation is broad: a phone charger can appear under "TV ve Ev Sineması". The scraper reports the category exactly as Amazon files it

### Input

| Field | Type | Description |
| --- | --- | --- |
| `categories` | array | Deal collections to scrape. Empty means all 33. |
| `dealFilter` | string | `realDiscountsOnly` (default) or `all`. |
| `minDiscountPercent` | integer | Drop anything below this percentage. |
| `maxItems` | integer | Stop after this many products. |
| `maxItemsPerCategory` | integer | Advanced: cap per category so one does not use the whole budget. |
| `proxyConfiguration` | object | Advanced: optional, data is served without a challenge. |

### Examples

Discounted computer gear, 50 products:

```json
{
  "categories": ["deals-collection-computers-and-accessories"],
  "maxItems": 50
}
```

Deep discounts only, across kitchen and toys:

```json
{
  "categories": ["deals-collection-kitchen", "deals-collection-toys"],
  "minDiscountPercent": 30,
  "maxItems": 100
}
```

Everything on the deals page, filter off:

```json
{
  "categories": ["deals-collection-star"],
  "dealFilter": "all",
  "maxItems": 200
}
```

### Output

| Field | Description |
| --- | --- |
| `asin` | Amazon product id |
| `title` | Product name |
| `url` | Product page link |
| `imageUrl` | Product image |
| `price` | Current deal price in TRY |
| `previousPrice` | Price before the deal, when Amazon shows one |
| `currency` | Always `TRY` |
| `discountPercent` | Advertised discount, when the product carries one |
| `savings` | Previous price minus current price |
| `isLowestPrice` | Whether this is a lowest-price-in-N-days deal |
| `lowestPriceDays` | The N: 30, 60, 90 or 365 |
| `dealBadge` | Amazon's badge text, verbatim |
| `dealMessage` | Amazon's secondary message, verbatim |
| `dealType` | e.g. `BEST_DEAL` |
| `categoryId` / `categoryLabel` | Which collection it came from |
| `scrapedAt` | When the run read it |

Sample row:

```json
{
  "asin": "B0FWVGN77V",
  "title": "MONTECH King 45 PRO ATX Bilgisayar Kasası",
  "url": "https://www.amazon.com.tr/dp/B0FWVGN77V",
  "price": 5499,
  "previousPrice": 7999,
  "currency": "TRY",
  "discountPercent": 31,
  "savings": 2500,
  "isLowestPrice": true,
  "lowestPriceDays": 365,
  "dealBadge": "%31 İndirim",
  "dealMessage": "365 günün en düşük fiyatı",
  "categoryLabel": "Bilgisayar"
}
```

### Notes

Results reflect what Amazon.com.tr is showing at the moment of the run. Deals expire and rotate, so two runs hours apart will differ — that is the source changing, not the scraper.

This is an unofficial scraper and is not affiliated with, endorsed by, or connected to Amazon.

# Actor input Schema

## `categories` (type: `array`):

Which deal collections to scrape. Leave empty to sweep every category Amazon currently lists. Each category beyond the first is billed as an extra category.

## `dealFilter` (type: `string`):

Amazon's deals pages mix real price cuts with items badged only 'Fırsat' or 'Prime Fırsatı', which usually are not meaningfully cheaper. The default keeps a product only when Amazon advertises a discount percentage or marks it the lowest price of the last 30/60/90/365 days.

## `minDiscountPercent` (type: `integer`):

Drop anything below this discount. Products without an advertised percentage are excluded when this is set.

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

Stop once this many products have been saved. Leave empty for everything the selected categories hold.

## `maxItemsPerCategory` (type: `integer`):

Keeps one large category from using the whole budget when several are selected.

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

Amazon.com.tr serves this data without a challenge, so a proxy is optional. Use one to spread requests across IPs on large sweeps.

## Actor input object example

```json
{
  "categories": [
    "deals-collection-computers-and-accessories"
  ],
  "dealFilter": "realDiscountsOnly",
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All deals this run saved, with prices, savings and category.

# 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 = {
    "categories": [
        "deals-collection-computers-and-accessories"
    ],
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("muzafferkadir/amazon-tr-deals-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 = {
    "categories": ["deals-collection-computers-and-accessories"],
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("muzafferkadir/amazon-tr-deals-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 '{
  "categories": [
    "deals-collection-computers-and-accessories"
  ],
  "maxItems": 100
}' |
apify call muzafferkadir/amazon-tr-deals-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/Ly0wyKlcbjSaNdXLt/builds/i8Dv6lVcVVUxhT9Z1/openapi.json