Web Scraping senza sforzo per il Web moderno

العربيه | Español | Português (Brasil) | Français | Deutsch | 简体中文 | 日本語 | Русский | 한국어

Metodi di selezione · Fetcher · Spider · Rotazione dei proxy · CLI · MCP

Scrapling è un framework di Web Scraping adattivo che gestisce tutto, da una singola richiesta a un crawl su larga scala.

Il suo parser impara dai cambiamenti dei siti web e riposiziona automaticamente i tuoi elementi quando le pagine vengono aggiornate. I suoi fetcher bypassano i sistemi anti-bot come Cloudflare Turnstile senza configurazione aggiuntiva. E il suo framework per spider ti consente di scalare fino a crawl concorrenti e multi-sessione, con pausa/ripresa e rotazione automatica dei proxy: il tutto in poche righe di Python. Una sola libreria, zero compromessi.

Crawl fulminei con statistiche in tempo reale e streaming. Creato da chi fa scraping per chi fa scraping e per gli utenti comuni: c'è qualcosa per tutti.```python from scrapling.fetchers import Fetcher, AsyncFetcher, StealthyFetcher, DynamicFetcher StealthyFetcher.adaptive = True p = StealthyFetcher.fetch('https://example.com', headless=True, network_idle=True) # Fetch website under the radar! products = p.css('.product', auto_save=True) # Scrape data that survives website design changes! products = p.css('.product', adaptive=True) # Later, if the website structure changes, pass adaptive=True to find them!

