Scrapling analizza 5,000 elementi in 1.99 millisecondi. La parte Cloudflare è più difficile da vendere.

D4Vinci/Scrapling è entrato nella classifica settimanale di GitHub con circa 8,700 stelle in sette giorni, per un totale di 99,671. È un framework di scraping per Python, una categoria affollata, e non punta a vincere sulla dimensione. La promessa della prima riga del README: mettere richieste HTTP veloci, browser stealth, parsing e crawling concorrente in un'unica libreria, che è la descrizione di quattro librerie di solito incollate insieme.
Il numero che si cita è un benchmark. Estrazione di testo su 5,000 elementi annidati: Scrapling a 1.99 ms, Parsel/Scrapy a 2.06, lxml puro a 2.56, PyQuery a 23.98, Selectolax a 197.02, MechanicalSoup a 1,545.15, BeautifulSoup con lxml a 1,562.1, BeautifulSoup con html5lib a 3,412.73. Medie su cento esecuzioni, secondo il README.
Leggi quella tabella due volte e dice meno di quanto sembri. I primi tre stanno entro il 30% l'uno dall'altro, e tutti e tre sono parser basati su lxml con involucri diversi. Il divario di 780x rispetto a BeautifulSoup è reale, ed è reale da dieci anni. Scrapling si colloca nel rumore di lxml facendo molto più che parsare, il che è un buon risultato e un'altra affermazione.
L'installazione ha due passaggi e il primo è una trappola
pip install scrapling
Questo installa il motore di parsing e le sue dipendenze. Nient'altro. Importando da `scrapling.fetchers` o `scrapling.spiders` si ottiene un `ModuleNotFoundError`, perché i fetcher sono distribuiti come extra:
pip install "scrapling[fetchers]"
scrapling install
Il secondo comando scarica browser e dipendenze di sistema. Salta quello e i fetcher stealth non hanno niente da guidare. Altri extra: `scrapling[ai]` per il server MCP, `scrapling[rag]` per output markdown pensato per il retrieval, `scrapling[shell]` per la shell interattiva e il comando `extract`, `scrapling[all]` per tutto. Le immagini Docker esistono su `pyd4vinci/scrapling` e sul registry di GitHub.
La separazione si difende. Un parser non ha motivo di trascinarsi un browser. Significa comunque che ogni tutorial che inizia con `pip install scrapling` produce un traceback alla seconda riga, e il README spende il primo avviso esattamente su questo.

