Suivi des prix avec Olostep

Aperçu

Olostep fournit une API de scraping web qui permet le suivi des prix en temps réel de millions de produits sur un site e-commerce à intervalles réguliers (par exemple, toutes les quelques heures) de manière évolutive et économique. Ceci est utile pour les entreprises qui souhaitent surveiller les fluctuations de prix, comparer les prix sur plusieurs sites web, ou suivre les stratégies de tarification des concurrents. Dans ce guide, nous verrons comment un client utilise Olostep pour configurer un suivi automatisé des prix pour des millions de produits Amazon quotidiennement.

Pourquoi utiliser Olostep pour le suivi des prix ?

Évolutivité : Suivez les prix de millions de produits toutes les quelques heures.
Automatisation : Configurez des tâches de scraping planifiées qui s’exécutent à des moments prédéfinis/intervalles réguliers.
Formats multiples : Récupérez les données au format JSON, html ou markdown.
Parseurs personnalisés : Extrayez uniquement les informations JSON pertinentes avec nos parseurs ou passez les vôtres à l’API.

Comment suivre les prix avec Olostep

Aperçu de la configuration du processus

Lors du suivi de produits à grande échelle, nous recommandons d’utiliser le point de terminaison Batches d’Olostep. Ce point de terminaison vous permet d’envoyer plusieurs lots d’URLs (chacun jusqu’à 10 000) à traiter en parallèle, puis de récupérer les résultats après 5 à 8 minutes. Vous pouvez envoyer plusieurs lots en même temps, surveiller leur progression et récupérer les résultats une fois qu’ils sont terminés. De cette manière, vous pouvez traiter des millions d’URLs en 15 à 20 minutes. Le flux global pour le suivi des prix avec Olostep est le suivant :

Lisez les produits depuis la base de données et enregistrez les URLs que vous souhaitez suivre dans un fichier CSV.
Lisez les données du fichier CSV et démarrez un lot en utilisant le point de terminaison de lot d’Olostep. Cela se fait en envoyant les données au point de terminaison par morceaux de jusqu’à 10 000 URLs à la fois.
Vérifiez le statut du lot toutes les 60 secondes pour surveiller la progression.
Une fois le lot terminé, lisez le contenu et utilisez-le dans votre flux de travail.

Vous pouvez démarrer un lot et obtenir le contenu html/markdown de la page, puis l’analyser vous-même pour extraire les données souhaitées. Mais nous recommandons de démarrer le lot avec un parseur afin que vous receviez un objet JSON contenant uniquement les données analysées dont vous avez besoin. Vous pouvez passer votre propre parseur à l’API ou utiliser l’un des parseurs préconstruits que nous avons pour certains sites web courants (par exemple, pages de produits Amazon, résultats de recherche Google, profils Linkedin, etc.). Nous stockons les données pour chaque lot pendant 7 jours afin que vous puissiez les récupérer plusieurs fois si nécessaire.

Étape 1 : Exporter les données des produits depuis votre base de données

La première étape consiste à récupérer les informations sur les produits depuis votre base de données et à les enregistrer au format CSV. Ce fichier doit contenir les identifiants des produits, les URLs, et toute métadonnée supplémentaire requise pour le suivi.

Étape 2 : Démarrer un lot avec Olostep

Pour démarrer un lot, lisez les données des produits depuis le CSV et envoyez-les au point de terminaison de lot d’Olostep. Cela se fait à l’aide d’une requête HTTP POST avec une charge utile JSON. Chaque lot peut contenir jusqu’à 10 000 URLs. Pour les ensembles de données volumineux (>10 000 URLs), divisez-les en plusieurs lots et envoyez-les en parallèle. Un lot se compose d’un tableau d’éléments, où chaque élément représente une URL de produit à traiter. Voici la structure d’une requête de lot

import requests

def start_batch(batch_array):
    payload = {
        "batch_array": batch_array,                 # Tableau d'éléments à traiter
        "batch_country": "IT",                      # Code pays pour le lot
        "parser": "@olostep/amazon-it-product"      # Optionnel : Spécifiez un parseur personnalisé pour obtenir uniquement les données JSON nécessaires
    }

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

