Web Scraping senza sforzo per il Web moderno

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

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

Scrapling è un framework di Web Scraping adattivo che gestisce tutto, da una singola richiesta a una scansione 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 spider ti permette di scalare fino a scansioni concorrenti multi-sessione con pausa/ripresa, rotazione automatica dei proxy e una velocità di scansione che si adatta alla rapidità con cui ogni sito risponde e rallenta quando inizia a bloccarti - il tutto in poche righe di Python. Una sola libreria, zero compromessi.

Scansioni velocissime con statistiche in tempo reale e streaming. Creato da Web Scraper per Web Scraper e 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!

O fino a scalare fino a crawler 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!}

Caratteristiche Principali

Spider - Un Framework Completo per il Crawling

• 🕷️ API Spider simile a Scrapy: Definisci spider con start_urls, callback parse asincroni 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 singolo spider - instrada le richieste a sessioni diverse tramite ID.
• 💾 Pausa e Ripresa: Persistenza del crawl basata su checkpoint. Premi Ctrl+C per un arresto pulito; 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 Richieste Bloccate: Rilevamento automatico e retry delle richieste bloccate con logica personalizzabile.
• 🚦 AutoThrottle: Smetti di indovinare i ritardi. Lo spider regola da solo il ritardo di ogni dominio in base alla velocità di risposta del sito, poi lo raddoppia (o attende quanto richiesto da Retry-After) ogni volta che il sito inizia a bloccare o limitare le richieste, 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.

Fetching di Siti Web Avanzati con Supporto 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 Chrome di Google.
• Bypass Anti-bot: Capacità stealth avanzate con StealthyFetcher e spoofing dell'impronta digitale. Può bypassare facilmente tutti i tipi di Turnstile/Interstitial di Cloudflare con automazione.
• Gestione Sessioni: Supporto sessioni persistenti con le classi FetcherSession, StealthySession e DynamicSession per la gestione di cookie e stato tra le richieste.
• Rotazione Proxy: ProxyRotator integrato con strategie di rotazione cicliche o personalizzate su tutti i tipi di sessione, oltre a override proxy per singola richiesta.
• Blocco Domini e Pubblicità: Blocca le richieste a domini specifici (e i loro sottodomini) o abilita il blocco pubblicità integrato (~3.500 domini noti di annunci/tracker) nei fetcher basati su browser.
• Prevenzione Perdite DNS: Supporto opzionale DNS-over-HTTPS per instradare le query DNS tramite DoH di Cloudflare, prevenendo perdite DNS quando si usano 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 su un provider di browser gestito. Puoi anche puntare qualsiasi fetcher browser alla tua build di Chromium con .

Scraping Adattivo

• 🔄 Tracciamento Intelligente degli Elementi: Riposiziona gli elementi dopo modifiche al sito web usando algoritmi intelligenti di similarità.
• 🎯 Selezione Flessibile Intelligente: Selettori CSS, selettori XPath, ricerca basata su filtri, ricerca testuale, ricerca regex e altro.
• 🔍 Trova Elementi Simili: Localizza automaticamente elementi simili a quelli trovati.

Funzionalità AI

• 🤖 Server MCP: Lascia che chatbot e agenti AI (Claude/Cursor/ecc.) facciano scraping tramite Scrapling con strumenti one-shot o basati su sessione che coprono richieste HTTP semplici (qualsiasi metodo), fetch del browser e fetch stealth che bypassano Cloudflare. Le pagine vengono ristrette con selettori CSS e private dei contenuti di prompt-injection prima che l'AI le veda, così l'agente legge meno, costa meno e non può essere dirottato da testo nascosto. Sono inclusi screenshot, browser remoti tramite CDP e un trasporto HTTP sicuro per impostazione predefinita. (video demo)
• 🧠 Agent Skill: Un Agent Skill pronto da installare che insegna agli agenti di codifica l'intera libreria, così il codice che scrivono con Scrapling corrisponde all'API attuale invece di fare supposizioni.
• 📚 Markdown pronto per RAG: Trasforma qualsiasi pagina in Markdown pulito, sanificato e pronto per LLM con una sola riga (page.markdown()), oppure esegui il crawl di un intero sito web in un corpus Markdown con il template SiteToMarkdownSpider, tutto senza un LLM nel loop. (docs)

Architettura ad Alte Prestazioni e Testata sul Campo

