Preisverfolgung mit Olostep

Übersicht

Olostep bietet eine Web-Scraping-API, die es ermöglicht, in Echtzeit die Preise von Millionen von Produkten auf einer E-Commerce-Plattform in regelmäßigen Abständen (z.B. alle paar Stunden) auf skalierbare und kosteneffiziente Weise zu verfolgen. Dies ist nützlich für Unternehmen, die Preisänderungen überwachen, Preise auf mehreren Websites vergleichen oder die Preisstrategien von Wettbewerbern verfolgen möchten. In diesem Leitfaden werden wir sehen, wie ein Kunde Olostep verwendet, um die automatisierte Preisverfolgung für Millionen von Amazon-Produkten täglich einzurichten.

Warum Olostep für die Preisverfolgung verwenden?

Skalierbarkeit: Verfolge Preise für Millionen von Produkten alle paar Stunden.
Automatisierung: Richte geplante Scraping-Aufgaben ein, die zu vordefinierten Zeiten/regelmäßigen Intervallen ausgeführt werden.
Mehrere Formate: Rufe Daten im JSON-, HTML- oder Markdown-Format ab.
Benutzerdefinierte Parser: Extrahiere nur die relevanten JSON-Informationen mit unseren Parsern oder übergebe deine eigenen an die API.

Wie man Preise mit Olostep verfolgt

Überblick über die Prozess-Einrichtung

Beim Verfolgen von Produkten in großem Maßstab empfehlen wir die Verwendung von Olosteps Batches-Endpunkt. Dieser Endpunkt ermöglicht es dir, mehrere Batches von URLs (jeweils bis zu 100.000) parallel zu verarbeiten und die Ergebnisse nach 5-8 Minuten abzurufen. Du kannst mehrere Batches gleichzeitig senden, ihren Fortschritt überwachen und die Ergebnisse abrufen, sobald sie abgeschlossen sind. Auf diese Weise kannst du Millionen von URLs in 15-20 Minuten verarbeiten. Der allgemeine Ablauf für die Preisverfolgung mit Olostep sieht wie folgt aus:

Lies die Produkte aus der Datenbank und speichere die URLs, die du verfolgen möchtest, in einer CSV-Datei.
Lies die Daten aus der CSV-Datei und starte einen Batch mit dem Olostep-Batch-Endpunkt. Dies erfolgt durch das Posten der Daten an den Endpunkt in Blöcken von bis zu 100.000 URLs gleichzeitig.
Überprüfe den Batch-Status alle 60 Sekunden, um den Fortschritt zu überwachen.
Sobald der Batch abgeschlossen ist, lies den Inhalt und verwende ihn in deinem Workflow.

Du kannst einen Batch starten und den HTML/Markdown-Inhalt der Seite zurückerhalten und ihn dann selbst parsen, um die gewünschten Daten zu extrahieren. Wir empfehlen jedoch, den Batch mit einem Parser zu starten, damit du ein JSON-Objekt mit nur den benötigten Daten erhältst. Du kannst deinen eigenen Parser an die API übergeben oder einen der vorgefertigten verwenden, die wir für einige gängige Websites haben (z.B. Amazon-Produktseiten, Google-Suchergebnisse, LinkedIn-Profile, etc.). Wir speichern die Daten für jeden Batch 7 Tage lang, sodass du sie bei Bedarf mehrfach abrufen kannst.

Schritt 1: Produktdaten aus deiner Datenbank exportieren

Der erste Schritt besteht darin, Produktinformationen aus deiner Datenbank abzurufen und im CSV-Format zu speichern. Diese Datei sollte Produktkennungen, URLs und alle zusätzlichen Metadaten enthalten, die für die Verfolgung erforderlich sind.

Schritt 2: Einen Batch mit Olostep starten

Um einen Batch zu starten, lies die Produktdaten aus der CSV und sende sie an den Olostep-Batch-Endpunkt. Dies erfolgt mit einer HTTP-POST-Anfrage mit einer JSON-Nutzlast. Jeder Batch kann bis zu 100.000 URLs enthalten. Für große Datensätze (>100.000 URLs) teile sie in mehrere Batches auf und sende sie parallel. Ein Batch besteht aus einem Array von Elementen, wobei jedes Element eine zu verarbeitende Produkt-URL darstellt. Hier ist die Struktur einer Batch-Anfrage:

import requests

def start_batch(batch_array):
    payload = {
        "batch_array": batch_array,                 # Array von Elementen zur Verarbeitung
        "batch_country": "IT",                      # Ländercode für den Batch
        "parser": "@olostep/amazon-it-product"      # Optional: Einen benutzerdefinierten Parser angeben, um nur die benötigten JSON-Daten zu erhalten
    }

    headers = {
        "Authorization": "Bearer YOUR_API_KEY",
        "Content-Type": "application/json"
    }

    response = requests.post(
        "https://api.olostep.com/v1/batches",
        headers=headers,
        json=payload
    )

    return response.json()["id"]

Struktur des Batch-Arrays

Jedes Element im batch_array sollte dieser Struktur folgen:

{
    "custom_id": "unique_identifier",    // Erforderlich: Deine eindeutige Kennung für das Element
    "url": "product_url",               // Erforderlich: Zu verarbeitende URL
    "wait_before_scraping": 0,         // Optional: Wartezeit vor dem Scraping jeder URL im Batch (in Millisekunden)
}

Parameter

array

erforderlich

Array von Elementen zur Verarbeitung. Maximal 100.000 URLs pro Batch. Jedes Element muss eine eindeutige custom_id haben.

