# Amazon.de Best Sellers Scraper (`scrapyspider/amazon-de-best-seller-scraper`) Actor

Scrapes Amazon Germany best seller rankings by category. Extracts rank, ASIN, title, price, rating, review count, images, brand, features, and product details. Supports all major categories. No account required.

- **URL**: https://apify.com/scrapyspider/amazon-de-best-seller-scraper.md
- **Developed by:** [ScrapySpider](https://apify.com/scrapyspider) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.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

### Amazon.de Best Sellers Scraper

Scrapes Amazon Germany's best seller rankings by category — no account, no login required — and returns structured data including rank, ASIN, price, rating, brand, key features, and product details.

- No Amazon account or cookies needed
- Supports all major Amazon.de categories (Electronics, Books, Toys, Kitchen, and more)
- Extracts listing data **and** full product detail pages in a single run
- Category input via URL paste or dropdown selector
- Up to 100 products per category per run (Amazon's best seller list limit)
- Outputs clean JSON ready to export as CSV or Excel

---

#### What data does it extract?

Each result contains:

**Best seller info:** rank, ASIN, category, category URL, scraped timestamp

**Product basics:** title, price (€), average star rating, review count, main image URL, product URL

**Product details:** brand, key features (bullet points), product description, availability status, category breadcrumb path

---

#### Use cases

- **Market research:** Identify top-selling products in any German Amazon category to spot trends and demand signals
- **Competitor analysis:** Monitor competitor products' rankings, pricing, and review counts over time
- **Product sourcing:** Find best-selling items for resale, arbitrage, or private-label opportunities
- **Price monitoring:** Track price changes on top-ranked products across categories
- **SEO & content:** Analyze product titles and features of top sellers to inform listings and keyword strategies
- **Academic research:** Gather structured e-commerce data for category and consumer behavior studies

---

#### How to use

1. Click **Try for free** above
2. In the **Input** tab, either paste one or more Amazon.de best seller category URLs under **Category URLs**, or select a category from the **Category Preset** dropdown
3. Set **Max Products** (default: 50; maximum: 100 per category)
4. Configure **Proxy** — residential proxies are recommended and set as default
5. Click **Start** and wait for the run to complete (typically 2–5 minutes for 50 products)
6. Download results as JSON, CSV, or Excel from the **Output** tab

**Tip:** You can combine a Category Preset with additional Category URLs to scrape multiple categories in one run.

---

#### Input parameters

| Parameter | Type | Required | Description |
|---|---|---|---|
| `categoryUrls` | Array of URLs | No | One or more Amazon.de best seller category page URLs. Example: `https://www.amazon.de/gp/bestsellers/electronics/` |
| `categoryPreset` | String (enum) | No | Pick from a list of popular categories: Electronics, Books, Toys, Kitchen, Sports, Beauty, Clothing, and more. Used alongside or instead of `categoryUrls`. |
| `maxProducts` | Integer | No | Maximum products to extract per category. Default: `50`. Min: `1`. Max: `100`. |
| `proxyConfiguration` | Object | No | Proxy settings. Default: Apify Proxy residential. Residential proxies strongly recommended for Amazon. |

At least one of `categoryUrls` or `categoryPreset` should be set. If neither is provided, the scraper defaults to the Amazon.de all-departments best sellers page.

---

#### Output example

```json
{
  "rank": 1,
  "asin": "B09G9HD6PD",
  "title": "Apple AirPods (3. Generation) mit Lightning Ladecase",
  "price": "€179,00",
  "rating": 4.7,
  "reviewCount": 28450,
  "imageUrl": "https://m.media-amazon.com/images/I/71bkXIe1ZfL._AC_SX466_.jpg",
  "productUrl": "https://www.amazon.de/dp/B09G9HD6PD",
  "brand": "Apple",
  "features": [
    "Räumliches Audio mit dynamischer Head-Tracking-Funktion",
    "Adaptiver EQ stimmt die Musik in Echtzeit auf deine Ohren ab",
    "Bis zu 6 Stunden Hörgenuss (bis zu 30 Stunden mit dem Ladecase)"
  ],
  "description": "AirPods bieten jetzt räumliches Audio mit dynamischem Head Tracking...",
  "availability": "Auf Lager",
  "breadcrumb": ["Elektronik & Foto", "Audio & HiFi", "Kopfhörer"],
  "category": "Electronics",
  "categoryUrl": "https://www.amazon.de/gp/bestsellers/electronics/",
  "scrapedAt": "2024-11-15T10:32:14.000Z"
}
````

***

#### Pricing

This Actor is **free to use** — you only pay for Apify platform compute time and proxy usage.

A typical run of 50 products costs approximately **$0.05–$0.15** in Apify platform credits, depending on proxy usage.

New Apify accounts receive **$5 in free credits** — enough for several hundred product scrapes.

***

#### Technical notes

- **No account needed:** This Actor does not require an Amazon account, login, or cookies
- **Residential proxies required:** Amazon.de actively blocks datacenter IPs and serves empty pages to bots. **Residential proxies are mandatory** — the scraper will not return products without them. Apify residential proxies are pre-configured as the default
- **Proxy credits:** Residential proxy usage is billed separately from Actor compute units. Check your Apify plan for included residential proxy bandwidth
- **Rate limits:** For large runs or multiple categories, increasing Actor memory to 2 GB is recommended
- **Data freshness:** All data is scraped live — no cached or stale results
- **Max products:** Amazon's best seller lists show a maximum of 100 products per category (2 pages of 50). The `maxProducts` input is capped at 100
- **Blocked pages:** If Amazon blocks a request, the scraper retries up to 3 times automatically
- **Language:** Results are in German as scraped from amazon.de — product titles, features, and descriptions will be in German

***

#### Support

Have questions or found a bug? Reach out:

- **Email:** ScrapySpider@protonmail.com
- **Website:** [ScrapySpider.com](https://ScrapySpider.com)
- **Apify:** Open a support issue on this Actor page
- **Response time:** Within 24–48 hours on weekdays

# Actor input Schema

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

One or more Amazon.de best seller category page URLs to scrape. Example: https://www.amazon.de/gp/bestsellers/electronics/. Leave empty if using Category Preset instead.

## `categoryPreset` (type: `string`):

Pick a popular Amazon.de best seller category. This will be used when no Category URLs are provided, or combined with them.

## `maxProducts` (type: `integer`):

Maximum number of best seller products to extract per category. Amazon shows up to 100 products per category (2 pages of 50). Default is 50.

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

Proxy settings for the scraper. Residential proxies are recommended for best results with Amazon.

## Actor input object example

```json
{
  "categoryPreset": "all",
  "maxProducts": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "categoryPreset": "all",
    "maxProducts": 5,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapyspider/amazon-de-best-seller-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 = {
    "categoryPreset": "all",
    "maxProducts": 5,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapyspider/amazon-de-best-seller-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 '{
  "categoryPreset": "all",
  "maxProducts": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scrapyspider/amazon-de-best-seller-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon.de Best Sellers Scraper",
        "description": "Scrapes Amazon Germany best seller rankings by category. Extracts rank, ASIN, title, price, rating, review count, images, brand, features, and product details. Supports all major categories. No account required.",
        "version": "0.1",
        "x-build-id": "pq6qgW6OdXqpLUBaQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapyspider~amazon-de-best-seller-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapyspider-amazon-de-best-seller-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/scrapyspider~amazon-de-best-seller-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapyspider-amazon-de-best-seller-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/scrapyspider~amazon-de-best-seller-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapyspider-amazon-de-best-seller-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": {
                    "categoryUrls": {
                        "title": "Category URLs",
                        "type": "array",
                        "description": "One or more Amazon.de best seller category page URLs to scrape. Example: https://www.amazon.de/gp/bestsellers/electronics/. Leave empty if using Category Preset instead.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "categoryPreset": {
                        "title": "Category Preset",
                        "enum": [
                            "",
                            "all",
                            "books",
                            "electronics",
                            "computers",
                            "toys",
                            "kitchen",
                            "sports",
                            "beauty",
                            "clothing",
                            "garden",
                            "automotive",
                            "music",
                            "movies",
                            "video-games",
                            "health",
                            "pet-supplies",
                            "office",
                            "tools"
                        ],
                        "type": "string",
                        "description": "Pick a popular Amazon.de best seller category. This will be used when no Category URLs are provided, or combined with them."
                    },
                    "maxProducts": {
                        "title": "Max Products",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of best seller products to extract per category. Amazon shows up to 100 products per category (2 pages of 50). Default is 50."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for the scraper. Residential proxies are recommended for best results with Amazon."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
