AI per Web Scraping — Agenti che Navigano e Raccolgono Dati

Il tuo scraper si rompe ogni volta che il sito target cambia un div o aggiunge un CAPTCHA? E quando i contenuti sono caricati via JavaScript, lo script prende solo pagine vuote. Lo vediamo spesso nei clienti che arrivano da noi con pipeline di estrazione dati fragili, costruite su selettori statici e regex. Il problema non è la tecnica, è l’approccio: stai chiedendo a un programma di fare quello che un umano fa naturalmente — capire dove stanno i dati e adattarsi. Con l’AI generativa puoi trasformare lo scraping in una navigazione intelligente, dove l’agente decide come interagire con la pagina. Vediamo come funziona e come costruirne uno.

Perché il web scraping tradizionale sta diventando obsoleto?

Se hai mai costruito uno scraper con Requests + BeautifulSoup o Scrapy, sai il dolore: basta che il sito ristrutturi il CSS, cambi gli ID o introduca un caricamento asincrono, e il tuo script va in bianco. Aggiungici i CAPTCHA moderni, i Cloudflare challenge e il rate limiting aggressivo, e il gioco è finito. I siti sono sempre più dinamici: React, Vue, SPA. Lo scraper tradizionale non “vede” il DOM renderizzato — serve un browser headless. Ma anche con Puppeteer o Playwright, la logica di estrazione resta rigida: devi aggiornare manualmente i selettori a ogni modifica. È una guerra di logoramento che il tuo budget non può vincere.

Il costo nascosto dello scraping manuale

Noi di Meteora Web abbiamo seguito clienti che spendevano ore a riparare script di scraping ogni settimana. Tradotto: €500+ al mese in manutenzione, per dati che arrivano in ritardo o incompleti. La soluzione non è uno script più robusto — è un agente che capisce cosa deve prendere e dove andare.

Differenza chiave: lo scraper classico esegue istruzioni fisse. L'agente AI interpreta un obiettivo (es. “prendi il prezzo di tutti i prodotti su questa pagina”) e si muove da solo, cliccando, scrollando, e estraendo ciò che serve.

Come funziona un agente AI per lo scraping?

L’idea è semplice: invece di scrivere driver.find_element(By.CLASS_NAME, 'price'), dai all’agente un comando in linguaggio naturale. L’agente usa un modello linguistico (LLM) per decidere le azioni da compiere sul browser — cliccare su un bottone, leggere un testo, navigare a un URL. Poi esegue con un tool di automazione (Playwright, Puppeteer) e restituisce il risultato all’LLM per valutare se l’obiettivo è raggiunto.

Architettura tipica di un agente scraping

LLM orchestratore (GPT-4, Claude 3.5, o modelli locali come Llama 3) – riceve il compito e decide i passi.
Browser headless (Playwright, Puppeteer) – esegue le azioni (click, scroll, estrazione).
Funzioni strumento – ogni azione è una funzione chiamabile dall’LLM (es. click_element(selector), extract_text(selector)).
Memoria – l’agente tiene traccia dello stato della pagina e dei dati già raccolti per non ripetere azioni.

L’agente esegue un loop: osserva il DOM (spesso semplificato in un sommario testuale), decide la prossima azione, la esegue, analizza il risultato, e continua fino al completamento.

Quali strumenti usare per creare un agente di scraping con AI?

Esistono già framework pronti, ma spesso conviene costruire una soluzione su misura per avere controllo sui costi e sulla latenza. Ecco le tre strade principali.

1. Crawl4AI – il più veloce per cominciare

Crawl4AI è una libreria Python open-source progettata per estrarre dati da siti con AI. Supporta LLM locali e remoti, estrazione strutturata, e gestione automatica di JavaScript. Perfetto se vuoi uno scraper “intelligente” senza scrivere da zero il loop decisionale.

import asyncio
from crawl4ai import AsyncWebCrawler