Oppure scalare fino a crawl completi```python
from scrapling.spiders import Spider, Response

class MySpider(Spider):
  name = "demo"
  start_urls = ["https://example.com/"]

  async def parse(self, response: Response):
      for item in response.css('.product'):
          yield {"title": item.css('h2::text').get()}

MySpider().start()

Sponsor Platinum

_{Vuoi mostrare il tuo annuncio qui? Clicca qui}

Sponsor

_{Vuoi mostrare il tuo annuncio qui? Clicca qui e scegli il livello che fa per te!}

Funzionalità Principali

Spider - Un Framework di Crawling Completo

• 🕷️ API Spider simile a Scrapy: Definisci spider con start_urls, callback parse asincrone e oggetti Request/Response.
• ⚡ Crawling Concorrente: Limiti di concorrenza configurabili, throttling per dominio e ritardi di download.
• 🔄 Supporto Multi-Sessione: Interfaccia unificata per richieste HTTP e browser headless stealth in un'unica spider - instrada le richieste verso sessioni diverse in base all'ID.
• 💾 Pausa e Ripresa: Persistenza del crawl basata su checkpoint. Premi Ctrl+C per un arresto controllato; riavvia per riprendere da dove avevi interrotto.
• 📡 Modalità Streaming: Trasmetti gli elementi estratti man mano che arrivano tramite async for item in spider.stream() con statistiche in tempo reale - ideale per UI, pipeline e crawl di lunga durata.
• 🛡️ Rilevamento delle Richieste Bloccate: Rilevamento automatico e retry delle richieste bloccate con logica personalizzabile.
• 🚦 AutoThrottle: Smetti di indovinare i ritardi. La spider regola autonomamente il ritardo di ciascun dominio in base alla velocità di risposta del sito web, poi lo raddoppia (o attende quanto richiesto da Retry-After) quando il sito inizia a bloccare o limitare il traffico, e accelera di nuovo quando smette.
• 🤖 Conformità a Robots.txt: Flag opzionale robots_txt_obey che rispetta le direttive Disallow, e con caching per dominio.

Recupero Avanzato di Siti Web con Supporto alle Sessioni

• Richieste HTTP: Richieste HTTP veloci e stealth con la classe Fetcher. Può impersonare l'impronta TLS dei browser, gli header e usare HTTP/3.
• Caricamento Dinamico: Recupera siti web dinamici con automazione completa del browser tramite la classe DynamicFetcher che supporta Chromium di Playwright e Google Chrome.
• Bypass Anti-bot: Funzionalità stealth avanzate con StealthyFetcher e spoofing dell'impronta digitale. Può bypassare facilmente tutti i tipi di Turnstile/Interstitial di Cloudflare con l'automazione.
• Gestione delle Sessioni: Supporto a sessioni persistenti con le classi FetcherSession, StealthySession e DynamicSession per la gestione di cookie e stato tra le richieste.
• Rotazione dei Proxy: ProxyRotator integrato con strategie di rotazione cicliche o personalizzate su tutti i tipi di sessione, oltre a override del proxy per singola richiesta.
• Blocco di Domini e Annunci: Blocca le richieste verso domini specifici (e i loro sottodomini) oppure attiva il blocco degli annunci integrato (circa 3.500 domini noti di annunci/tracker) nei fetcher basati su browser.
• Prevenzione delle Perdite DNS: Supporto opzionale DNS-over-HTTPS per instradare le query DNS tramite il DoH di Cloudflare, prevenendo perdite DNS quando si utilizzano proxy.
• Browser Remoti: Invece di avviare un browser localmente, connettiti a uno già in esecuzione tramite CDP con cdp_url, sia sulla stessa macchina, su un altro host o tramite un provider di browser gestiti. Puoi anche puntare qualsiasi browser fetcher alla tua build di Chromium con .

Scraping Adattivo e Integrazione AI

• 🔄 Tracciamento Intelligente degli Elementi: Riposiziona gli elementi dopo i cambiamenti del sito web utilizzando algoritmi intelligenti di similarità.
• 🎯 Selezione Flessibile Intelligente: Selettori CSS, selettori XPath, ricerca basata su filtri, ricerca testuale, ricerca con regex e altro.
• 🔍 Trova Elementi Simili: Localizza automaticamente elementi simili a quelli trovati.
• 🤖 Server MCP da Usare con l'AI: Server MCP integrato per Web Scraping ed estrazione dati assistiti dall'AI. Il server MCP dispone di potenti capacità personalizzate che sfruttano Scrapling per estrarre contenuti mirati prima di passarli all'AI (Claude/Cursor/ecc.), accelerando così le operazioni e riducendo i costi minimizzando l'uso dei token. (video dimostrativo) Può anche mantenere aperte le sessioni del browser tra le chiamate, acquisire screenshot delle pagine e controllare browser remoti tramite CDP.
• 🧠 Agent Skill: Un'Agent Skill pronta da installare che insegna ai coding agent l'intera libreria, così il codice che scrivono con Scrapling corrisponde all'API attuale invece di tirare a indovinare.

Architettura ad Alte Prestazioni e Collaudata sul Campo

• 🚀 Veloce come un Fulmine: Prestazioni ottimizzate che superano la maggior parte delle librerie di scraping Python.
• 🔋 Efficiente in Memoria: Strutture dati ottimizzate e lazy loading per un'impronta di memoria minima.
• ⚡ Serializzazione JSON Veloce: 10 volte più veloce della libreria standard.
• 🏗️ Collaudata sul Campo: Non solo Scrapling ha una copertura dei test del 92% e una copertura completa dei type hint, ma è stata usata quotidianamente da centinaia di Web Scraper nell'ultimo anno.

Esperienza Amichevole per Sviluppatori/Web Scraper

• 🎯 Shell Interattiva per Web Scraping: Shell IPython opzionale integrata con integrazione Scrapling, scorciatoie e nuovi strumenti per velocizzare lo sviluppo di script di Web Scraping, come convertire le richieste curl in richieste Scrapling e visualizzare i risultati delle richieste nel tuo browser.
• 🚀 Usalo direttamente dal Terminale: Opzionalmente, puoi usare Scrapling per fare scraping di un URL senza scrivere una sola riga di codice!
• 🛠️ API di Navigazione Avanzate: Attraversamento avanzato del DOM con metodi di navigazione per elementi genitori, fratelli e figli.
• 🧬 Elaborazione Testuale Avanzata: Regex integrata, metodi di pulizia e operazioni sulle stringhe ottimizzate.
• 📝 Generazione Automatica dei Selettori: Genera selettori CSS/XPath robusti per qualsiasi elemento.
• 🔌 API Familiare: Simile a Scrapy/BeautifulSoup con gli stessi pseudo-elementi usati in Scrapy/Parsel.
• 🤝 Integrazione Scrapy Drop-in: Hai già investito in Scrapy? Decora qualsiasi callback con scrapling_response per analizzare le risposte che recuperi già con il parser di Scrapling, senza bisogno di riscrittura.
• 📘 Copertura Completa dei Tipi: Type hint completi per un eccellente supporto IDE e completamento del codice. L'intera codebase viene scansionata automaticamente con PyRight e MyPy a ogni modifica.
• 🔋 Immagine Docker Pronta: A ogni release, viene automaticamente creata e pubblicata un'immagine Docker contenente tutti i browser.

Per Iniziare

Diamo una rapida occhiata a ciò che Scrapling può fare senza scendere troppo in profondità.

Utilizzo di Base

Richieste HTTP con supporto alle sessioni```python from scrapling.fetchers import Fetcher, FetcherSession