string

erforderlich

Zweibuchstabiger Ländercode (z.B. “IT” für Italien).

string

Name des zu verwendenden benutzerdefinierten Parsers (z.B. “@olostep/amazon-it-product”). Kontaktiere uns unter info@olostep.com, um Zugang zu den vorgefertigten Parsern zu erhalten oder um deinen eigenen zu erstellen.

Antwort

{
    "id": "batch_54ikwskmt8"
}

Der Endpunkt gibt ein JSON-Objekt zurück, das die batch_id enthält, die verwendet werden kann, um den Status zu überwachen und dann die Ergebnisse abzurufen. Beispielverwendung

# Batch-Array vorbereiten
batch_array = [
{
    "custom_id": "product_123",
    "url": "https://www.amazon.it/dp/B0CHF6Z393/?coliid=INQXTGFQF4FM4&colid=1R0NGA5NR5LSZ&psc=1&ref_=list_c_wl_lv_vv_lig_dp_it"
},
{
    "custom_id": "product_124",
    "url": "https://www.amazon.it/dp/B0CHMJL774/?coliid=I6CFYA5EHVHE2&colid=1R0NGA5NR5LSZ&psc=1&ref_=list_c_wl_lv_vv_lig_dp_it"
}
]

# Batch-Verarbeitung starten
batch_id = start_batch(batch_array)
print(f"Batch gestartet: {batch_id}")

Schritt 3: Batch-Status überwachen

Sobald ein Batch gestartet ist, musst du seinen Status überwachen, um festzustellen, wann die Verarbeitung abgeschlossen ist. Die API bietet einen Status-Endpunkt, der periodisch abgefragt werden kann (z.B. alle 60 Sekunden) mit der batch_id

import requests

def check_batch_status(batch_id):
headers = {"Authorization": "Bearer " + API_KEY}
response = requests.request(
"GET",
f"https://api.olostep.com/v1/batches/{batch_id}",
headers=headers
)
return response.json()["status"]

Für den Produktionseinsatz wird empfohlen, asynchrones Monitoring zu implementieren, um mehrere Batches effizient zu handhaben:

import asyncio

async def monitor_batch(batch_id: str) -> None:
"""Einen einzelnen Batch überwachen, bis er abgeschlossen ist"""
while True:
    status = check_batch_status(batch_id)
    if status == "completed":
        print(f"Batch {batch_id} abgeschlossen!")
        return
    print(f"Batch {batch_id} wird noch verarbeitet... Erneut in 60 Sekunden prüfen")
    await asyncio.sleep(60)

Schritt 4: IDs für abgeschlossene Elemente abrufen

Sobald der Batch als abgeschlossen markiert ist, kannst du die Liste der abgeschlossenen Elemente abrufen. Jedes Element hat eine retrieve_id. Wenn du den tatsächlichen Inhalt möchtest, verwende den Retrieve-Endpunkt, indem du die retrieve_id übergibst

import requests

def get_completed_items(batch_id):
    headers = {"Authorization": "Bearer YOUR_API_KEY"}
    response = requests.get(f"https://api.olostep.com/v1/batches/{batch_id}/items", headers=headers)
    return response.json()["items"]

Dies gibt die abgeschlossenen Elemente zurück, die jeweils eine retrieve_id für jede gesendete URL haben. Du kannst dann den Retrieve-Endpunkt verwenden, um die extrahierten Daten (HTML, Markdown oder JSON) für jede URL abzurufen und zu speichern. Du kannst die retrieve_id für jedes Element im Batch mit dem folgenden Code abrufen:

items = get_completed_items("your_batch_id")
for item in items:
    print(f"""
    URL: {item['url']}
    Custom ID: {item['custom_id']}
    Retrieve ID: {item['retrieve_id']}
    ---
    """)

Schritt 5: Den Inhalt für jedes Element abrufen

Sobald du die retrieve_id für jedes Element hast, kannst du dessen Inhalt (HTML, Markdown oder JSON) mit dem Retrieve-Endpunkt abrufen:

def retrieve_content(retrieve_id):
url = "https://api.olostep.com/v1/retrieve"
headers = {"Authorization": "Bearer YOUR_API_KEY"}
params = {"retrieve_id": retrieve_id}

response = requests.get(
url,
headers=headers,
params=params
)
return response.json()

# Beispielverwendung
retrieve_id = "product_123"
content = retrieve_content(retrieve_id)

# Wenn du mehrere Elemente verarbeiten möchtest
def process_batch_content(batch_id):
items = get_completed_items(batch_id)
for item in items:
content = retrieve_content(item['retrieve_id'])
# Verarbeite oder speichere den Inhalt nach Bedarf

Fazit

Indem du diesen Schritten folgst, kannst du ein automatisiertes Preisverfolgungssystem mit Olostep einrichten. In Kürze werden wir ein Open-Source-GitHub-Repo mit dem vollständigen Code für dieses Beispiel veröffentlichen.

​Übersicht

​Warum Olostep für die Preisverfolgung verwenden?

​Wie man Preise mit Olostep verfolgt

​Überblick über die Prozess-Einrichtung

​Schritt 1: Produktdaten aus deiner Datenbank exportieren

​Schritt 2: Einen Batch mit Olostep starten

​Struktur des Batch-Arrays

​Schritt 3: Batch-Status überwachen

​Schritt 4: IDs für abgeschlossene Elemente abrufen

​Schritt 5: Den Inhalt für jedes Element abrufen

​Fazit