Scrapare IMDb con Python: codice che funziona davvero

Se hai cercato di recente "scrape IMDb with Python", probabilmente hai già notato una cosa: la maggior parte dei tutorial che trovi è rotta. Non nel senso di "un po' datata" — ma proprio nel senso di "restituisce zero risultati e una valanga di errori NoneType".

Nelle ultime settimane ho testato tutti i principali tutorial per estrarre dati da IMDb che sono riuscito a trovare — GeeksforGeeks, Medium, freeCodeCamp, notebook su Kaggle, insomma tutti. Su taggati per l'estrazione da IMDb, la grande maggioranza usa selettori CSS (td.titleColumn, td.ratingColumn) che non esistono più da giugno 2023, quando IMDb ha ridisegnato la sua pagina Top 250. Il risultato? Forum pieni di sviluppatori che chiedono "perché il mio codice restituisce vuoto?" e maintainer di librerie popolari come "Non c'è molto che possiamo fare, se non sistemare ogni parser". Questa guida ti mostra due metodi Python che funzionano davvero oggi, come gestire la paginazione e gli errori più comuni, quando Python non è nemmeno lo strumento giusto e come rendere il tuo scraper più resistente nel tempo, così non finirà anche lui nel cimitero degli scraper rotti.

Cosa significa estrarre dati da IMDb con Python?

Il web scraping consiste nell'estrarre automaticamente dati dalle pagine web — invece di copiare e incollare tutto a mano, scrivi uno script che faccia il lavoro per te. Quando parliamo di "scrapare IMDb", intendiamo prelevare dati strutturati sui film (titoli, valutazioni, generi, cast, durata, numero di voti) dalle pagine di IMDb usando Python.