with FetcherSession(impersonate='chrome') as session: # Use latest version of Chrome's TLS fingerprint page = session.get('https://quotes.toscrape.com/', stealthy_headers=True) quotes = page.css('.quote .text::text').getall()

Or use one-off requests

page = Fetcher.get('https://quotes.toscrape.com/') quotes = page.css('.quote .text::text').getall()

Modalità stealth avanzata```python
from scrapling.fetchers import StealthyFetcher, StealthySession

with StealthySession(headless=True, solve_cloudflare=True) as session:  # Keep the browser open until you finish
    page = session.fetch('https://nopecha.com/demo/cloudflare', google_search=False)
    data = page.css('#padded_content a').getall()

# Or use one-off request style, it opens the browser for this request, then closes it after finishing
page = StealthyFetcher.fetch('https://nopecha.com/demo/cloudflare')
data = page.css('#padded_content a').getall()

Automazione completa del browser```python from scrapling.fetchers import DynamicFetcher, DynamicSession

with DynamicSession(headless=True, disable_resources=False, network_idle=True) as session: # Keep the browser open until you finish page = session.fetch('https://quotes.toscrape.com/', load_dom=False) data = page.xpath('//span[@class="text"]/text()').getall() # XPath selector if you prefer it

Or use one-off request style, it opens the browser for this request, then closes it after finishing

page = DynamicFetcher.fetch('https://quotes.toscrape.com/') data = page.css('.quote .text::text').getall()

### Spider
Costruisci crawler completi con richieste concorrenti, più tipi di sessione e pausa/ripresa:```python
from scrapling.spiders import Spider, Request, 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(),
            }
            
        next_page = response.css('.next a')
        if next_page:
            yield response.follow(next_page[0].attrib['href'])

result = QuotesSpider().start()
print(f"Scraped {len(result.items)} quotes")
result.items.to_json("quotes.json")

Usa più tipi di sessione in un singolo spider:```python from scrapling.spiders import Spider, Request, Response from scrapling.fetchers import FetcherSession, AsyncStealthySession

class MultiSessionSpider(Spider): name = "multi" start_urls = ["https://example.com/"]

def configure_sessions(self, manager):
    manager.add("fast", FetcherSession(impersonate="chrome"))
    manager.add("stealth", AsyncStealthySession(headless=True), lazy=True)

async def parse(self, response: Response):
    for link in response.css('a::attr(href)').getall():
        # Route protected pages through the stealth session
        if "protected" in link:
            yield Request(link, sid="stealth")
        else:
            yield Request(link, sid="fast", callback=self.parse)  # explicit callback

