Suivi des prix avec Olostep

Aperçu

Olostep fournit une API de web scraping qui permet le suivi en temps réel des prix 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 des 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’à 100k) à traiter en parallèle et de récupérer ensuite 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 de 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 batch d’Olostep. Cela se fait en envoyant les données au point de terminaison par morceaux de jusqu’à 100 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 de ceux 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 de votre base de données et à les enregistrer au format CSV. Ce fichier doit contenir les identifiants des produits, les URLs, et toutes les métadonnées supplémentaires nécessaires pour le suivi.

Étape 2 : Démarrer un lot avec Olostep

Pour démarrer un lot, lisez les données des produits à partir du CSV et envoyez-les au point de terminaison batch d’Olostep. Cela se fait en utilisant une requête HTTP POST avec une charge utile JSON. Chaque lot peut contenir jusqu’à 100k URLs. Pour les ensembles de données volumineux (>100 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 dont vous avez besoin
    }

    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

array

requis

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

string

requis

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

string

Nom du parseur personnalisé à utiliser (par exemple, “@olostep/amazon-it-product”). Contactez-nous à info@olostep.com pour obtenir l’accès 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é, tu devras 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 seul lot 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} 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é, tu peux récupérer la liste des éléments terminés. Chaque élément aura un retrieve_id. Si tu veux le contenu réel, utilise 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 retournera les éléments terminés qui ont chacun un retrieve_id pour chaque URL envoyée. Tu peux ensuite utiliser le point de terminaison retrieve pour récupérer et stocker les données extraites (html, markdown ou JSON) pour chaque URL. Tu peux obtenir le retrieve_id pour chaque élément du 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 tu as le retrieve_id pour chaque élément, tu peux 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 tu veux 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'])
# Traiter ou stocker le contenu selon les besoins

Conclusion

En suivant ces étapes, tu peux configurer un système de suivi des prix automatisé en utilisant Olostep. Bientôt, nous publierons un dépôt github open-source 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