• 🚀 Estremamente Veloce: Prestazioni ottimizzate che superano la maggior parte delle librerie Python per scraping.
• 🔋 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.
• 🏗️ Testata 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 integrata opzionale con integrazione Scrapling, scorciatoie e nuovi strumenti per accelerare lo sviluppo di script di Web Scraping, come convertire 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 Ricca: Traversal avanzato del DOM con metodi di navigazione per genitore, fratello e figlio.
• 🧬 Elaborazione Testo Migliorata: Regex integrata, metodi di pulizia e operazioni su stringhe ottimizzate.
• 📝 Generazione Automatica di 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 già recuperi con il parser di Scrapling, senza riscritture.
• 📘 Copertura Completa dei Tipi: Type hint completi per un eccellente supporto IDE e completamento del codice. L'intero codebase viene scansionato automaticamente con PyRight e MyPy a ogni modifica.
• 🔋 Immagine Docker Pronta: Con ogni release, viene automaticamente creata e pubblicata un'immagine Docker contenente tutti i browser.

Per Iniziare

Ti diamo una rapida occhiata a cosa può fare Scrapling senza entrare troppo nel dettaglio.

Utilizzo Base

Richieste HTTP con supporto sessione```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()

Piena automazione 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()

### Spiders
Costruisci crawler completi con richieste concorrenti, più tipi di sessione e funzionalità di 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

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

Premi Ctrl+C per mettere in pausa con eleganza: i progressi vengono salvati automaticamente. In seguito, quando riavvierai lo spider, passa lo stesso crawldir e riprenderà da dove si era fermato.

Oppure salta del tutto la scrittura della logica di crawling con i modelli 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

### Analisi Avanzata e Navigazione```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 per il Web Scraping```bash scrapling shell

Estrae le 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 la shell interattiva di Web Scraping. Consulta la documentazione completa qui

Benchmark delle prestazioni

Scrapling non è solo potente, ma anche estremamente veloce. I seguenti benchmark confrontano il parser di Scrapling con le ultime versioni di altre librerie popolari.

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

Prestazioni di ricerca di similarità degli elementi e di testo

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

Tutti i benchmark rappresentano medie di oltre 100 esecuzioni. Consulta 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 dipendenza 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 qualsiasi dei fetcher o spider, installa prima le dipendenze dei fetcher come mostrato di seguito.

### Dipendenze Opzionali

1. Se hai intenzione di utilizzare una qualsiasi delle funzionalità extra di seguito, i fetcher o le loro classi, dovrai installare le dipendenze dei fetcher e le loro dipendenze del browser come segue:
    ```bash
    pip install "scrapling[fetchers]"
    
    scrapling install           # installazione normale
    scrapling install  --force  # forzare la reinstallazione
    ```

    Questo scarica tutti i browser, insieme alle loro dipendenze di sistema e alle dipendenze per la manipolazione delle impronte digitali.

    Oppure puoi installarli dal codice invece di eseguire un comando come questo:
    ```python
    from scrapling.cli import install
    
    install([], standalone_mode=False)          # installazione normale
    install(["--force"], standalone_mode=False) # forzare la reinstallazione
    ```

2. Funzionalità extra:
   - Installa la funzionalità del server MCP:
       ```bash
       pip install "scrapling[ai]"
       ```
   - Installa le dipendenze per ([costruire sistemi RAG](https://scrapling.readthedocs.io/en/latest/ai/building-rag-systems.html)):
       ```bash
       pip install "scrapling[rag]"
       ```
   - Installa le funzionalità della shell (shell di 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 opzioni extra (se non l'hai già fatto)

### Docker
Puoi anche installare un'immagine Docker con tutte le funzionalità extra 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 tramite GitHub Actions e il ramo principale del repository.

## Contributi

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

## Dichiarazione di esclusione di responsabilità

> [!CAUTION]
> Questa libreria è fornita esclusivamente a scopo educativo e di ricerca. Utilizzando questa libreria, accetti di conformarti alle leggi locali e internazionali sullo scraping dei dati e sulla privacy. Gli autori e i contributori non sono responsabili di 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

Questo lavoro è concesso in licenza sotto la Licenza BSD-3-Clause.

Riconoscimenti

Questo progetto include codice adattato da:

• Parsel (Licenza BSD) - Utilizzato per il sottomodulo translator