Prijsbewaking met Olostep

Overzicht

Olostep biedt een web scraping API die real-time prijsbewaking van miljoenen producten op een e-commerce platform mogelijk maakt op regelmatige intervallen (bijvoorbeeld elke paar uur) op een schaalbare en kosteneffectieve manier. Dit is nuttig voor bedrijven die prijsfluctuaties willen monitoren, prijzen willen vergelijken op meerdere websites, of de prijsstrategieën van concurrenten willen volgen. In deze gids zullen we zien hoe een klant Olostep gebruikt om geautomatiseerde prijsbewaking op te zetten voor miljoenen Amazon-producten per dag.

Waarom Olostep gebruiken voor prijsbewaking?

Schaalbaarheid: Volg prijzen voor miljoenen producten elke paar uur.
Automatisering: Stel geplande scraping-taken in die op vooraf bepaalde tijden/reguliere intervallen worden uitgevoerd.
Meerdere formaten: Haal gegevens op in JSON-, html- of markdown-formaat.
Aangepaste parsers: Haal alleen de relevante JSON-informatie op met onze parsers of geef je eigen parser door aan de API.

Hoe prijzen volgen met Olostep

Overzicht van het proces

Bij het volgen van producten op grote schaal raden we aan om Olostep’s Batches endpoint te gebruiken. Dit endpoint stelt je in staat om meerdere batches van URL’s (elk tot 100k) parallel te laten verwerken en vervolgens de resultaten na 5-8 minuten op te halen. Je kunt meerdere batches tegelijkertijd verzenden, hun voortgang monitoren en de resultaten ophalen zodra ze voltooid zijn. Op deze manier kun je miljoenen URL’s verwerken in 15-20 minuten. De algemene flow voor prijsbewaking met Olostep is als volgt:

Lees de producten uit de database en sla de URL’s die je wilt volgen op in een CSV-bestand.
Lees de gegevens uit het CSV-bestand en start een batch met behulp van Olostep’s batch endpoint. Dit doe je door de gegevens in stukken van maximaal 100.000 URL’s per keer naar het endpoint te posten.
Controleer elke 60 seconden de batchstatus om de voortgang te monitoren.
Zodra de batch voltooid is, lees je de inhoud en gebruik je deze in je workflow.

Je kunt een batch starten en de html/markdown-inhoud van de pagina terugkrijgen en deze zelf parseren om de gegevens te extraheren die je wilt. Maar we raden aan om de batch met een parser te starten, zodat je een JSON-object terugkrijgt met alleen de geparseerde gegevens die je nodig hebt. Je kunt je eigen parser doorgeven aan de API of een van de vooraf gebouwde parsers gebruiken die we hebben voor enkele veelvoorkomende websites (bijv. Amazon-productpagina’s, Google-zoekresultaten, LinkedIn-profielen, enz.). We slaan de gegevens voor elke batch 7 dagen op, zodat je ze meerdere keren kunt ophalen indien nodig.

Stap 1: Exporteer productgegevens uit je database

De eerste stap is om productinformatie uit je database op te halen en op te slaan in een CSV-formaat. Dit bestand moet productidentificatoren, URL’s en eventuele extra metadata bevatten die nodig zijn voor het volgen.

Stap 2: Start een batch met Olostep

Om een batch te starten, lees je de productgegevens uit de CSV en stuur je deze naar het Olostep batch endpoint. Dit doe je met een HTTP POST-verzoek met een JSON-payload. Elke batch kan maximaal 100k URL’s bevatten. Voor grote datasets (>100.000 URL’s), splits je deze in meerdere batches en stuur je ze parallel. Een batch bestaat uit een array van items, waarbij elk item een product-URL vertegenwoordigt die moet worden verwerkt. Hier is de structuur van een batchverzoek:

import requests

def start_batch(batch_array):
    payload = {
        "batch_array": batch_array,                 # Array van items om te verwerken
        "batch_country": "IT",                      # Landcode voor de batch
        "parser": "@olostep/amazon-it-product"      # Optioneel: Specificeer een aangepaste parser zodat je alleen de JSON-gegevens krijgt die je nodig hebt
    }

    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"]