Due fetcher, due lavori diversi
La chiamata di base, quella che scrivono tutti:
from scrapling.fetchers import Fetcher
page = Fetcher.get('https://quotes.toscrape.com/') quotes = page.css('.quote .text::text').getall() ```
`FetcherSession(impersonate='chrome')` mantiene una sessione e imita l'impronta TLS di un browser, cosa che conta per i siti che identificano l'handshake invece della stringa user agent. Supporta anche HTTP/3.
L'altro fetcher è quello che il progetto vende davvero:
from scrapling.fetchers import StealthyFetcher
page = StealthyFetcher.fetch('https://nopecha.com/demo/cloudflare', solve_cloudflare=True) ```
`StealthySession` tiene aperto un browser headless, risolve Cloudflare Turnstile e i controlli interstiziali, e supporta `record_requests=True` più `session.network.search()` per catturare le chiamate API che la pagina fa in background. Quest'ultima funzione cambia il modo di lavorare. Gran parte dello scraping non consiste nel leggere HTML, ma nel trovare l'endpoint JSON che la pagina chiama e chiamarlo direttamente. Uno strumento che espone quelle richieste risparmia un pomeriggio nei dev tools.
Ci sono anche `ProxyRotator` per ruotare i proxy, protezione dalle perdite DNS via DoH con Cloudflare, blocco di circa 3,500 domini noti di pubblicità e tracciamento, e un'opzione `cdp_url` per agganciarsi a un browser remoto.
L'API Spider ha la forma di Scrapy di proposito
from scrapling.spiders import Spider, Response
class QuotesSpider(Spider): name = "quotes" start_urls = ["https://quotes.toscrape.com/"] concurrent_requests = 10
async def parse(self, response: Response): for quote in response.css('.quote'): yield {"text": quote.css('.text::text').get(), "author": quote.css('.author::text').get()} nxt = response.css('.next a') if nxt: yield response.follow(nxt[0].attrib['href'])
result = QuotesSpider().start() result.items.to_json("quotes.json") ```
`start_urls`, `parse` asincrono, dict in yield, oggetti `Request` e `Response`: chi ha scritto uno spider Scrapy legge questo senza aprire la documentazione. Il framework aggiunge throttling per dominio con AutoThrottle, `robots_txt_obey`, un `LinkExtractor`, rilevamento delle richieste bloccate con retry, e una modalità sviluppo che mette in cache le risposte su disco per ripetere un crawl senza toccare di nuovo il sito.
`crawldir` è la funzione che farà risparmiare più tempo in pratica. Passi una directory e Ctrl+C salva le richieste in sospeso e gli URL già visti; riparti con la stessa directory e il crawl riprende. I crawl lunghi falliscono, e un framework che presume il contrario è un framework da sorvegliare.
Ci sono template per le forme comuni: `CrawlSpider`, `SitemapSpider`, spider per feed XML e CSV, e `ShopifySpider`, che legge gli endpoint pubblici di collezione di uno store ed emette un item per variante. L'export è integrato: `to_json`, `to_jsonl`, `to_csv`, `to_xml`.
L'oggetto selector è la parte sottovalutata
Le pagine parse restituiscono un oggetto `Selector` invece di una lista di nodi. Supporta CSS, XPath, `find_all`, `find_by_text`, ricerca regex e navigazione: `.next`, `.parent`, `.below_elements`, `find_similar()`. C'è una funzione di tracciamento degli elementi che rilocalizza un target dopo un restyling del sito, ed è il problema di manutenzione che uccide gli scraper di lungo corso. Non funzionerà sempre, e quando funziona evita una riscrittura.
Il parser gira anche da solo: `Selector("...")` senza chiamata di rete, ed è così che si testano unitariamente le logiche di estrazione.
Il server MCP, e perché una libreria di scraping ora ne include uno
`scrapling[ai]` aggiunge un server MCP perché un agent possa chiamare i fetcher direttamente, screenshot, sessioni loggate e API di background catturate comprese. Il README cita la protezione da prompt injection, ed è la preoccupazione giusta: uno scraper che passa il testo di una pagina a un modello è un canale per tutto ciò che la pagina vuole far leggere al modello.
Questa scelta di packaging dice dove i maintainer pensano che siano gli utenti. Un anno fa una libreria di scraping la usava un data engineer dentro uno script. Ora è anche uno strumento che un agent raccoglie a metà task, e l'interfaccia che gli serve è una tool call con uno schema.
La riga del README che fa il lavoro vero
Sepolta verso la fine: "This library is provided for educational and research purposes only." Più una richiesta di rispettare i termini di servizio e robots.txt.
È un disclaimer standard e legalmente vale poco. Descrive però la situazione reale con precisione. La capacità tecnica di superare un controllo anti-bot e il permesso legale di farlo non hanno rapporto, e il secondo peggiora. Siti che tolleravano lo scraping ora fanno causa, bloccano all'edge o vendono l'accesso. Un framework che rende banale l'elusione sposta la decisione da "posso" a "dovrei", e la sposta su chi lancia lo script.
La tabella del benchmark porterà le stelle. La trappola dell'installazione porterà le issue. A decidere se questo repository sarà utile fra due anni è se i maintainer tengono aggiornato lo strato stealth, perché quello è un tapis roulant e il parsing no.
Articoli correlati
Un foglio di calcolo comunitario di tocchi che spegne la pubblicità negli Android cinesi
Non tocca il sistema, non sblocca niente, non flasha niente. Ribalta solo gli interruttori che i produttori hanno già previsto. Il prezzo è una lista che qualcuno deve continuare a scrivere.
GPT Image 2.6 ha tenuto il prezzo dei token e alzato la fattura
GPT Image 2.6 conserva ogni tariffa per token di 2.5 e costa comunque di più per immagine, perché buona parte del lavoro passa ora nei token di output. Undici giorni dopo il lancio, la struttura dei prezzi dice più della classifica.
Qualcuno ha ricostruito IDM dall'esterno e ha scritto cosa non ha toccato
Una reimplementazione in Rust di Internet Download Manager promette 5 volte la velocità e 86 lingue. Il documento più interessante è il paragrafo che spiega come è stata costruita senza copiare nulla.
Rune è un framework UI per Rust costruito perché un agente possa verificare il proprio lavoro
Rune renderizza headless, esporta il suo albero di elementi e accetta input scriptato, dando a un agente di coding un segnale diffabile che nessuno screenshot può offrire. Il framework è in pre-release e non accetta pull request.