Metti in pausa e riprendi lunghe scansioni con checkpoint eseguendo lo spider in questo modo:```python
QuotesSpider(crawldir="./crawl_data").start()

Premi Ctrl+C per sospendere in modo pulito: i progressi vengono salvati automaticamente. In seguito, quando avvii di nuovo lo spider, passa lo stesso crawldir e riprenderà da dove si era interrotto.

Oppure salta del tutto la scrittura della logica di crawling con i template già pronti, come estrarre l'intero catalogo di un negozio Shopify:```python from scrapling.spiders import ShopifySpider

class MyStore(ShopifySpider): target_website = "example.com"

result = MyStore().start() # Every product in the store, one item per variant

### Parsing e Navigazione Avanzati```python
from scrapling.fetchers import Fetcher

# Rich element selection and navigation
page = Fetcher.get('https://quotes.toscrape.com/')

# Get quotes with multiple selection methods
quotes = page.css('.quote')  # CSS selector
quotes = page.xpath('//div[@class="quote"]')  # XPath
quotes = page.find_all('div', {'class': 'quote'})  # BeautifulSoup-style
# Same as
quotes = page.find_all('div', class_='quote')
quotes = page.find_all(['div'], class_='quote')
quotes = page.find_all(class_='quote')  # and so on...
# Find element by text content
quotes = page.find_by_text('quote', tag='div')

# Advanced navigation
quote_text = page.css('.quote')[0].css('.text::text').get()
quote_text = page.css('.quote').css('.text::text').getall()  # Chained selectors
first_quote = page.css('.quote')[0]
author = first_quote.next_sibling.css('.author::text')
parent_container = first_quote.parent

# Element relationships and similarity
similar_elements = first_quote.find_similar()
below_elements = first_quote.below_elements()

Puoi usare il parser subito se non vuoi recuperare siti web come di seguito:```python from scrapling.parser import Selector

page = Selector("...")

E funziona esattamente allo stesso modo!

### Esempi di gestione delle sessioni asincrone```python
import asyncio
from scrapling.fetchers import FetcherSession, AsyncStealthySession, AsyncDynamicSession

async with FetcherSession(http3=True) as session:  # `FetcherSession` is context-aware and can work in both sync/async patterns
    page1 = session.get('https://quotes.toscrape.com/')
    page2 = session.get('https://quotes.toscrape.com/', impersonate='firefox135')

# Async session usage
async with AsyncStealthySession(max_pages=2) as session:
    tasks = []
    urls = ['https://example.com/page1', 'https://example.com/page2']
    
    for url in urls:
        task = session.fetch(url)
        tasks.append(task)
    
    print(session.get_pool_stats())  # Optional - The status of the browser tabs pool (busy/free/error)
    results = await asyncio.gather(*tasks)
    print(session.get_pool_stats())

CLI e shell interattiva

Scrapling include una potente interfaccia a riga di comando:

Avvia la shell interattiva di Web Scraping```bash scrapling shell

Estrae pagine in un file direttamente senza programmazione (Estrae il contenuto all'interno del tag `body` per impostazione predefinita). Se il file di output termina con `.txt`, verrà estratto il contenuto testuale del target. Se termina con `.md`, sarà una rappresentazione Markdown del contenuto HTML; se termina con `.html`, sarà il contenuto HTML stesso.```bash
scrapling extract get 'https://example.com' content.md
scrapling extract get 'https://example.com' content.txt --css-selector '#fromSkipToProducts' --impersonate 'chrome'  # All elements matching the CSS selector '#fromSkipToProducts'
scrapling extract fetch 'https://example.com' content.md --css-selector '#fromSkipToProducts' --no-headless
scrapling extract stealthy-fetch 'https://nopecha.com/demo/cloudflare' captchas.html --css-selector '#padded_content a' --solve-cloudflare

[!NOTE] Ci sono molte altre funzionalità, ma vogliamo mantenere questa pagina concisa, incluso il server MCP e l'interattiva Web Scraping Shell. Consulta la documentazione completa qui

Benchmark delle prestazioni