Lo stack Python tipico per farlo include tre librerie: requests (per scaricare la pagina web), BeautifulSoup (per analizzare l'HTML e trovare i dati) e pandas (per organizzare ed esportare i risultati). Alcuni tutorial usano anche Selenium o Playwright per le pagine che richiedono il rendering JavaScript, ma come vedrai esistono approcci più veloci.

Una precisazione importante: tutto ciò che trovi in questa guida è stato verificato sulla struttura attuale di IMDb a metà 2025. IMDb modifica il sito circa ogni 6–12 mesi, quindi se la stai leggendo nel 2027, alcuni selettori potrebbero essere cambiati. (Ti spiego anche come gestire questo caso.)

Perché estrarre dati da IMDb con Python? Casi d'uso reali

Prima ancora di scrivere una riga di codice: cosa faresti davvero con i dati di IMDb? La risposta dipende da chi sei.

Il dataset di recensioni di IMDb è uno dei benchmark NLP più usati al mondo — l'articolo fondamentale di Maas et al. (2011) ha accumulato e il dataset è integrato in TensorFlow, Keras e PyTorch. Su Hugging Face, il dataset stanfordnlp/imdb riceve 213.321 download al mese ed è stato usato per addestrare oltre 1.500 modelli. Quindi, se lavori nel machine learning, probabilmente conosci già i dati di IMDb.

Ma i casi d'uso vanno ben oltre l'accademia:

Solo il mercato del film tourism vale, secondo le stime, . Netflix ha speso oltre 17 miliardi di dollari in contenuti nel 2024, con guidata da raccomandazioni personalizzate. In sostanza: i dati di IMDb alimentano decisioni reali in molti settori.

Le opzioni per ottenere i dati di IMDb (prima ancora di scrivere codice)

Questa è la sezione che la maggior parte dei tutorial salta del tutto. Vanno dritti a pip install beautifulsoup4 senza chiedersi se lo scraping in Python sia davvero la scelta giusta per il tuo caso.

Ecco il panorama completo:

Un paio di note su queste opzioni. Cinemagoer non ha avuto un rilascio su PyPI da maggio 2023 e gran parte dei suoi parser si è rotta dopo il redesign di IMDb di giugno 2025 — oggi non lo consiglierei per un uso in produzione. TMDb è ottimo, ma usa un suo sistema di valutazione, non quello di IMDb. E l'API enterprise ufficiale di IMDb costa tramite AWS Data Exchange, quindi per la maggior parte di noi non è un'opzione.

Per chi non vuole scrivere codice, legge la pagina IMDb, suggerisce automaticamente i campi da estrarre (titolo, valutazione, anno, genere) ed esporta in Excel, Google Sheets, Airtable o Notion in due clic. L'AI si adatta quando IMDb cambia layout, quindi non c'è alcun selettore da mantenere. Ne parliamo meglio più avanti.

Per chi invece vuole scrivere Python, ecco due metodi che funzionano.

Metodo 1: estrarre IMDb con Python usando BeautifulSoup (approccio tradizionale)

È l'approccio classico che trovi nella maggior parte dei tutorial. Funziona, ma voglio essere chiaro: è il più fragile tra quelli che vedrai qui. I nomi delle classi CSS di IMDb sono generati automaticamente e cambiano con i redesign. Detto questo, è il modo migliore per imparare le basi del web scraping.

Passo 1: installa e importa le librerie Python

Ti servono quattro pacchetti:

1pip install requests beautifulsoup4 pandas lxml

Ecco a cosa serve ciascuno:

• requests — invia richieste HTTP per scaricare la pagina
• beautifulsoup4 — analizza l'HTML per cercare elementi specifici
• pandas — organizza i dati estratti in tabelle ed esporta in CSV/Excel
• lxml — parser HTML veloce (BeautifulSoup può usarlo come backend)

Blocco di importazione:

1import requests
2from bs4 import BeautifulSoup
3import pandas as pd

Passo 2: invia una richiesta HTTP a IMDb

Qui è dove la maggior parte dei principianti incontra il primo blocco. IMDb blocca le richieste che non includono un header User-Agent adeguato — riceverai un errore 403 Forbidden. La stringa user-agent predefinita di Python Requests (python-requests/2.31.0) viene individuata subito.

1url = "https://www.imdb.com/chart/top/"
2headers = {
3    "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",
4    "Accept-Language": "en-US,en;q=0.9"
5}
6response = requests.get(url, headers=headers)
7if response.status_code != 200:
8    print(f"Impossibile recuperare la pagina: {response.status_code}")
9else:
10    print("Pagina recuperata con successo")

Anche l'header Accept-Language è importante — senza di esso, IMDb potrebbe restituire contenuti in una lingua diversa in base alla geolocalizzazione del tuo IP.

Passo 3: analizza l'HTML con BeautifulSoup

Una volta ottenuto l'HTML, crea un oggetto BeautifulSoup e inizia a cercare gli elementi giusti. Apri la pagina Top 250 di IMDb in Chrome, fai clic destro su un titolo e scegli "Inspect" per vedere la struttura HTML sottostante.

1soup = BeautifulSoup(response.text, "lxml")

A metà 2025, la pagina Top 250 usa questi selettori:

• Contenitore film: li.ipc-metadata-list-summary-item
• Titolo: h3.ipc-title__text
• Anno: span.cli-title-metadata-item (primo span)
• Valutazione: span.ipc-rating-star--rating

Avviso: quelle classi con prefisso ipc- sono generate dal sistema di componenti di IMDb. Sono rimaste stabili dal redesign di giugno 2023, ma non c'è alcuna garanzia che non cambino di nuovo.

Passo 4: estrai i dati del film (titolo, anno, valutazione)

Qui mi differenzio dalla maggior parte dei tutorial: aggiungo la gestione degli errori con try/except. Nessuna delle guide concorrenti che ho esaminato lo fa, ed è esattamente il motivo per cui il loro codice si rompe in silenzio quando un selettore cambia.

1movies = []
2movie_items = soup.select("li.ipc-metadata-list-summary-item")
3for item in movie_items:
4    try:
5        title_tag = item.select_one("h3.ipc-title__text")
6        title = title_tag.text.strip() if title_tag else "N/A"
7        year_tag = item.select_one("span.cli-title-metadata-item")
8        year = year_tag.text.strip() if year_tag else "N/A"
9        rating_tag = item.select_one("span.ipc-rating-star--rating")
10        rating = rating_tag.text.strip() if rating_tag else "N/A"
11        movies.append({
12            "title": title,
13            "year": year,
14            "rating": rating
15        })
16    except Exception as e:
17        print(f"Errore nell'analisi del film: {e}")
18        continue
19print(f"Estratti {len(movies)} film")

Passo 5: salva in CSV o Excel con Pandas

1df = pd.DataFrame(movies)
2df.to_csv("imdb_top_250.csv", index=False)
3df.to_excel("imdb_top_250.xlsx", index=False)
4print(df.head())

Output di esempio:

1                          title  year rating
20  1. The Shawshank Redemption  1994    9.3
31           2. The Godfather    1972    9.2
42     3. The Dark Knight        2008    9.0
53  4. The Godfather Part II     1974    9.0
64         5. 12 Angry Men       1957    9.0

Funziona. Ma si regge su selettori CSS che potrebbero rompersi da un momento all'altro — ed è qui che entra in gioco l'approccio che consiglio davvero.

Metodo 2: trucco con JSON-LD — salta del tutto l'analisi dell'HTML

Questa è la tecnica che nessun articolo concorrente copre, ed è quella che userei per qualsiasi progetto serio. IMDb incorpora dati strutturati come (JavaScript Object Notation for Linked Data) nei tag <script type="application/ld+json"> di ogni pagina. Questi dati seguono lo standard Schema.org, vengono usati da Google per i risultati arricchiti e cambiano molto meno frequentemente dei nomi delle classi CSS.

Apify IMDb Scraper, uno strumento di livello professionale, usa questo ordine di priorità per l'estrazione: "JSON-LD > NEXT_DATA > DOM". È la gerarchia che consiglierei anch'io.

Perché JSON-LD è più affidabile dei selettori CSS

Classi CSS come ipc-metadata-list-summary-item sono generate automaticamente dal sistema React di IMDb e cambiano a ogni redesign. Lo schema JSON-LD rappresenta il modello dati reale, non il livello di presentazione. È come la differenza tra leggere l'indice di un libro e cercare di riconoscere i capitoli dalla dimensione del font.

Passo dopo passo: estrarre i dati di IMDb da JSON-LD

Passo 1: recupera la pagina

Come prima: usa requests con un header User-Agent corretto.

1import requests
2from bs4 import BeautifulSoup
3import json
4import pandas as pd
5url = "https://www.imdb.com/chart/top/"
6headers = {
7    "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",
8    "Accept-Language": "en-US,en;q=0.9"
9}
10response = requests.get(url, headers=headers)
11soup = BeautifulSoup(response.text, "lxml")

Passo 2: trova il tag script JSON-LD

1script_tag = soup.find("script", {"type": "application/ld+json"})
2if not script_tag:
3    print("Nessun JSON-LD trovato in questa pagina")
4else:
5    data = json.loads(script_tag.string)
6    print(f"Trovato JSON-LD con tipo: {data.get('@type', 'sconosciuto')}")

Passo 3: analizza i dati strutturati

Nella pagina Top 250, il JSON-LD contiene un array itemListElement con tutti i 250 film. Ogni voce include posizione, nome, URL, aggregateRating, datePublished, genere, descrizione, regista e array degli attori.

1movies = []
2for item in data.get("itemListElement", []):
3    movie = item.get("item", {})
4    rating_info = movie.get("aggregateRating", {})
5    movies.append({
6        "rank": item.get("position"),
7        "title": movie.get("name"),
8        "url": movie.get("url"),
9        "rating": rating_info.get("ratingValue"),
10        "vote_count": rating_info.get("ratingCount"),
11        "date_published": movie.get("datePublished"),
12        "genre": ", ".join(movie.get("genre", [])),
13        "description": movie.get("description"),
14    })

Passo 4: esporta in CSV

1df = pd.DataFrame(movies)
2df.to_csv("imdb_top_250_json_ld.csv", index=False)
3print(df.head())

Output di esempio:

1   rank                      title                                     url  rating  vote_count date_published              genre
20     1  The Shawshank Redemption  https://www.imdb.com/title/tt0111161/     9.3     2900000     1994-10-14     Drama
31     2            The Godfather   https://www.imdb.com/title/tt0068646/     9.2     2000000     1972-03-24     Crime, Drama
42     3          The Dark Knight   https://www.imdb.com/title/tt0468569/     9.0     2800000     2008-07-18     Action, Crime, Drama

Tutti e 250 i film. Dati puliti, strutturati, senza acrobazie con i selettori CSS. E dato che queste informazioni seguono lo standard Schema.org (su cui si basa Google per i risultati di ricerca), è molto meno probabile che cambino rispetto al layout visivo.

Bonus: __NEXT_DATA__ per le pagine dei singoli film

Per ottenere dati più ricchi dalle pagine dei singoli titoli (durata, cast completo, trama, immagini poster), IMDb incorpora anche un oggetto JSON __NEXT_DATA__. È il dato usato da React per idratare la pagina — non può essere rimosso senza rompere il sito.

1# In una pagina di un singolo film, ad esempio /title/tt0111161/
2next_data_tag = soup.find("script", {"id": "__NEXT_DATA__"})
3if next_data_tag:
4    next_data = json.loads(next_data_tag.string)
5    above_fold = next_data["props"]["pageProps"]["aboveTheFoldData"]
6    title = above_fold["titleText"]["text"]
7    year = above_fold["releaseYear"]["year"]
8    rating = above_fold["ratingsSummary"]["aggregateRating"]
9    runtime_seconds = above_fold.get("runtime", {}).get("seconds", 0)
10    genres = [g["text"] for g in above_fold["genres"]["genres"]]
11    plot = above_fold["plot"]["plotText"]["plainText"]

Usa JSON-LD per le pagine elenco/classifica, __NEXT_DATA__ per le pagine dei singoli titoli. Questo è l'approccio da produzione.

Perché il tuo scraper IMDb continua a rompersi (e come risolverlo)

Questo è di gran lunga il problema più segnalato in tutti i forum che ho controllato sull'estrazione da IMDb. Gli utenti scrivono: "Alcuni codici si sono rotti per via dei cambiamenti UI" e "Non funziona nel 2024!" — e la risposta di solito è silenzio o "prova Selenium".

La causa principale è la migrazione continua di IMDb verso un frontend React/Next.js. Ecco la cronologia dei principali cambiamenti che hanno rotto gli scraper:

In pratica, c'è un grande cambiamento che rompe tutto circa ogni 6–12 mesi. Se il tuo scraper si basa sui nomi delle classi CSS, sei su un tapis roulant.

Errori comuni e come risolverli

Risultati vuoti / errori NoneType

È l'errore più comune. Vedrai AttributeError: 'NoneType' object has no attribute 'text'. Significa che BeautifulSoup non ha trovato l'elemento cercato — di solito perché il nome della classe CSS è cambiato o perché il contenuto viene renderizzato via JavaScript.

Soluzione: passa all'estrazione JSON-LD (Metodo 2 sopra). I dati sono nella risposta HTML iniziale, senza bisogno di JavaScript.

403 Forbidden

IMDb usa per rilevare e bloccare i bot. Il trigger numero uno è un header User-Agent mancante o chiaramente falso. Questo è documentato in progetti open source e nei , dove un dipendente IMDb ha riconosciuto il problema.

Soluzione: includi sempre una stringa User-Agent da browser realistica e l'header Accept-Language: en-US. Usa requests.Session() per il pooling delle connessioni.

Restituisce solo 25 risultati

Le pagine di ricerca IMDb e le liste "Most Popular" usano il lazy loading — inizialmente renderizzano solo circa 25 risultati e ne caricano altri via AJAX man mano che scorri.

Soluzione: usa la paginazione tramite parametro URL (coperta nella prossima sezione) oppure passa alla pagina Top 250, che carica tutti i 250 film in una sola risposta.

I selettori smettono improvvisamente di funzionare

Vecchi selettori che non funzionano più: td.titleColumn, td.ratingColumn, .lister-item-header, .inline-block.ratings-imdb-rating. Se il tuo codice usa uno di questi, è rotto.

Soluzione: preferisci gli attributi data-testid (come h1[data-testid="hero-title-block__title"]) ai nomi di classe generati automaticamente. Ancora meglio: usa JSON-LD.

Un framework decisionale: correzioni a breve e a lungo termine

• Correzione rapida: aggiungi blocchi try/except attorno a ogni selettore, verifica gli status code HTTP, registra gli errori invece di far crashare lo script
• Correzione di medio termine: passa dai selettori CSS all'estrazione JSON-LD (Metodo 2)
• Correzione di lungo termine: usa i per l'analisi su larga scala, oppure uno strumento come che usa l'AI per rileggere la struttura della pagina ogni volta — nessun selettore da mantenere, l'AI si adatta automaticamente ai cambi di layout

Oltre il limite dei 25 risultati: paginazione IMDb e dataset di grandi dimensioni

Ogni tutorial concorrente che ho esaminato estrae esattamente una pagina. Nessuno parla di paginazione. Ma se ti servono più di un singolo elenco, ti scontrerai rapidamente con dei limiti.

Pagine che non richiedono paginazione

Buone notizie: la pagina Top 250 carica tutti i 250 film in una singola risposta renderizzata dal server. Sia JSON-LD sia __NEXT_DATA__ contengono il dataset completo. Nessuna paginazione necessaria.

Come funziona la paginazione di ricerca su IMDb

Le pagine di ricerca IMDb usano un parametro URL start=, incrementato di 50:

1https://www.imdb.com/search/title/?groups=top_1000&start=1
2https://www.imdb.com/search/title/?groups=top_1000&start=51
3https://www.imdb.com/search/title/?groups=top_1000&start=101

Ecco un ciclo Python che scorre i risultati pagina per pagina:

1import time
2all_movies = []
3for start in range(1, 1001, 50):  # Scorre i risultati del top 1000
4    url = f"https://www.imdb.com/search/title/?groups=top_1000&start={start}"
5    response = requests.get(url, headers=headers)
6    if response.status_code != 200:
7        print(f"Errore a start={start}: {response.status_code}")
8        break
9    soup = BeautifulSoup(response.text, "lxml")
10    # Estrai i film usando il metodo che preferisci
11    # ...
12    print(f"Pagina estratta a partire da {start}")
13    time.sleep(3)  # Sii rispettoso — IMDb blocca dopo circa 50 richieste rapide

Quel time.sleep(3) conta davvero. Le segnalazioni della community indicano che IMDb inizia a bloccare gli IP dopo circa 50 richieste rapide. Un ritardo casuale tra 2 e 5 secondi è una buona pratica.

Quando saltare del tutto lo scraping: i dataset ufficiali di IMDb

Per esigenze davvero ampie, IMDb mette a disposizione 7 file TSV gratuiti su , aggiornati ogni giorno:

Caricarli in Pandas è semplice:

1ratings = pd.read_csv("title.ratings.tsv.gz", sep="\t", compression="gzip")
2basics = pd.read_csv("title.basics.tsv.gz", sep="\t", compression="gzip", low_memory=False)
3# Unisci su tconst (ID titolo IMDb)
4merged = basics.merge(ratings, on="tconst")
5top_movies = merged[merged["titleType"] == "movie"].nlargest(250, "averageRating")

Questi dataset coprono oltre 26 milioni di titoli. Niente paginazione, niente selettori, niente errori 403. La licenza è solo per uso personale e non commerciale — non puoi ripubblicare o rivendere i dati.

La scorciatoia no-code: Thunderbit gestisce la paginazione per te

Per chi ha bisogno di dati IMDb paginati ma non vuole scrivere la logica di paginazione, supporta nativamente sia la paginazione a click sia lo scroll infinito. Tu gli dici cosa estrarre, lui fa il resto — incluso lo scroll del contenuto caricato via lazy loading.

Estrarre IMDb con Python: codice completo e funzionante (pronto da copiare e incollare)

Ecco due script autonomi che puoi eseguire subito.

Script A: metodo BeautifulSoup (selettori CSS)

1import requests
2from bs4 import BeautifulSoup
3import pandas as pd
4url = "https://www.imdb.com/chart/top/"
5headers = {
6    "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",
7    "Accept-Language": "en-US,en;q=0.9"
8}
9response = requests.get(url, headers=headers)
10if response.status_code != 200:
11    print(f"Errore: {response.status_code}")
12    exit()
13soup = BeautifulSoup(response.text, "lxml")
14movie_items = soup.select("li.ipc-metadata-list-summary-item")
15movies = []
16for item in movie_items:
17    try:
18        title = item.select_one("h3.ipc-title__text")
19        year = item.select_one("span.cli-title-metadata-item")
20        rating = item.select_one("span.ipc-rating-star--rating")
21        movies.append({
22            "title": title.text.strip() if title else "N/A",
23            "year": year.text.strip() if year else "N/A",
24            "rating": rating.text.strip() if rating else "N/A",
25        })
26    except Exception as e:
27        print(f"Film saltato per errore: {e}")
28df = pd.DataFrame(movies)
29df.to_csv("imdb_top250_bs4.csv", index=False)
30print(f"Salvati {len(df)} film")
31print(df.head())

Script B: metodo JSON-LD (consigliato)

1import requests
2from bs4 import BeautifulSoup
3import json
4import pandas as pd
5url = "https://www.imdb.com/chart/top/"
6headers = {
7    "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",
8    "Accept-Language": "en-US,en;q=0.9"
9}
10response = requests.get(url, headers=headers)
11if response.status_code != 200:
12    print(f"Errore: {response.status_code}")
13    exit()
14soup = BeautifulSoup(response.text, "lxml")
15script_tag = soup.find("script", {"type": "application/ld+json"})
16if not script_tag:
17    print("Nessun dato JSON-LD trovato")
18    exit()
19data = json.loads(script_tag.string)
20movies = []
21for item in data.get("itemListElement", []):
22    movie = item.get("item", {})
23    rating_info = movie.get("aggregateRating", {})
24    directors = movie.get("director", [])
25    director_names = ", ".join(
26        d.get("name", "") for d in (directors if isinstance(directors, list) else [directors])
27    )
28    movies.append({
29        "rank": item.get("position"),
30        "title": movie.get("name"),
31        "url": movie.get("url"),
32        "rating": rating_info.get("ratingValue"),
33        "votes": rating_info.get("ratingCount"),
34        "year": movie.get("datePublished", "")[:4],
35        "genre": ", ".join(movie.get("genre", [])),
36        "director": director_names,
37        "description": movie.get("description"),
38    })
39df = pd.DataFrame(movies)
40df.to_csv("imdb_top250_jsonld.csv", index=False)
41print(f"Salvati {len(df)} film")
42print(df.head())

Entrambi gli script includono la gestione degli errori e producono un CSV pulito. Lo Script B ti offre dati più ricchi — regista, descrizione, URL — ed è più resistente ai cambi di layout.

Come estrarre dati da IMDb senza scrivere codice (con Thunderbit)

Non tutti hanno bisogno o vogliono scrivere Python. Magari sei un operations analyst e ti bastano i film più votati di questa settimana in un foglio di calcolo. Magari sei un content strategist e vuoi confrontare l'evoluzione dei generi nel tempo. In questi casi, costruire uno scraper è eccessivo.

Ecco come ottenere gli stessi dati usando :

Prima di iniziare:

• Difficoltà: Principiante
• Tempo necessario: ~2 minuti
• Cosa ti serve: browser Chrome, (il piano gratuito basta)

Passo 1: apri la pagina IMDb che vuoi estrarre. Apri la Top 250 di IMDb (o qualsiasi altra pagina elenco/ricerca) in Chrome.

Passo 2: clicca "AI Suggest Fields" nella sidebar di Thunderbit. L'AI analizza la pagina e suggerisce le colonne — di solito Titolo, Anno, Valutazione, Genere e altre a seconda della pagina. Vedrai una tabella di anteprima con i campi suggeriti.

Passo 3: modifica i campi se necessario. Rimuovi le colonne che non ti servono oppure aggiungine di personalizzate cliccando su "+ Add Column" e descrivendo in linguaggio naturale ciò che vuoi (ad esempio "nome del regista" o "numero di voti").

Passo 4: clicca "Scrape". Thunderbit estrae i dati. Per le pagine con scroll infinito o paginazione, gestisce automaticamente lo scorrimento.

Passo 5: esporta. Clicca il pulsante di export e scegli il formato: Excel, Google Sheets, CSV, Airtable o Notion. I dati arrivano nella destinazione in pochi secondi.

Il vantaggio principale non è solo la comodità: è che l'AI di Thunderbit legge la struttura della pagina da zero ogni volta. Quando IMDb cambia layout (e lo farà), l'AI si adatta. Nessun selettore da aggiornare, nessun codice da sistemare. Per chi è stato colpito da uno scraper rotto alle 2 di notte prima di una scadenza, vale tantissimo.

Thunderbit supporta anche lo scraping delle sottopagine: puoi aprire la scheda di ogni film e arricchire la tua tabella con cast, regista, durata e altri campi non visibili nella pagina elenco. Se vuoi vederlo in azione, visita il .

È legale scrapare IMDb? Quello che devi sapere

Gli utenti lo chiedono esplicitamente nei forum: "È legale una cosa del genere?… IMDb non vuole che la gente scrapi il suo sito." È una domanda legittima, e nessun articolo concorrente la affronta.

robots.txt di IMDb: la tabella Top 250 (/chart/top/), le pagine dei singoli titoli (/title/ttXXXXXXX/) e le pagine nome (/name/nmXXXXXXX/) NON sono bloccate dal robots.txt. I percorsi bloccati includono /find, /_json/*, /search/name-text, /user/ur*/ratings e vari endpoint AJAX. Non è specificato alcun Crawl-delay.

Condizioni d'uso di IMDb: la clausola rilevante dice: "Non puoi usare data mining, robot, screen scraping o strumenti simili di raccolta ed estrazione dati su questo sito, salvo consenso scritto esplicito da parte nostra." Un'ulteriore clausola vieta la rivendita o l'uso commerciale dei dati estratti.

Cosa significa in pratica: recenti sentenze del 2024 (Meta v. Bright Data, X Corp v. Bright Data) hanno stabilito che i Termini di Servizio potrebbero non vincolare utenti che non li hanno mai accettati — quindi, se estrai dati pubblicamente accessibili senza fare login, l'applicabilità dei ToS è discutibile. Ma si tratta di un'area legale in evoluzione.

Alternative più sicure: i sono esplicitamente autorizzati per uso personale e non commerciale. L'API di TMDb è permissiva con una chiave gratuita. Entrambe sono soluzioni solide se vuoi restare chiaramente nel lecito.

Indicazioni pratiche: se fai scraping, usa una frequenza rispettosa (time.sleep(3) tra le richieste), imposta header corretti e non colpire percorsi bloccati dal robots.txt. Per progetti commerciali, consulta un legale o usa i dataset/API ufficiali.

Abbiamo approfondito nel blog di Thunderbit.

Conclusione: scegli il modo giusto per estrarre IMDb con Python

In breve:

• BeautifulSoup + selettori CSS: utile per imparare le basi. Aspettati che si rompa ogni 6–12 mesi. Aggiungi sempre gestione errori.
• Estrazione JSON-LD: l'approccio che consiglierei per qualsiasi progetto Python in corso. Segue lo standard Schema.org, cambia molto meno spesso delle classi CSS e ti offre dati strutturati puliti senza rendering JavaScript.
• JSON __NEXT_DATA__: usalo come complemento per ottenere dati più ricchi nelle pagine dei singoli titoli (durata, cast completo, trama, immagini poster).
• Dataset ufficiali IMDb: la scelta migliore per l'analisi su larga scala. Oltre 26 milioni di titoli, aggiornati ogni giorno, senza bisogno di scraping. Solo uso personale/non commerciale.
• : la scelta migliore per chi non programma o per chi vuole dati in fretta senza mantenere codice. L'AI si adatta ai cambi di layout, gestisce la paginazione ed esporta su Excel/Sheets/Airtable/Notion.

Salva questa guida tra i preferiti — la aggiornerò quando la struttura di IMDb cambierà di nuovo. E se vuoi evitare del tutto il codice, e vedi quanto velocemente puoi passare da una pagina IMDb a un foglio di calcolo pulito. Se lavori anche con altri siti, la nostra guida su copre il flusso di lavoro più ampio.

FAQ

È legale estrarre dati da IMDb?

I Termini di Servizio di IMDb vietano lo scraping senza consenso, ma l'applicabilità di questi termini sui dati pubblicamente accessibili è discutibile dal punto di vista legale dopo alcune sentenze del 2024. Le opzioni più sicure sono i (uso personale/non commerciale) oppure l'API TMDb (chiave gratuita). Se decidi comunque di fare scraping, rispetta il robots.txt, usa ritardi ragionevoli tra le richieste ed evita i percorsi bloccati. Per uso commerciale, consulta un professionista legale.

Perché il mio scraper IMDb restituisce risultati vuoti?

Quasi sempre la causa sono selettori CSS obsoleti — classi come td.titleColumn e td.ratingColumn non esistono più da giugno 2023. La soluzione è passare all'estrazione JSON-LD (analizzando il tag <script type="application/ld+json">) oppure aggiornare i selettori alle classi attuali con prefisso ipc-. Verifica anche di includere un header User-Agent corretto, perché se manca potresti ricevere un errore 403 che appare come un risultato vuoto.

Come posso estrarre più di 25 risultati da IMDb?

La pagina Top 250 carica tutti i 250 film in una sola risposta — quindi non serve paginazione. Per i risultati di ricerca, usa il parametro URL start= (incrementandolo di 50) per scorrere le pagine. Ad esempio: start=1, start=51, start=101. Inserisci time.sleep(3) tra le richieste per evitare blocchi. In alternativa, i dataset ufficiali di IMDb su contengono oltre 26 milioni di titoli senza alcuna paginazione.

Cos'è __NEXT_DATA__ e perché dovrei usarlo per estrarre dati da IMDb?

__NEXT_DATA__ è un oggetto JSON incorporato in un tag <script id="__NEXT_DATA__"> nelle pagine React/Next.js di IMDb. Contiene i dati strutturati completi che React usa per renderizzare la pagina — titoli, valutazioni, cast, generi, durata e altro. Poiché rappresenta il modello dati sottostante e non il layout visivo, è più resistente ai redesign dell'interfaccia rispetto ai selettori CSS. Usalo insieme a JSON-LD per l'approccio di estrazione più robusto.

Posso estrarre dati da IMDb senza programmare?

Sì. Ci sono due opzioni principali: (1) scaricare i — 7 file TSV che coprono oltre 26 milioni di titoli, aggiornati ogni giorno, gratuiti per uso non commerciale. (2) usare , che legge la pagina IMDb, suggerisce automaticamente i campi da estrarre ed esporta in Excel, Google Sheets o CSV in due clic — senza codice e senza selettori da mantenere.

Scopri di più