Scrapare IMDb con Python: codice che funziona davvero

Se di recente hai cercato "scrape IMDb with Python", probabilmente hai notato una cosa: la maggior parte dei tutorial che trovi è ormai rotta. Non “un po’ datata” rotta — proprio del tipo “restituisce zero risultati e una raffica di errori NoneType” rotta.

Ho passato le ultime settimane a testare tutti i principali tutorial di scraping IMDb che sono riuscito a trovare — GeeksforGeeks, Medium, freeCodeCamp, notebook Kaggle, insomma di tutto. Su oltre etichettati per lo scraping di IMDb, la stragrande maggioranza fa riferimento a 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 manutentori di librerie popolari come “Non possiamo fare molto, a parte sistemare ogni parser.” Questa guida copre due metodi in Python che funzionano davvero oggi, come gestire la paginazione e gli errori comuni, quando Python non è nemmeno lo strumento giusto e come rendere il tuo scraper a prova di futuro, così non finirà nel cimitero degli script rotti.

Cosa significa fare scraping di IMDb con Python?

Il web scraping è il processo di estrarre dati in modo programmatico dalle pagine web — invece di copiare e incollare a mano, scrivi uno script che lo faccia per te. Quando parliamo di “scraping IMDb”, intendiamo estrarre dati strutturati sui film (titoli, valutazioni, generi, cast, durata, numero di voti) dalle pagine di IMDb usando Python.

Lo stack Python tipico per farlo coinvolge 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 nota importante: tutto in questa guida è verificato rispetto all’attuale struttura delle pagine IMDb a metà 2025. IMDb cambia le cose circa ogni 6–12 mesi, quindi se stai leggendo questo nel 2027, alcuni selettori potrebbero essere cambiati. (Ti spiegherò anche come gestire questo caso.)

Perché fare scraping di IMDb con Python? Casi d'uso reali

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

Il dataset delle recensioni IMDb è uno dei benchmark NLP più usati al mondo — l’articolo fondativo 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 IMDb.

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

Il solo mercato del turismo cinematografico vale una stima di . Netflix ha speso oltre 17 miliardi di dollari in contenuti nel 2024, con guidata da raccomandazioni personalizzate. Il punto è questo: i dati IMDb alimentano decisioni reali in tutti i settori.

