# Otto.de Scraper (`lexis-solutions/otto-de-scraper`)

The Otto.de Apify Scraper is an automated tool for extracting valuable data from Otto.de - one of the leading e-commerce platforms in Germany. It provides businesses with insights for market analysis, competitor monitoring, and price tracking. Ideal for e-commerce and market research.

- **URL**: https://beta-securitybyobscurity.apify.com/lexis-solutions/otto-de-scraper.md
- **Developed by:** [Lexis Solutions](https://beta-securitybyobscurity.apify.com/lexis-solutions) (community)
- **Categories:** E-commerce
- **Stats:** 63 total users, 5 monthly users, 100.0% runs succeeded, 16 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

$25.00/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.
You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

# README

🇬🇧 [English](#english) | 🇩🇪 [Deutsch](#deutsch)

***

### Introduction

<a name="english"></a>

The Otto.de Apify Scraper is a powerful web scraping tool specifically designed to extract data from the popular German e-commerce website, Otto.de. This scraper enables users to collect various product-related information, including product names, prices, descriptions, images, and more.

Otto.de is one of the leading e-commerce platforms in Germany, offering a wide range of products such as electronics, fashion, home appliances, and more. The Otto.de Apify Scraper helps users to gather valuable data from this platform, which can be used for various purposes like market research, price monitoring, and competitor analysis. This scraper is built using Apify, a popular web scraping and automation platform, which ensures a seamless and efficient data extraction process.

### Use Cases

The Otto.de Apify Scraper can be used in multiple scenarios, including but not limited to:

1. **Market Research:** Extract data from Otto.de to analyze market trends, customer preferences, and product performance. This information can be used to identify potential business opportunities and make data-driven decisions.
2. **Price Monitoring:** Track product prices on Otto.de to stay updated on price changes and fluctuations, which can help businesses optimize their pricing strategies and stay competitive in the market.
3. **Competitor Analysis:** Gather data on competitor products and their pricing to identify strengths and weaknesses, enabling businesses to gain a competitive edge.
4. **Product Catalog Management:** Keep your product catalog updated by extracting product information like names, descriptions, images, and more from Otto.de.

Happy scraping!

### Input 📥

To use this actor, you need to provide the following input:

- Field: **startUrls**
  - Type: array
  - Required: Yes
  - Description: Search or product URLs to scrape
- Field: **maxItems**
  - Type: integer
  - Required: No
  - Description: The number of items to be scraped. (if search)
- Field: **proxyConfiguration**
  - Type: object
  - Required: No
  - Description: Your proxy configuration from Apify

### How to get startUrls?

1. A single product

   Open the product on [Otto](https://www.otto.de) and copy its link from the browser URL bar.

2. Search

   2.1. Open the [Otto](https://www.otto.de) website.

   2.2. Navigate to a category or search that you are interested in.

   2.3. Once in the search page, add all needed filters on the page. This will change the URL in the browser search bar. Once ready, copy the URL and paste to Apify as an item in the `startUrls` array.

#### Examples

A single product:

```
https://www.otto.de/p/adidas-performance-eq19-run-laufschuh-laufschuh-C1537649564/#variationId=1537649612
```

A search page ( colorful backpacks under 100€)

```
https://www.otto.de/taschen/rucksaecke/?farbe=bunt&preis-in-eur~bis=100&zielgruppe=herren
```

### Output 📤

<a name="output"></a>

An example output for buy mode looks like this:

```json
{
  "name": "Brandit Trekkingrucksack",
  "sku": "S0X010QGNRF",
  "listPrice": {
    "price": "24.95",
    "priceCurrency": "EUR"
  },
  "aggregateRating": {
    "ratingValue": "4.75",
    "reviewCount": "12"
  },
  "brand": "Brandit",
  "description": "Der BW Kampfrucksack ist ein idealer Begleiter auf jeder Wanderung. Er besitzt zwei feste Außentaschen, ein Hauptfach mit variablem Zwischenboden und flachem Einsteckfach für eine Isomatte, sowie ein aufgesetztes Top-Case mit Klett-Fach. Des Weiteren gibt es ein separates Bodenfach, Kunststoffschnellverschlüsse, gepolsterte Schultergurte, einen Bauchgurt und diverse Befestigungsmöglichkeiten für Ausrüstungsgegenstände. Die stabilen Packgurte bestehen aus strapazierfähigem und wasserfestem Polyamidgewebe und befinden sich an der Vorderseite. Der Kampfrucksack ist mit einer wasserabweisenden Beschichtung ausgestattet. . Technische Daten: Material: 100 Polyester beschichtet mit Polyurethan; Volumen: 65 Liter; Maße (HxBxT): 65x43x25 cm",
  "image": [
    "https://i.otto.de/i/otto/d5859a09-3cb9-5806-b2a7-3ff80a24f43b/brandit-freizeitrucksack-rucksack-bw-olive-65-liter.jpg?$formatz$"
  ]
}
```

### FAQ

**Q: How do I set up the Otto.de Apify Scraper?**

A: To set up the scraper, you'll need an Apify account. Once you have an account, you can access the scraper through the Apify Console, input the required parameters, and start the scraping process.

**Q: Is this scraper legal to use?**

A: Web scraping is subject to legal and ethical considerations. Before using the Otto.de Apify Scraper, ensure that you comply with the website's terms of service, robots.txt file, and any applicable laws and regulations.

**Q: How fast is the data extraction process?**

A: The speed of data extraction depends on various factors such as the number of products, server response time, and the complexity of the data. The scraper is designed to be efficient and fast, but the actual extraction speed may vary.

**Q: How can I export the extracted data?**

A: The Otto.de Apify Scraper allows you to export the extracted data in various formats like JSON, CSV, or Excel. You can download the data directly from the Apify Console or use the Apify API to integrate it into your applications.

***

<a name="deutsch"></a>

### Einführung

Der Otto.de Apify Scraper ist ein leistungsstarkes Web-Scraping-Tool, das speziell für die Extraktion von Daten aus der beliebten deutschen E-Commerce-Website Otto.de entwickelt wurde. Dieser Scraper ermöglicht es Benutzern, verschiedene produktbezogene Informationen zu sammeln, einschließlich Produktnamen, Preise, Beschreibungen, Bilder und mehr.

Otto.de ist eine der führenden E-Commerce-Plattformen in Deutschland und bietet eine breite Palette von Produkten wie Elektronik, Mode, Haushaltsgeräte und mehr. Der Otto.de Apify Scraper hilft Nutzern, wertvolle Daten von dieser Plattform zu sammeln, die für verschiedene Zwecke wie Marktforschung, Preisüberwachung und Konkurrenzanalyse verwendet werden können. Der Scraper basiert auf Apify, einer beliebten Web-Scraping- und Automatisierungsplattform, die einen nahtlosen und effizienten Datenextraktionsprozess gewährleistet.

### Anwendungsfälle

Der Otto.de Apify Scraper kann in einer Vielzahl von Szenarien eingesetzt werden, unter anderem in der

1. **Marktforschung:** Extrahieren Sie Daten von Otto.de, um Markttrends, Kundenpräferenzen und Produktleistungen zu analysieren. Diese Informationen können genutzt werden, um potenzielle Geschäftsmöglichkeiten zu identifizieren und datengestützte Entscheidungen zu treffen.
2. **Preisüberwachung:** Verfolgen Sie die Produktpreise auf Otto.de, um über Preisänderungen und -schwankungen auf dem Laufenden zu bleiben. Dies kann Unternehmen helfen, ihre Preisstrategien zu optimieren und auf dem Markt wettbewerbsfähig zu bleiben.
3. **Analyse der Wettbewerber:** Sammeln Sie Daten über Produkte und Preise von Mitbewerbern, um Stärken und Schwächen zu ermitteln und sich so einen Wettbewerbsvorteil zu verschaffen.
4. **Produktkatalog-Management:** Halten Sie Ihren Produktkatalog auf dem neuesten Stand, indem Sie Produktinformationen wie Namen, Beschreibungen, Bilder und mehr aus Otto.de extrahieren.

Viel Spaß beim Scrapen!

### Eingabe 📥

Um diesen Actor zu verwenden, müssen Sie die folgenden Eingaben bereitstellen:

- Feld: **startUrls**
  - Typ: Array
  - Erforderlich: Ja
  - Beschreibung: Such- oder Produkt-URLs zum Scrapen
- Feld: **maxItems**
  - Typ: Integer
  - Erforderlich: Nein
  - Beschreibung: Die Anzahl der zu scrapenden Artikel. (bei Suche)
- Feld: **proxyConfiguration**
  - Typ: Objekt
  - Erforderlich: Nein
  - Beschreibung: Ihre Proxy-Konfiguration von Apify

### Wie bekomme ich startUrls?

1. Ein einzelnes Produkt

   Öffnen Sie das Produkt auf [Otto](https://www.otto.de) und kopieren Sie den Link aus der Browser-URL-Leiste.

2. Suche

   2.1. Öffnen Sie die [Otto](https://www.otto.de) Website.

   2.2. Navigieren Sie zu einer Kategorie oder Suche, die Sie interessiert.

   2.3. Sobald Sie sich auf der Suchseite befinden, fügen Sie alle benötigten Filter auf der Seite hinzu. Dadurch ändert sich die URL in der Browser-Suchleiste. Wenn Sie fertig sind, kopieren Sie die URL und fügen Sie sie als Element im `startUrls`-Array in Apify ein.

#### Beispiele

Ein einzelnes Produkt:

```
https://www.otto.de/p/adidas-performance-eq19-run-laufschuh-laufschuh-C1537649564/#variationId=1537649612
```

Eine Suchseite (bunte Rucksäcke unter 100€):

```
https://www.otto.de/taschen/rucksaecke/?farbe=bunt&preis-in-eur~bis=100&zielgruppe=herren
```

### Ausgabe 📤

Ein Beispiel für die Ausgabe im Kaufmodus sieht folgendermaßen aus: [LINK](#output)

### FAQ

**F: Wie richte ich den Otto.de Apify Scraper ein?**

A: Um den Scraper einzurichten, benötigen Sie ein Apify-Konto. Sobald Sie ein Konto haben, können Sie über die Apify-Konsole auf den Scraper zugreifen, die erforderlichen Parameter eingeben und den Scraping-Vorgang starten.

**F: Ist die Verwendung dieses Scrapers legal?**

A: Web-Scraping unterliegt rechtlichen und ethischen Überlegungen. Stellen Sie vor der Verwendung des Otto.de Apify Scrapers sicher, dass Sie den Nutzungsbedingungen der Website, der robots.txt-Datei und allen anwendbaren Gesetzen und Vorschriften entsprechen.

**F: Wie schnell ist der Datenextraktionsprozess?**

A: Die Geschwindigkeit der Datenextraktion hängt von verschiedenen Faktoren ab, wie z.B. der Anzahl der Produkte, der Serverantwortzeit und der Komplexität der Daten. Der Scraper ist darauf ausgelegt, effizient und schnell zu sein, aber die tatsächliche Extraktionsgeschwindigkeit kann variieren.

**F: Wie kann ich die extrahierten Daten exportieren?**

A: Der Otto.de Apify Scraper ermöglicht Ihnen, die extrahierten Daten in verschiedenen Formaten wie JSON, CSV oder Excel zu exportieren. Sie können die Daten direkt aus der Apify-Konsole herunterladen oder die Apify-API verwenden, um sie in Ihre Anwendungen zu integrieren.

***

\* German translations provided by ChatGPT, let us know if you have any feedback, or if you'd like to contribute to this project.

# Actor input Schema

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

URLs to scrape

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

The number of items to be scraped.

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

Your proxy configuration from Apify

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.otto.de/haushalt/trockner/waermepumpentrockner/?l=gq&o=120&c=Trockner"
    }
  ],
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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.otto.de/haushalt/trockner/waermepumpentrockner/?l=gq&o=120&c=Trockner"
        }
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("lexis-solutions/otto-de-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.otto.de/haushalt/trockner/waermepumpentrockner/?l=gq&o=120&c=Trockner" }],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("lexis-solutions/otto-de-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 '{
  "startUrls": [
    {
      "url": "https://www.otto.de/haushalt/trockner/waermepumpentrockner/?l=gq&o=120&c=Trockner"
    }
  ],
  "maxItems": 10
}' |
apify call lexis-solutions/otto-de-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Otto.de Scraper",
        "description": "The Otto.de Apify Scraper is an automated tool for extracting valuable data from Otto.de - one of the leading e-commerce platforms in Germany. It provides businesses with insights for market analysis, competitor monitoring, and price tracking. Ideal for e-commerce and market research.",
        "version": "0.0",
        "x-build-id": "S667mNkpv2mKUI6p4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lexis-solutions~otto-de-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lexis-solutions-otto-de-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/lexis-solutions~otto-de-scraper/runs": {
            "post": {
                "operationId": "runs-sync-lexis-solutions-otto-de-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/lexis-solutions~otto-de-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-lexis-solutions-otto-de-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",
                "required": [
                    "startUrls",
                    "proxyConfiguration"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "URLs to scrape",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "type": "integer",
                        "description": "The number of items to be scraped."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Your proxy configuration from Apify",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
