Zum Hauptinhalt springen

​
Überblick

Olostep bietet eine Web-Scraping-API, die eine Echtzeit-Preisverfolgung von Millionen von Produkten auf einer E-Commerce-Plattform in regelmäßigen Abständen (z.B. alle paar Stunden) auf skalierbare und kosteneffiziente Weise ermöglicht. 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 eine 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: Daten im JSON-, HTML- oder Markdown-Format abrufen.
  • 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 den Prozessablauf

Beim Verfolgen von Produkten in großem Maßstab empfehlen wir die Verwendung des Batches-Endpunkts von Olostep. Dieser Endpunkt ermöglicht es dir, mehrere Batches von URLs (jeweils bis zu 10.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 gesamte Ablauf für die Preisverfolgung mit Olostep sieht wie folgt aus:
  1. Lese die Produkte aus der Datenbank und speichere die URLs, die du verfolgen möchtest, in einer CSV-Datei.
  2. Lese die Daten aus der CSV-Datei und starte einen Batch mit dem Batch-Endpunkt von Olostep. Dies geschieht, indem die Daten in Paketen von bis zu 10.000 URLs gleichzeitig an den Endpunkt gesendet werden.
  3. Überprüfe den Batch-Status alle 60 Sekunden, um den Fortschritt zu überwachen.
  4. Sobald der Batch abgeschlossen ist, lese den Inhalt und verwende ihn in deinem Workflow.
Du kannst einen Batch starten und den HTML/Markdown-Inhalt der Seite zurückerhalten und dann selbst analysieren, 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 analysierten 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 usw.). 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, lese die Produktdaten aus der CSV und sende sie an den Batch-Endpunkt von Olostep. Dies erfolgt mit einer HTTP-POST-Anfrage mit einer JSON-Nutzlast. Jeder Batch kann bis zu 10.000 URLs enthalten. Für große Datensätze (>10.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 zu verarbeitenden Elementen
        "batch_country": "IT",                      # Ländercode für den Batch
        "parser": "@olostep/amazon-it-product"      # Optional: Spezifiziere einen benutzerdefinierten Parser, 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
​
batch_array
array
erforderlich
Array von zu verarbeitenden Elementen. Maximal 10.000 URLs pro Batch. Jedes Element muss eine eindeutige custom_id haben.
​
batch_country
string
erforderlich
Zwei-Buchstaben-Ländercode (z.B. “IT” für Italien).
​
parser
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 (z.B. alle 60 Sekunden) mit der batch_id abgefragt werden kann. 
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, eine asynchrone Überwachung 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... In 60 Sekunden erneut prüfen")
    await asyncio.sleep(60)

​
Schritt 4: Die 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 wird die abgeschlossenen Elemente zurückgeben, 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 folgendem 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.