async def main():
    async with AsyncWebCrawler(verbose=True) as crawler:
        result = await crawler.arun(
            url="https://example.com/prodotti",
            bypass_cache=True,
            extraction_strategy="llm",
            llm_config={"provider": "openai/gpt-4", "api_token": "sk-..."}
        )
        print(result.extracted_content)

asyncio.run(main())

Attenzione: Crawl4AI usa token API. Valuta il costo per pagina: un LLM potente può consumare $0.01–0.03 per richiesta. Per grandi volumi, usa modelli più piccoli (Llama 3 8B) su GPU locale.

2. OpenAI Functions + Playwright – controllo granulare

Se hai bisogno di logiche complesse (es. login, paginazione dinamica, modali), costruisci tu il loop con le function calling di OpenAI.

from openai import OpenAI
from playwright.async_api import async_playwright
import json

client = OpenAI(api_key="sk-...")

async def navigate(url: str) -> str:
    async with async_playwright() as p:
        browser = await p.chromium.launch()
        page = await browser.new_page()
        await page.goto(url)
        # Ottieni il sommario della pagina (titoli, link, testi brevi)
        summary = await page.evaluate('''() => {
            return JSON.stringify({
                title: document.title,
                links: Array.from(document.querySelectorAll('a')).slice(0,10).map(a => a.href),
                text: document.body.innerText.substring(0,2000)
            });
        }''')
        await browser.close()
        return summary

functions = [
    {
        "name": "navigate",
        "description": "Naviga a un URL e restituisce un sommario della pagina",
        "parameters": {
            "type": "object",
            "properties": {
                "url": {"type": "string", "description": "URL completo"}
            },
            "required": ["url"]
        }
    }
]

# Loop decisionale dell'agente
messages = [{"role": "system", "content": "Sei un assistente che estrae dati da siti web. Usa navigate per esplorare le pagine."},
            {"role": "user", "content": "Trova il prezzo del prodotto 'iPhone 16' su un e-commerce."}]

# Chiamata iniziale
response = client.chat.completions.create(
    model="gpt-4",
    messages=messages,
    functions=functions,
    function_call="auto"
)

Poi gestisci la risposta, esegui la funzione e continui finché l’LLM non restituisce il dato finale.

3. Browser-use – agente preconfigurato

Browser-use è un progetto che integra LLM e Playwright in un agente già pronto. Basta descrivere il compito in linguaggio naturale e lui esegue. Utile per prototipi, ma meno flessibile per siti con modelli di interazione unici.

Come evitare blocchi e gestire il rate limiting con un agente?

Anche l’agente più intelligente viene bloccato se si comporta come un bot. La differenza è che l’AI può imitare un umano: muovere il mouse, scrollare naturalmente, attendere tempi casuali. Ecco le pratiche che usiamo nei nostri progetti.

Rotazione dei proxy e user-agent

Non usare mai un solo IP su larga scala. Integra proxy residenziali (es. BrightData, Oxylabs) e cambia user-agent a ogni richiesta. Con Playwright puoi impostare un proxy per sessione:

browser = await p.chromium.launch(proxy={"server": "http://proxy:8080"})

Ruota anche il viewport, la lingua del browser e i cookie iniziali per sembrare un vero utente.

Ritardi umani e comportamenti casuali

L’agente deve introdurre delay casuali tra un’azione e l’altra (1–3 secondi). Usa await page.wait_for_timeout(random.uniform(1000, 3000)). Inoltre, simula lo scroll graduale invece di saltare direttamente in fondo alla pagina.

Gestione dei CAPTCHA

Se il sito presenta reCAPTCHA, hai tre opzioni:

Evitare il rilevamento: usa proxy residenziali e comportamenti umani – molti siti non attivano il CAPTCHA se non percepiscono attività sospetta.
Servizi di risoluzione a pagamento: 2Captcha, Capsolver – integrabili via API, costo ~$0.001 per CAPTCHA.
Vision AI: per CAPTCHA semplici (testo distorto), usa un modello OCR + LLM. Non consigliato per reCAPTCHA v3.