Structuur van de batch array

Elk item in de batch_array moet deze structuur volgen:

{
    "custom_id": "unique_identifier",    // Vereist: Jouw unieke identificator voor het item
    "url": "product_url",               // Vereist: URL die moet worden verwerkt
    "wait_before_scraping": 0,         // Optioneel: Wachttijd voordat elke URL in de batch wordt gescraped (in milliseconden)
}

Parameters

array

vereist

Array van items om te verwerken. Maximum van 100.000 URL’s per batch. Elk item moet een unieke custom_id hebben.

string

vereist

Tweeletterige landcode (bijv. “IT” voor Italië).

string

Naam van de aangepaste parser die je wilt gebruiken (bijv. “@olostep/amazon-it-product”). Neem contact met ons op via info@olostep.com om toegang te krijgen tot de vooraf gebouwde parsers of om je eigen parser te maken.

Antwoord

{
    "id": "batch_54ikwskmt8"
}

Het endpoint retourneert een JSON-object met de batch_id, die kan worden gebruikt om de status te monitoren en vervolgens de resultaten op te halen. Voorbeeldgebruik

# Bereid batch array voor
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"
}
]

# Start batchverwerking
batch_id = start_batch(batch_array)
print(f"Batch gestart: {batch_id}")

Stap 3: Monitor de batchstatus

Zodra een batch is gestart, moet je de status ervan monitoren om te bepalen wanneer de verwerking is voltooid. De API biedt een status endpoint dat periodiek kan worden gepolld (bijv. elke 60 seconden) met de 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"]

Voor productiegebruik wordt aanbevolen om asynchrone monitoring te implementeren om meerdere batches efficiënt te verwerken:

import asyncio

async def monitor_batch(batch_id: str) -> None:
"""Monitor een enkele batch totdat deze is voltooid"""
while True:
    status = check_batch_status(batch_id)
    if status == "completed":
        print(f"Batch {batch_id} voltooid!")
        return
    print(f"Batch {batch_id} wordt nog verwerkt... Over 60 seconden opnieuw controleren")
    await asyncio.sleep(60)

Stap 4: Haal de ID’s op voor voltooide items

Zodra de batch als voltooid is gemarkeerd, kun je de lijst met voltooide items ophalen. Elk item heeft een retrieve_id. Als je de daadwerkelijke inhoud wilt, gebruik je het retrieve endpoint door de retrieve_id door te geven

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"]

Dit retourneert de voltooide items die elk een retrieve_id hebben voor elke verzonden URL. Je kunt vervolgens het retrieve endpoint gebruiken om de geëxtraheerde gegevens (html, markdown of JSON) voor elke URL op te halen en op te slaan. Je kunt de retrieve_id voor elk item in de batch ophalen met de volgende code:

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']}
    ---
    """)

Stap 5: Haal de inhoud op voor elk item

Zodra je de retrieve_id voor elk item hebt, kun je de inhoud (HTML, Markdown of JSON) ophalen met behulp van het retrieve endpoint:

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()

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

# Als je meerdere items wilt verwerken
def process_batch_content(batch_id):
items = get_completed_items(batch_id)
for item in items:
content = retrieve_content(item['retrieve_id'])
# Verwerk of sla de inhoud op zoals nodig

Conclusie

Door deze stappen te volgen, kun je een geautomatiseerd prijsbewakingssysteem opzetten met behulp van Olostep. Binnenkort zullen we een open-source GitHub-repo publiceren met de volledige code voor dit voorbeeld.

​Overzicht

​Waarom Olostep gebruiken voor prijsbewaking?

​Hoe prijzen volgen met Olostep

​Overzicht van het proces

​Stap 1: Exporteer productgegevens uit je database

​Stap 2: Start een batch met Olostep

​Structuur van de batch array

​Stap 3: Monitor de batchstatus

​Stap 4: Haal de ID’s op voor voltooide items

​Stap 5: Haal de inhoud op voor elk item

​Conclusie