Scrapling non è solo potente: è anche estremamente veloce. I seguenti benchmark confrontano il parser di Scrapling con le versioni più recenti di altre librerie popolari.

Test di velocità di estrazione del testo (5000 elementi annidati)

Ricerca di similarità degli elementi e del testo

Le capacità adattive di individuazione degli elementi di Scrapling superano significativamente le alternative:

Tutti i benchmark rappresentano la media di oltre 100 esecuzioni. Vedi benchmarks.py per la metodologia.

Installazione

Scrapling richiede Python 3.10 o superiore:```bash pip install scrapling

> [!IMPORTANT]
> Questa installazione include solo il motore di parsing e le sue dipendenze, senza alcun fetcher o dipendenze da riga di comando. Quindi importare qualsiasi cosa da `scrapling.fetchers` o `scrapling.spiders`, come negli esempi precedenti, solleverà `ModuleNotFoundError` con questa sola installazione. Se hai intenzione di utilizzare uno dei fetcher o spider, installa prima le dipendenze dei fetcher come mostrato di seguito.

### Dipendenze opzionali

1. Se hai intenzione di utilizzare una delle funzionalità extra qui sotto, i fetcher o le loro classi, dovrai installare le dipendenze dei fetcher e le relative dipendenze del browser come segue:
    ```bash
    pip install "scrapling[fetchers]"
    
    scrapling install           # normal install
    scrapling install  --force  # force reinstall
    ```

    Questo scarica tutti i browser, insieme alle loro dipendenze di sistema e alle dipendenze di manipolazione delle fingerprint.

    Oppure puoi installarle dal codice invece di eseguire un comando come questo:
    ```python
    from scrapling.cli import install
    
    install([], standalone_mode=False)          # normal install
    install(["--force"], standalone_mode=False) # force reinstall
    ```

2. Funzionalità extra:
   - Installa la funzionalità server MCP:
       ```bash
       pip install "scrapling[ai]"
       ```
   - Installa le funzionalità della shell (la shell Web Scraping e il comando `extract`):
       ```bash
       pip install "scrapling[shell]"
       ```
   - Installa tutto:
       ```bash
       pip install "scrapling[all]"
       ```
   Ricorda che devi installare le dipendenze del browser con `scrapling install` dopo una qualsiasi di queste installazioni extra (se non l'hai già fatto).

### Docker
Puoi anche installare un'immagine Docker con tutte le estensioni e i browser con il seguente comando da DockerHub:```bash
docker pull pyd4vinci/scrapling

Oppure scaricalo dal registro GitHub:```bash docker pull ghcr.io/d4vinci/scrapling:latest

Questa immagine viene creata e pubblicata automaticamente utilizzando GitHub Actions e il branch principale del repository.

## Contributi

Accogliamo con piacere i contributi! Prima di iniziare, ti preghiamo di leggere le nostre [linee guida per i contributi](https://github.com/D4Vinci/Scrapling/blob/main/CONTRIBUTING.md).

## Disclaimer

> [!CAUTION]
> Questa libreria è fornita esclusivamente a scopo didattico e di ricerca. Utilizzando questa libreria, accetti di rispettare le leggi locali e internazionali sul data scraping e sulla privacy. Gli autori e i contributori non sono responsabili per qualsiasi uso improprio di questo software. Rispetta sempre i termini di servizio dei siti web e i file robots.txt.

## 🎓 Citazioni
Se hai utilizzato la nostra libreria per scopi di ricerca, ti preghiamo di citarci con il seguente riferimento:```text
  @misc{scrapling,
    author = {Karim Shoair},
    title = {Scrapling},
    year = {2024},
    url = {https://github.com/D4Vinci/Scrapling},
    note = {An adaptive Web Scraping framework that handles everything from a single request to a full-scale crawl!}
  }

Licenza

Quest'opera è concessa in licenza ai sensi della BSD-3-Clause License.

Ringraziamenti

Questo progetto include codice adattato da:

• Parsel (BSD License)-Usato per il sottomodulo translator