Structure du tableau de lot

Chaque élément dans le batch_array doit suivre cette structure :

{
    "custom_id": "unique_identifier",    // Requis : Votre identifiant unique pour l'élément
    "url": "product_url",               // Requis : URL à traiter
    "wait_before_scraping": 0,         // Optionnel : Temps d'attente avant de scraper chaque URL dans le lot (en millisecondes)
}

Paramètres

batch_array

array

requis

Tableau d’éléments à traiter. Maximum de 10 000 URLs par lot. Chaque élément doit avoir un custom_id unique.

batch_country

string

requis

Code pays à deux lettres (par exemple, “IT” pour l’Italie).

parser

string

Nom du parseur personnalisé à utiliser (par exemple, “@olostep/amazon-it-product”). Contactez-nous à info@olostep.com pour accéder aux parseurs préconstruits ou pour créer le vôtre.

Réponse

{
    "id": "batch_54ikwskmt8"
}

Le point de terminaison renvoie un objet JSON contenant le batch_id, qui peut être utilisé pour surveiller le statut et ensuite récupérer les résultats. Exemple d’utilisation

# Préparer le tableau de lot
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"
}
]

# Démarrer le traitement du lot
batch_id = start_batch(batch_array)
print(f"Lot démarré : {batch_id}")

Étape 3 : Surveiller le statut du lot

Une fois qu’un lot est démarré, vous devrez surveiller son statut pour déterminer quand le traitement est terminé. L’API fournit un point de terminaison de statut qui peut être interrogé périodiquement (par exemple, toutes les 60 secondes) avec le 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"]

Pour une utilisation en production, il est recommandé de mettre en œuvre une surveillance asynchrone pour gérer plusieurs lots efficacement :

import asyncio

async def monitor_batch(batch_id: str) -> None:
"""Surveiller un lot unique jusqu'à ce qu'il soit terminé"""
while True:
    status = check_batch_status(batch_id)
    if status == "completed":
        print(f"Lot {batch_id} terminé !")
        return
    print(f"Lot {batch_id} toujours en cours de traitement... Nouvelle vérification dans 60 secondes")
    await asyncio.sleep(60)

Étape 4 : Récupérer les IDs pour les éléments terminés

Une fois que le lot est marqué comme terminé, vous pouvez récupérer la liste des éléments terminés. Chaque élément aura un retrieve_id. Si vous souhaitez le contenu réel, utilisez le point de terminaison retrieve en passant le retrieve_id

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

Cela renverra les éléments terminés qui ont chacun un retrieve_id pour chaque URL envoyée. Vous pouvez ensuite utiliser le point de terminaison retrieve pour récupérer et stocker les données extraites (html, markdown ou JSON) pour chaque URL. Vous pouvez obtenir le retrieve_id pour chaque élément dans le lot en utilisant le code suivant :

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

Étape 5 : Récupérer le contenu pour chaque élément

Une fois que vous avez le retrieve_id pour chaque élément, vous pouvez récupérer son contenu (HTML, Markdown, ou JSON) en utilisant le point de terminaison retrieve :

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

# Exemple d'utilisation
retrieve_id = "product_123"
content = retrieve_content(retrieve_id)

# Si vous souhaitez traiter plusieurs éléments
def process_batch_content(batch_id):
items = get_completed_items(batch_id)
for item in items:
content = retrieve_content(item['retrieve_id'])
# Traitez ou stockez le contenu selon vos besoins

Conclusion

En suivant ces étapes, vous pouvez configurer un système de suivi des prix automatisé en utilisant Olostep. Bientôt, nous publierons un dépôt open-source sur GitHub avec le code complet pour cet exemple.

​Aperçu

​Pourquoi utiliser Olostep pour le suivi des prix ?

​Comment suivre les prix avec Olostep

​Aperçu de la configuration du processus

​Étape 1 : Exporter les données des produits depuis votre base de données

​Étape 2 : Démarrer un lot avec Olostep

​Structure du tableau de lot

​Étape 3 : Surveiller le statut du lot

​Étape 4 : Récupérer les IDs pour les éléments terminés

​Étape 5 : Récupérer le contenu pour chaque élément

​Conclusion