Naar hoofdinhoud gaan

​
Overzicht

Olostep biedt een web scraping API die real-time prijsvolging van miljoenen producten op een e-commerce platform mogelijk maakt op regelmatige intervallen (bijv. 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 prijsstrategieën van concurrenten willen volgen. In deze gids zullen we zien hoe een klant Olostep gebruikt om geautomatiseerde prijsvolging voor miljoenen Amazon-producten dagelijks op te zetten.

​
Waarom Olostep Gebruiken voor Prijs Volgen?

  • Schaalbaarheid: Volg prijzen voor miljoenen producten elke paar uur.
  • Automatisering: Stel geplande scraping-taken in die op vooraf bepaalde tijden/regelmatige 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 te Volgen met Olostep

​
Overzicht van het Proces

Bij het volgen van producten op 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 10k) parallel te laten verwerken en vervolgens de resultaten na 5-8 minuten op te halen. Je kunt meerdere batches tegelijk verzenden, hun voortgang monitoren en de resultaten ophalen zodra ze compleet zijn. Op deze manier kun je miljoenen URL’s in 15-20 minuten verwerken. De algemene flow voor prijsvolging met Olostep is als volgt:
  1. Lees de producten uit de database en sla de URL’s die je wilt volgen op in een CSV-bestand.
  2. Lees de gegevens uit het CSV-bestand en start een batch met Olostep’s batch endpoint. Dit gebeurt door de gegevens in stukken van maximaal 10.000 URL’s per keer naar het endpoint te posten.
  3. Controleer elke 60 seconden de batchstatus om de voortgang te monitoren.
  4. Zodra de batch compleet is, lees de inhoud en gebruik deze in je workflow.
Je kunt een batch starten en de html/markdown inhoud van de pagina terugkrijgen en deze vervolgens zelf parsen om de gegevens die je wilt extraheren. 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, etc…). We slaan de gegevens voor elke batch 7 dagen op, zodat je deze 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 deze in een CSV-formaat op te slaan. 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 gebeurt met een HTTP POST-verzoek met een JSON-payload. Elke batch kan maximaal 10k URL’s bevatten. Voor grote datasets (>10.000 URL’s), splits in meerdere batches en stuur 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: Je unieke identificator voor het item
    "url": "product_url",               // Vereist: URL om te verwerken
    "wait_before_scraping": 0,         // Optioneel: Wachttijd voordat elke url in de batch wordt gescrapet (in milliseconden)
}
Parameters
​
batch_array
array
vereist
Array van items om te verwerken. Maximaal 10.000 URL’s per batch. Elk item moet een unieke custom_id hebben.
​
batch_country
string
vereist
Tweeletterige landcode (bijv. “IT” voor Italië).
​
parser
string
Naam van de aangepaste parser om te 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 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. Voorbeeld Gebruik 
# 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 Batch Status

Zodra een batch is gestart, moet je de status monitoren om te bepalen wanneer de verwerking is voltooid. De API biedt een status endpoint dat periodiek kan worden gepolst (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 zal een retrieve_id hebben. Als je de daadwerkelijke inhoud wilt, gebruik dan 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 zal de voltooide items retourneren 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 verkrijgen 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()

# Voorbeeld gebruik
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 prijsvolgsysteem opzetten met Olostep. Binnenkort zullen we een open-source github repo publiceren met de volledige code voor dit voorbeeld.