Esempio pratico: un agente che estrae listini da e-commerce concorrenti

Mettiamo insieme tutto: un agente che naviga su un e-commerce di abbigliamento (es. Zalando, ma con IP italiano) e raccoglie nome, prezzo e disponibilità di tutti i giacche invernali. Usiamo Playwright + OpenAI con funzione di estrazione.

import asyncio
from playwright.async_api import async_playwright
from openai import OpenAI
import json
import random

client = OpenAI(api_key="sk-...")

async def extract_products(url: str) -> list:
    async with async_playwright() as p:
        browser = await p.chromium.launch(headless=True)
        context = await browser.new_context(
            user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
            locale="it-IT",
            viewport={"width": 1920, "height": 1080}
        )
        page = await context.new_page()
        await page.goto(url, wait_until="networkidle")
        # Scroll lento umano
        for _ in range(5):
            await page.evaluate("window.scrollBy(0, window.innerHeight * 0.2)")
            await asyncio.sleep(random.uniform(0.5, 1.5))
        # Estrai il DOM ridotto per l'agente
        dom_snapshot = await page.evaluate('''() => {
            function extract(element, depth=0) {
                if (depth > 3) return '';
                let items = [];
                for (let child of element.children) {
                    let tag = child.tagName.toLowerCase();
                    if (['script', 'style', 'noscript'].includes(tag)) continue;
                    let text = child.innerText?.substring(0,200);
                    if (text) items.push({tag, text, children: extract(child, depth+1)});
                }
                return items;
            }
            return JSON.stringify(extract(document.body));
        }''')
        await browser.close()
        # Chiedi all'LLM di estrarre i prodotti
        response = client.chat.completions.create(
            model="gpt-4o-mini",  # più economico
            messages=[
                {"role": "system", "content": "Estrai tutti i prodotti dalla pagina. Restituisci un array JSON con oggetti {nome, prezzo, disponibile: true/false}."},
                {"role": "user", "content": f"Ecco la struttura della pagina: {dom_snapshot[:10000]}"}
            ]
        )
        content = response.choices[0].message.content
        # Estrai JSON dalla risposta (può contenere markdown)
        import re
        json_match = re.search(r'\[.*\]', content, re.DOTALL)
        if json_match:
            return json.loads(json_match.group())
        return []

asyncio.run(extract_products("https://www.zalando.it/giacche-invernali/"))

Attenzione: Questo codice è dimostrativo. In produzione devi gestire errori, paginazione, e limitare la dimensione del DOM inviato all’API. Noi usiamo una strategia di “taglia e incolla” selettiva per ridurre i costi.

Cosa fare adesso

Abbiamo visto il problema, i concetti, gli strumenti e un esempio concreto. Ora tocca a te.

Crea un agente minimale con un LLM economico (GPT-4o-mini o Claude 3 Haiku) e un sito semplice che non blocchi. Prova a estrarre titoli e link da una pagina statica.
Testa il comportamento umano: aggiungi proxy e ritardi, verifica che il CAPTCHA non scatti.
Misura i costi: calcola quanti token consumi per pagina. Con GPT-4o-mini, una pagina con ~2000 token di input e 200 di output costa circa $0.0006. Per 1000 pagine, $0.60. Molto meno di uno sviluppatore che ripara script ogni settimana.
Applica il pattern a un caso reale: estrai i prezzi di un concorrente per il tuo settore (abbigliamento, elettronica, alimentari). Ricorda: rispetta le condizioni d’uso e la frequenza.
Leggi la documentazione di Playwright Python e OpenAI Function Calling per approfondire.

Noi di Meteora Web usiamo questi agenti per monitorare i prezzi della concorrenza per i nostri clienti e-commerce. Se hai bisogno di una pipeline robusta o di un agente su misura, consulta il nostro pillar sull’AI agentica o parlane con noi.