Passer au contenu principal

​
Vue d’ensemble

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. Cela 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 mettre en place 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 complets. 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 :
  1. Lire les produits de la base de données et enregistrer les URLs que vous souhaitez suivre dans un fichier CSV.
  2. Lire les données du fichier CSV et démarrer un lot en utilisant le point de terminaison batch d’Olostep. Cela se fait en postant les données au point de terminaison par morceaux de jusqu’à 10 000 URLs à la fois.
  3. Vérifiez le statut du lot toutes les 60 secondes pour surveiller la progression.
  4. 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 le parser vous-même pour extraire les données souhaitées. Mais nous recommandons de démarrer le lot avec un parseur afin de recevoir 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 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 de 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 toute autre métadonnée nécessaire 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’à 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 lots

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 le scraping de 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 lots
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 efficacement plusieurs lots : 
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} toujours en cours de traitement... Vérification à nouveau dans 60 secondes")
    await asyncio.sleep(60)

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

Une fois que le lot est marqué comme terminé, vous pouvez récupérer la liste des éléments complété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 complété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 mettre en place 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.