Le tue opzioni per ottenere i dati IMDb (prima di scrivere una riga di 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 l’approccio giusto per la tua situazione.

Ecco il quadro completo:

Qualche nota su queste opzioni. Cinemagoer non ha avuto un rilascio su PyPI da maggio 2023 e la maggior parte dei suoi parser si è rotta dopo il redesign di IMDb di giugno 2025 — al momento non lo consiglierei per un uso in produzione. TMDb è ottimo ma usa un proprio 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 ci sono selettori da mantenere. Più avanti torniamo su questo.

Ora, per chi invece vuole scrivere Python — ecco due metodi che funzionano.

Metodo 1: fare scraping di IMDb con Python usando BeautifulSoup (approccio tradizionale)

Questo è l’approccio classico che troverai nella maggior parte dei tutorial. Funziona, ma voglio essere chiaro fin da subito: è il più fragile tra quelli che tratterò. 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 cosa fa ciascuno:

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

Il blocco di importazione:

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

Passo 2: invia una richiesta HTTP a IMDb

Qui è dove molti principianti sbattono contro il primo muro. 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 segnalata 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 conta — 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 sul titolo di un film e scegli “Ispeziona” 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: quei nomi di classe con prefisso ipc- sono generati dal sistema di componenti di IMDb. Sono rimasti 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 discosto dalla maggior parte dei tutorial: includo la gestione degli errori con try/except. Nessuna delle guide concorrenti che ho esaminato lo fa, ed è esattamente per questo che 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/D"
7        year_tag = item.select_one("span.cli-title-metadata-item")
8        year = year_tag.text.strip() if year_tag else "N/D"
9        rating_tag = item.select_one("span.ipc-rating-star--rating")
10        rating = rating_tag.text.strip() if rating_tag else "N/D"
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 regge su selettori CSS che potrebbero rompersi da un giorno all’altro — ed è qui che entra in gioco l’approccio che consiglio davvero.

Metodo 2: il trucco del 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, sono usati da Google per i risultati di ricerca avanzati e cambiano molto meno spesso 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é il JSON-LD è più affidabile dei selettori CSS

Classi CSS come ipc-metadata-list-summary-item sono generate automaticamente dal sistema di componenti 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 identificare i capitoli in base alla dimensione del carattere.

Passo dopo passo: estrarre dati IMDb dal JSON-LD

Passo 1: recupera la pagina

Come prima — usa requests con un header User-Agent adeguato.

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, director e array di actor.

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. Puliti, strutturati, senza acrobazie con i selettori CSS. E poiché questi dati seguono lo standard Schema.org (su cui Google si basa per i risultati di ricerca), è molto meno probabile che cambino rispetto al layout visivo.

Bonus: __NEXT_DATA__ per le pagine dei singoli film

Per dati più ricchi dalle pagine dei singoli titoli (durata, cast completo, trama, immagini del poster), IMDb incorpora anche un oggetto JSON __NEXT_DATA__. Sono i dati che React usa per idratare la pagina — non possono essere rimossi senza rompere il sito.

1# Su una pagina di un film singolo come /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/classifiche, __NEXT_DATA__ per le pagine dei titoli singoli. 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 di scraping IMDb che ho controllato. Gli utenti scrivono: “Parte del codice si è rotta a causa di cambiamenti dell’interfaccia” e “Non funziona nel 2024!” — e la risposta è di solito il silenzio oppure “prova Selenium”.

La causa principale è la migrazione continua di IMDb verso un frontend React/Next.js. Ecco la cronologia dei principali cambiamenti rottura:

È grosso modo un grande cambiamento di rottura 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'. Questo significa che BeautifulSoup non è riuscito a trovare l’elemento che stai cercando — di solito perché il nome della classe CSS è cambiato o il contenuto è renderizzato da 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 1 è un header User-Agent mancante o palesemente falso. È documentato in progetti open source e nei , dove un dipendente IMDb ha riconosciuto il problema.

Soluzione: includi sempre una stringa User-Agent realistica di un browser 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 gli elenchi “Most Popular” usano il lazy loading — inizialmente renderizzano solo circa 25 risultati e caricano altro via AJAX mentre scorri.

Soluzione: usa la paginazione tramite parametro URL (coperta nella sezione successiva) 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 quadro decisionale: correzioni a breve termine vs a lungo termine

• Fix rapido: aggiungi blocchi try/except intorno a ogni selettore, verifica i codici di stato HTTP, registra gli errori invece di andare in crash
• Fix di medio termine: passa dai selettori CSS all’estrazione JSON-LD (Metodo 2)
• Fix di lungo termine: usa i per analisi su larga scala, oppure uno strumento come che usa l’AI per rileggere ogni volta la struttura della pagina — nessun selettore da mantenere, l’AI si adatta automaticamente ai cambiamenti di layout

Oltre il muro dei 25 risultati: scraping della paginazione IMDb e dei grandi dataset

Ogni tutorial concorrente che ho esaminato fa scraping di esattamente una pagina. Nessuno copre la paginazione. Ma se ti serve più di un solo elenco, incontrerai presto dei limiti.

Le pagine che non richiedono paginazione

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

Come funziona la paginazione della ricerca IMDb

Le pagine di ricerca IMDb usano un parametro URL start=, che aumenta 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 il 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 raccolta a partire da {start}")
13    time.sleep(3)  # Sii rispettoso — IMDb blocca dopo circa 50 richieste rapide

Quel time.sleep(3) conta. Le segnalazioni della community suggeriscono 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 bulk ufficiali di IMDb

Per esigenze davvero su larga scala, IMDb fornisce 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 basata su clic sia lo scroll infinito. Tu gli dici di fare scraping, lui gestisce il resto — incluso lo scorrimento dei contenuti caricati in lazy loading.

Fare scraping di IMDb con Python: codice completo 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/D",
23            "year": year.text.strip() if year else "N/D",
24            "rating": rating.text.strip() if rating else "N/D",
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 fornisce dati più ricchi — regista, descrizione, URL — ed è più resistente ai cambiamenti di layout.

Come fare scraping di IMDb senza scrivere alcun codice (usando Thunderbit)

Non tutti hanno bisogno o vogliono scrivere Python. Magari sei un analista operations che ha solo bisogno dei film meglio valutati di questa settimana in un foglio di calcolo. Magari sei un content strategist che vuole confrontare i trend di genere tra anni diversi. In questi casi, scrivere uno scraper è eccessivo.

Ecco come ottenere gli stessi dati usando :

Prima di iniziare:

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

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

Passo 2: fai clic su “Suggerisci campi con AI” nella barra laterale di Thunderbit. L’AI analizza la pagina e consiglia 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 facendo clic su “+ Aggiungi colonna” e descrivendo in linguaggio naturale ciò che vuoi (ad esempio, “Nome del regista” o “Numero di voti”).

Passo 4: fai clic su “Scrape”. Thunderbit estrae i dati. Per pagine con scroll infinito o paginazione, gestisce automaticamente lo scorrimento.

Passo 5: esporta. Fai clic sul pulsante di esportazione e scegli il formato — Excel, Google Sheets, CSV, Airtable o Notion. I dati arrivano nella tua destinazione in pochi secondi.

Il vantaggio principale non è solo la comodità — è che l’AI di Thunderbit legge ogni volta la struttura della pagina da zero. Quando IMDb cambia layout (e lo farà), l’AI si adatta. Niente selettori da aggiornare, niente codice da correggere. Per chiunque sia stato bruciato da uno scraper rotto alle 2 di notte prima di una scadenza, vale tantissimo.

Thunderbit supporta anche lo scraping delle sottopagine — puoi entrare nella scheda di dettaglio 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, dai un’occhiata al .

È legale fare scraping di IMDb? Cosa devi sapere

Gli utenti lo chiedono esplicitamente nei forum: “Una cosa del genere è legale?... IMDb non vuole che la gente faccia scraping del loro sito web.” È una domanda legittima, e nessun articolo concorrente la affronta.

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

Condizioni d'uso di IMDb: la clausola rilevante recita: “Non puoi usare data mining, robot, screen scraping o strumenti simili di raccolta ed estrazione dati su questo sito, salvo nostro espresso consenso scritto.” 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 — se stai estraendo dati pubblicamente disponibili senza effettuare il login, l’applicabilità dei ToS è discutibile. Ma si tratta di un’area legale in evoluzione.

Alternative sicure: i sono esplicitamente autorizzati per uso personale e non commerciale. L’API di TMDb è permissiva con una chiave API gratuita. Entrambe sono opzioni solide se vuoi restare chiaramente nel perimetro consentito.

Indicazione pratica: se fai scraping, usa un ritmo rispettoso (time.sleep(3) tra le richieste), imposta header corretti e non colpire percorsi bloccati da robots.txt. Per progetti commerciali, consulta un professionista legale o usa i dataset/API ufficiali.

Abbiamo trattato in modo approfondito le nel blog di Thunderbit.

Conclusione: scegli il modo giusto per fare scraping di IMDb con Python

La versione breve:

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

Aggiungi questa guida ai preferiti — la aggiornerò quando la struttura di IMDb cambierà di nuovo. E se vuoi saltare del tutto il codice, e scopri 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 fare scraping di IMDb?

I Termini di servizio di IMDb vietano lo scraping senza consenso, ma l’applicabilità dei ToS sui dati accessibili pubblicamente è legalmente discutibile dopo recenti sentenze del 2024. Le opzioni più sicure sono i (uso personale/non commerciale) o l’API di TMDb (chiave gratuita). Se fai scraping, rispetta robots.txt, usa pause 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 attuali classi con prefisso ipc-. Verifica anche di aver incluso un header User-Agent corretto, perché la sua assenza provoca un errore 403 che può sembrare un risultato vuoto.

Come faccio a estrarre più di 25 risultati da IMDb?

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

Cos'è __NEXT_DATA__ e perché dovrei usarlo per fare scraping di IMDb?

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

Posso fare scraping di IMDb senza programmare?

Sì. Due opzioni principali: (1) scaricare i — 7 file TSV che coprono oltre 26 milioni di titoli, aggiornati quotidianamente, 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 — niente codice, niente selettori da mantenere.

Scopri di più