> ## Documentation Index
> Fetch the complete documentation index at: https://docs.olostep.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Tracciamento dei Prezzi con Olostep
> Scopri come utilizzare Olostep per monitorare i prezzi dei prodotti su larga scala in un e-commerce.
## Panoramica
Olostep fornisce un'API di web scraping che consente il monitoraggio in tempo reale dei prezzi di milioni di prodotti su un e-commerce a intervalli regolari (ad esempio ogni poche ore) in modo scalabile ed economico.
Questo è utile per le aziende che vogliono monitorare le fluttuazioni dei prezzi, confrontare i prezzi su più siti web o tracciare le strategie di prezzo dei concorrenti.
In questa guida, vedremo come un cliente utilizza Olostep per impostare un monitoraggio automatico dei prezzi per milioni di prodotti Amazon ogni giorno.
## Perché Usare Olostep per il Monitoraggio dei Prezzi?
* **Scalabilità:** Monitora i prezzi di milioni di prodotti ogni poche ore.
* **Automazione:** Imposta attività di scraping programmate che si eseguono a orari predefiniti/intervalli regolari.
* **Formati Multipli:** Recupera i dati in formato JSON, html o markdown.
* **Parser Personalizzati:** Estrai solo le informazioni JSON rilevanti con i nostri parser o passa i tuoi all'API.
## Come Monitorare i Prezzi Usando Olostep
### Panoramica del Processo di Configurazione
Quando si monitorano prodotti su larga scala, consigliamo di utilizzare l'[endpoint Batches di Olostep](https://docs.olostep.com/api-reference/batches/create).
Questo endpoint ti consente di inviare più batch di URL (ognuno fino a 10k) da elaborare in parallelo e poi recuperare i risultati dopo 5-8 minuti. Puoi inviare più batch contemporaneamente, monitorare il loro progresso e recuperare i risultati una volta completati. In questo modo puoi elaborare milioni di URL in 15-20 minuti.
Il flusso complessivo per il monitoraggio dei prezzi usando Olostep è il seguente:
1. **Leggi i prodotti dal database e salva gli URL che vuoi monitorare in un file CSV.**
2. **Leggi i dati dal file CSV e avvia un batch usando l'endpoint batch di Olostep.** Questo viene fatto inviando i dati all'endpoint in blocchi di massimo 10.000 URL alla volta.
3. **Controlla lo stato del batch ogni 60 secondi** per monitorare il progresso.
4. **Una volta che il batch è completo, leggi il contenuto e usalo nel tuo flusso di lavoro.**
Puoi avviare un batch e ottenere il contenuto html/markdown della pagina e poi analizzarlo tu stesso per estrarre i dati che desideri. Ma consigliamo di avviare il batch con un parser in modo che ti venga restituito un oggetto JSON con solo i dati analizzati di cui hai bisogno.
Puoi passare il tuo parser all'API o utilizzare uno di quelli predefiniti che abbiamo per alcuni siti comuni (ad esempio pagine prodotto Amazon, risultati di ricerca Google, profili Linkedin, ecc...).
Conserviamo i dati per ogni batch per 7 giorni in modo che tu possa recuperarli più volte se necessario.
### Passo 1: Esporta i Dati dei Prodotti dal tuo Database
Il primo passo è recuperare le informazioni sui prodotti dal tuo database e salvarle in formato CSV. Questo file dovrebbe contenere identificatori di prodotto, URL e qualsiasi metadato aggiuntivo richiesto per il monitoraggio.
### Passo 2: Avvia un Batch con Olostep
Per avviare un batch, leggi i dati dei prodotti dal CSV e inviali all'endpoint batch di Olostep. Questo viene fatto utilizzando una richiesta HTTP POST con un payload JSON.
Ogni batch può contenere fino a 10k URL. Per dataset di grandi dimensioni (>10.000 URL), dividi in più batch e inviali in parallelo.
Un batch consiste in un array di elementi, dove ogni elemento rappresenta un URL di prodotto da elaborare. Ecco la struttura di una richiesta batch
```python theme={null}
import requests
def start_batch(batch_array):
payload = {
"batch_array": batch_array, # Array di elementi da elaborare
"batch_country": "IT", # Codice paese per il batch
"parser": "@olostep/amazon-it-product" # Opzionale: Specifica un parser personalizzato per ottenere solo i dati JSON di cui hai bisogno
}
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"]
```
#### Struttura dell'Array del Batch
Ogni elemento nel batch\_array dovrebbe seguire questa struttura:
```json filename="batch_item.json" theme={null}
{
"custom_id": "unique_identifier", // Richiesto: Il tuo identificatore univoco per l'elemento
"url": "product_url", // Richiesto: URL da elaborare
"wait_before_scraping": 0, // Opzionale: Tempo di attesa prima di eseguire lo scraping di ogni URL nel batch (in millisecondi)
}
```
Parametri
Array di elementi da elaborare. Massimo 10.000 URL per batch. Ogni elemento deve avere un `custom_id` univoco.
Codice paese a due lettere (ad es., "IT" per l'Italia).
Nome del parser personalizzato da utilizzare (ad es., "@olostep/amazon-it-product"). Contattaci a [info@olostep.com](mailto:info@olostep.com) per ottenere accesso ai parser predefiniti o per crearne uno tuo.
Risposta
```json filename="response.json" theme={null}
{
"id": "batch_54ikwskmt8"
}
```
L'endpoint restituisce un oggetto JSON contenente il batch\_id, che può essere utilizzato per monitorare lo stato e poi recuperare i risultati.
Esempio di Utilizzo
```python theme={null}
# Prepara l'array del batch
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"
}
]
# Avvia l'elaborazione del batch
batch_id = start_batch(batch_array)
print(f"Batch avviato: {batch_id}")
```
### Passo 3: Monitora lo Stato del Batch
Una volta avviato un batch, dovrai monitorare il suo stato per determinare quando l'elaborazione è completa. L'API fornisce un endpoint di stato che può essere interrogato periodicamente (ad es., ogni 60 secondi) con il batch\_id
```python filename="check_status.py" theme={null}
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"]
```
Per l'uso in produzione, è consigliato implementare un monitoraggio asincrono per gestire più batch in modo efficiente:
```python theme={null}
import asyncio
async def monitor_batch(batch_id: str) -> None:
"""Monitora un singolo batch fino al suo completamento"""
while True:
status = check_batch_status(batch_id)
if status == "completed":
print(f"Batch {batch_id} completato!")
return
print(f"Batch {batch_id} ancora in elaborazione... Controllo di nuovo tra 60 secondi")
await asyncio.sleep(60)
```
### Passo 4: Recupera gli ID per gli Elementi Completati
Una volta che il batch è contrassegnato come completato, puoi recuperare l'elenco degli elementi completati. Ogni elemento avrà un retrieve\_id. Se vuoi il contenuto effettivo usa l'endpoint retrieve passando il `retrieve_id`
```python theme={null}
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"]
```
Questo restituirà gli elementi completati che hanno ciascuno un `retrieve_id` per ogni URL inviato. Puoi quindi utilizzare l'endpoint retrieve per recuperare e memorizzare i dati estratti (html, markdown o JSON) per ogni URL.
Puoi ottenere il `retrieve_id` per ogni elemento nel batch usando il seguente codice:
```python theme={null}
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']}
---
""")
```
### Passo 5: Recupera il Contenuto per ciascun Elemento
Una volta che hai il `retrieve_id` per ciascun elemento, puoi recuperare il suo contenuto (HTML, Markdown o JSON) usando l'endpoint retrieve:
```python filename="retrieve_content.py" theme={null}
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()
# Esempio di utilizzo
retrieve_id = "product_123"
content = retrieve_content(retrieve_id)
# Se vuoi elaborare più elementi
def process_batch_content(batch_id):
items = get_completed_items(batch_id)
for item in items:
content = retrieve_content(item['retrieve_id'])
# Elabora o memorizza il contenuto come necessario
```
## Conclusione
Seguendo questi passaggi, puoi impostare un sistema di monitoraggio dei prezzi automatizzato utilizzando Olostep. A breve pubblicheremo un repository open-source su GitHub con il codice completo per questo esempio.