Extrair IMDb com Python: Código que realmente funciona

Se você pesquisou recentemente por "Extrair IMDb com Python", provavelmente já notou uma coisa: a maioria dos tutoriais que encontra está quebrada. Não é um quebrado de "só um pouco desatualizado" — é mais do tipo "não devolve nenhum resultado e dispara uma enxurrada de erros NoneType".

Passei as últimas semanas testando todos os principais tutoriais de scraping do IMDb que consegui encontrar — GeeksforGeeks, Medium, freeCodeCamp, notebooks do Kaggle, tudo. Dos marcados para scraping do IMDb, a grande maioria ainda usa seletores CSS (td.titleColumn, td.ratingColumn) que deixaram de existir em junho de 2023, quando o IMDb redesenhou a página Top 250. O resultado? Fóruns cheios de programadores a perguntar "por que é que o meu código devolve vazio?" e responsáveis por bibliotecas populares como que "não há muito que possamos fazer para além de corrigir cada parser". Este guia cobre dois métodos em Python que realmente funcionam neste momento, como lidar com paginação e erros comuns, quando é que Python nem sequer é a melhor opção e como preparar o seu scraper para o futuro para não acabar no cemitério dos scripts mortos.

O que significa extrair dados do IMDb com Python?

Web scraping é o processo de extrair dados de páginas web de forma programática — em vez de copiar e colar manualmente, escreve-se um script para fazer isso por si. Quando falamos em "extrair dados do IMDb", queremos dizer recolher dados estruturados de filmes (títulos, classificações, géneros, elenco, duração, número de votos) a partir das páginas do IMDb usando Python.

A pilha típica de Python para isto envolve três bibliotecas: requests (para ir buscar a página), BeautifulSoup (para analisar o HTML e encontrar os dados) e pandas (para organizar e exportar os resultados). Alguns tutoriais também usam Selenium ou Playwright para páginas que exigem renderização JavaScript, mas, como vai ver, há abordagens mais rápidas.

Um aviso importante: tudo neste guia foi verificado em relação à estrutura atual das páginas do IMDb até meados de 2025. O IMDb altera as coisas aproximadamente a cada 6 a 12 meses, por isso, se estiver a ler isto em 2027, alguns seletores podem já ter mudado. (Também vou explicar como lidar com isso.)

Por que extrair dados do IMDb com Python? Casos de uso reais

Antes de escrever uma única linha de código, para que é que realmente usaria os dados do IMDb? A resposta depende de quem é.

O conjunto de dados de avaliações do IMDb é um dos benchmarks de PLN mais usados no mundo — o artigo fundamental de Maas et al. (2011) já soma , e o conjunto de dados já vem integrado no TensorFlow, Keras e PyTorch. No Hugging Face, o conjunto stanfordnlp/imdb recebe 213.321 transferências por mês e já foi usado para treinar mais de 1.500 modelos. Portanto, se trabalha com machine learning, é provável que já esteja familiarizado com os dados do IMDb.

Mas os casos de uso vão muito além da academia:

Só o mercado do turismo cinematográfico vale uma estimativa de . A Netflix gastou mais de US$ 17 mil milhões em conteúdo em 2024, com impulsionada por recomendações personalizadas. Em resumo: os dados do IMDb influenciam decisões reais em vários setores.

As suas opções para obter dados do IMDb (antes de escrever uma linha de código)

Esta é a secção que a maioria dos tutoriais ignora por completo. Saltam logo para pip install beautifulsoup4 sem sequer perguntar se o scraping em Python é a abordagem certa para o seu caso.

Aqui fica o panorama completo:

Algumas notas sobre estas opções. O Cinemagoer não tem lançamento no PyPI desde maio de 2023 e a maioria dos seus parsers deixou de funcionar depois do redesign do IMDb em junho de 2025 — eu não o recomendaria para produção neste momento. O TMDb é excelente, mas usa o seu próprio sistema de avaliação, e não o do IMDb. E a API corporativa oficial do IMDb custa através do AWS Data Exchange, por isso não é uma opção para a maioria de nós.

Para quem não quer escrever código, o lê a página do IMDb, sugere automaticamente os campos de extração (título, avaliação, ano, género) e exporta para Excel, Google Sheets, Airtable ou Notion em dois cliques. A IA adapta-se quando o IMDb muda o layout, por isso não há seletores para manter. Mais sobre isso já a seguir.

Agora, para quem quer mesmo escrever Python — aqui ficam dois métodos que funcionam.

Método 1: Extrair IMDb com Python usando BeautifulSoup (abordagem tradicional)

Esta é a abordagem clássica que encontra na maioria dos tutoriais. Funciona, mas quero ser direto: é a mais frágil das que vou mostrar. Os nomes das classes CSS do IMDb são gerados automaticamente e mudam com os redesigns. Ainda assim, continua a ser a melhor forma de aprender os fundamentos de web scraping.

Passo 1: instale e importe as suas bibliotecas Python

Precisa de quatro pacotes:

1pip install requests beautifulsoup4 pandas lxml

O que cada um faz:

• requests — envia pedidos HTTP para ir buscar a página
• beautifulsoup4 — analisa o HTML para poder procurar elementos específicos
• pandas — organiza os dados extraídos em tabelas e exporta para CSV/Excel
• lxml — um analisador HTML rápido (o BeautifulSoup pode usá-lo como backend)

O seu bloco de imports:

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

Passo 2: envie um pedido HTTP para o IMDb

É aqui que a maioria dos iniciantes bate na primeira parede. O IMDb bloqueia pedidos que não incluem um cabeçalho User-Agent adequado — vai ver um erro 403 Forbidden. A string padrão de user-agent do Python Requests (python-requests/2.31.0) é sinalizada imediatamente.

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"Falha ao obter a página: {response.status_code}")
9else:
10    print("Página obtida com sucesso")

O cabeçalho Accept-Language também é importante — sem ele, o IMDb pode devolver conteúdo noutro idioma com base na geolocalização do seu IP.

Passo 3: analise o HTML com BeautifulSoup

Depois de obter o HTML, crie um objeto BeautifulSoup e comece a procurar os elementos certos. Abra a página Top 250 do IMDb no Chrome, clique com o botão direito num título de filme e selecione "Inspecionar" para ver a estrutura HTML subjacente.

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

Até meados de 2025, a página Top 250 usa estes seletores:

• Contentor do filme: li.ipc-metadata-list-summary-item
• Título: h3.ipc-title__text
• Ano: span.cli-title-metadata-item (primeiro span)
• Avaliação: span.ipc-rating-star--rating

Um aviso: estes nomes de classe com prefixo ipc- são gerados pelo sistema de componentes do IMDb. Mantiveram-se estáveis desde o redesign de junho de 2023, mas não há garantia de que não voltem a mudar.

Passo 4: extraia os dados do filme (título, ano, avaliação)

Aqui eu sigo um caminho diferente da maioria dos tutoriais: incluo tratamento de erros com try/except. Nenhum dos guias concorrentes que analisei faz isto, e é precisamente por isso que o código deles falha silenciosamente quando um seletor muda.

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"Erro ao analisar o filme: {e}")
18        continue
19print(f"Extraídos {len(movies)} filmes")

Passo 5: guarde em CSV ou Excel com 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())

Exemplo de saída:

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

Isto funciona. Mas está dependente de seletores CSS que podem deixar de funcionar de um dia para o outro — e é aqui que entra a abordagem que eu realmente recomendo.

Método 2: o truque do JSON-LD — salte a análise do HTML por completo

Esta é a técnica que nenhum artigo concorrente cobre, e é a que eu usaria em qualquer projeto sério. O IMDb incorpora dados estruturados como (JavaScript Object Notation for Linked Data) em tags <script type="application/ld+json"> em todas as páginas. Estes dados seguem o padrão Schema.org, são usados pelo Google para resultados de pesquisa enriquecidos e mudam com muito menos frequência do que nomes de classes CSS.

O Apify IMDb Scraper, uma ferramenta de nível de produção, usa a ordem de prioridade de extração: "JSON-LD > NEXT_DATA > DOM". Essa é a hierarquia que eu também recomendaria.

Por que JSON-LD é mais fiável do que seletores CSS

Nomes de classe como ipc-metadata-list-summary-item são gerados automaticamente pelo sistema de componentes React do IMDb e mudam a cada redesign. O esquema JSON-LD representa o modelo de dados real, não a camada de apresentação. É como a diferença entre ler o índice de um livro e tentar identificar os capítulos pela espessura da fonte.

Passo a passo: extraia dados do IMDb a partir de JSON-LD

Passo 1: obtenha a página

Igual ao anterior — use requests com um cabeçalho User-Agent adequado.

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: encontre a tag de script JSON-LD

1script_tag = soup.find("script", {"type": "application/ld+json"})
2if not script_tag:
3    print("Nenhum JSON-LD encontrado nesta página")
4else:
5    data = json.loads(script_tag.string)
6    print(f"JSON-LD encontrado com tipo: {data.get('@type', 'desconhecido')}")

Passo 3: analise os dados estruturados

Na página Top 250, o JSON-LD contém um array itemListElement com todos os 250 filmes. Cada entrada inclui posição, nome, URL, aggregateRating, datePublished, género, descrição, realizador e arrays do elenco.

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: exporte para CSV

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

Exemplo de saída:

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

Todos os 250 filmes. Limpo, estruturado, sem malabarismos com seletores CSS. E, como estes dados seguem o padrão Schema.org — do qual o Google depende para resultados de pesquisa — é muito menos provável que mudem do que o layout visual.

Bónus: __NEXT_DATA__ para páginas individuais de filmes

Para dados mais ricos em páginas individuais de títulos (duração, elenco completo, resumo da trama, imagens do cartaz), o IMDb também incorpora um objeto JSON __NEXT_DATA__. Estes são os dados que o React usa para hidratar a página — não podem ser removidos sem partir o site.

1# Numa página individual de filme, como /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"]

Use JSON-LD para páginas de listas/quadros, __NEXT_DATA__ para páginas individuais de títulos. Essa é a abordagem de nível de produção.

Por que o seu scraper do IMDb continua a falhar (e como corrigir)

Este é o ponto de dor mais relatado em todos os fóruns de scraping do IMDb que consultei. As pessoas escrevem: "Parte do código quebrou por causa de mudanças na interface" e "Não funciona em 2024!" — e a resposta costuma ser silêncio ou "experimente o Selenium".

A causa raiz é a migração contínua do IMDb para uma interface React/Next.js. Aqui fica a linha temporal das principais mudanças que partiram tudo:

Isto é, aproximadamente, uma grande mudança a cada 6 a 12 meses. Se o seu scraper depende de nomes de classes CSS, está a correr numa passadeira sem sair do lugar.

Erros comuns e como corrigi-los

Resultados vazios / erros NoneType

O erro mais comum. Vai ver AttributeError: 'NoneType' object has no attribute 'text'. Isto significa que o BeautifulSoup não encontrou o elemento que estava à procura — normalmente porque o nome da classe CSS mudou ou porque o conteúdo é renderizado por JavaScript.

Correção: mude para extração de JSON-LD (Método 2 acima). Os dados estão na resposta HTML inicial, sem necessidade de JavaScript.

403 Forbidden

O IMDb usa para detetar e bloquear bots. O principal gatilho é a ausência de um cabeçalho User-Agent ou um cabeçalho obviamente falso. Isto foi documentado em projetos de código aberto e nos , onde um funcionário do IMDb reconheceu o problema.

Correção: inclua sempre uma string realista de User-Agent de navegador e o cabeçalho Accept-Language: en-US. Use requests.Session() para pooling de ligações.

Apenas 25 resultados devolvidos

As páginas de pesquisa e as listas "Mais populares" do IMDb usam carregamento preguiçoso — inicialmente renderizam cerca de 25 resultados e carregam mais via AJAX à medida que faz scroll.

Correção: use paginação por parâmetro de URL (coberta na próxima secção) ou mude para a página Top 250, que carrega todos os 250 filmes numa única resposta.

Os seletores deixam de funcionar de repente

Seletores antigos que já não funcionam: td.titleColumn, td.ratingColumn, .lister-item-header, .inline-block.ratings-imdb-rating. Se o seu código usa algum destes, está quebrado.

Correção: prefira atributos data-testid (como h1[data-testid="hero-title-block__title"]) em vez de nomes de classe gerados automaticamente. Melhor ainda: use JSON-LD.

Um quadro de decisão: correções de curto prazo vs. longo prazo

• Correção rápida: adicione blocos try/except em torno de cada seletor, valide códigos de estado HTTP e registe erros em vez de fazer o script rebentar
• Correção de médio prazo: migre de seletores CSS para extração de JSON-LD (Método 2)
• Correção de longo prazo: use os para análises em grande escala, ou uma ferramenta como o que usa IA para reler a estrutura da página sempre que necessário — sem seletores para manter, a IA adapta-se automaticamente às mudanças de layout

Para lá da barreira dos 25 resultados: paginação do IMDb e conjuntos de dados grandes

Todos os tutoriais concorrentes que analisei extraem exatamente uma página. Ninguém cobre paginação. Mas, se precisar de mais do que uma única lista, vai topar com limites depressa.

Páginas que não precisam de paginação

Boa notícia: a página Top 250 carrega todos os 250 filmes numa única resposta renderizada pelo servidor. Tanto o JSON-LD como o __NEXT_DATA__ contêm o conjunto de dados completo. Não é necessária paginação.

Como funciona a paginação da pesquisa do IMDb

As páginas de pesquisa do IMDb usam um parâmetro de URL start=, incrementando de 50 em 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

Aqui está um loop em Python que percorre os resultados por páginas:

1import time
2all_movies = []
3for start in range(1, 1001, 50):  # Percorre o 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"Falha em start={start}: {response.status_code}")
8        break
9    soup = BeautifulSoup(response.text, "lxml")
10    # Extraia os filmes usando o método que preferir
11    # ...
12    print(f"Página extraída a partir de {start}")
13    time.sleep(3)  # Seja respeitador — o IMDb bloqueia após cerca de 50 pedidos rápidos

Esse time.sleep(3) importa. Relatos da comunidade sugerem que o IMDb começa a bloquear IPs após cerca de 50 pedidos rápidos. Um atraso aleatório entre 2 e 5 segundos é uma boa prática.

Quando saltar o scraping por completo: os conjuntos de dados oficiais em massa do IMDb

Para necessidades realmente grandes, o IMDb oferece 7 ficheiros TSV gratuitos em , atualizados diariamente:

Carregá-los no Pandas é simples:

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# Juntar pelo tconst (ID de título do IMDb)
4merged = basics.merge(ratings, on="tconst")
5top_movies = merged[merged["titleType"] == "movie"].nlargest(250, "averageRating")

Estes conjuntos cobrem mais de 26 milhões de títulos. Sem paginação, sem seletores, sem erros 403. A licença é apenas para uso pessoal e não comercial — não pode republicar nem revender os dados.

O atalho sem código: o Thunderbit trata da paginação por si

Para leitores que precisam de dados do IMDb com paginação, mas não querem escrever a lógica da paginação, o oferece suporte nativo tanto à paginação por clique como ao scroll infinito. Diz-lhe o que quer extrair e ele trata do resto — incluindo o scroll de conteúdo carregado sob pedido.

Extrair IMDb com Python: o código completo e funcional (pronto para copiar e colar)

Aqui ficam dois scripts independentes que pode executar já.

Script A: método BeautifulSoup (seletores 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"Erro: {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"Ignorando filme devido a erro: {e}")
28df = pd.DataFrame(movies)
29df.to_csv("imdb_top250_bs4.csv", index=False)
30print(f"Guardados {len(df)} filmes")
31print(df.head())

Script B: método JSON-LD (recomendado)

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"Erro: {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("Nenhum dado JSON-LD encontrado")
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"Guardados {len(df)} filmes")
42print(df.head())

Ambos os scripts incluem tratamento de erros e produzem uma saída CSV limpa. O Script B traz dados mais ricos — realizador, descrição, URL — e é mais resiliente a mudanças no layout.

Como extrair IMDb sem escrever código nenhum (usando o Thunderbit)

Nem toda a gente precisa ou quer escrever Python. Talvez seja um analista de operações que só precisa dos filmes mais bem avaliados desta semana numa folha de cálculo. Talvez seja um estratega de conteúdo a querer comparar tendências de género ao longo dos anos. Nesses casos, escrever um scraper é excesso.

Veja como obter os mesmos dados usando o :

Antes de começar:

• Dificuldade: Iniciante
• Tempo necessário: ~2 minutos
• O que precisa: navegador Chrome, (o plano gratuito funciona)

Passo 1: navegue até à página do IMDb que quer extrair. Abra o Top 250 do IMDb (ou qualquer outra página de lista/pesquisa do IMDb) no Chrome.

Passo 2: clique em "IA Sugerir Campos" na barra lateral do Thunderbit. A IA analisa a página e recomenda colunas — normalmente Título, Ano, Avaliação, Género e mais algumas, dependendo da página. Vai ver uma tabela de pré-visualização com os campos sugeridos.

Passo 3: ajuste os campos se necessário. Remova colunas de que não precisa ou adicione novas clicando em "+ Adicionar Coluna" e descrevendo em linguagem natural o que pretende (por exemplo, "nome do realizador" ou "número de votos").

Passo 4: clique em "Extrair". O Thunderbit extrai os dados. Em páginas com scroll infinito ou paginação, trata do scroll automaticamente.

Passo 5: exporte. Clique no botão de exportação e escolha o formato — Excel, Google Sheets, CSV, Airtable ou Notion. Os dados chegam ao destino em segundos.

A principal vantagem aqui não é só a conveniência — é que a IA do Thunderbit volta a ler a estrutura da página sempre que corre. Quando o IMDb muda o layout (e vai mudar), a IA adapta-se. Sem seletores para atualizar, sem código para corrigir. Para quem já foi apanhado por um scraper avariado às 2h da manhã, perto de um prazo, isto vale ouro.

O Thunderbit também suporta extração de subpáginas — pode abrir a página de detalhes de cada filme e enriquecer a sua tabela com elenco, realizador, duração e outros campos que não aparecem na lista. Se quiser ver isto em ação, confira o .

É legal extrair dados do IMDb? O que precisa de saber

Os utilizadores perguntam isto explicitamente nos fóruns: "Isto é legal?... O IMDb não quer que as pessoas façam scraping do site." É uma pergunta justa, e nenhum artigo concorrente aborda isto.

robots.txt do IMDb: o gráfico Top 250 (/chart/top/), páginas individuais de títulos (/title/ttXXXXXXX/) e páginas de nomes (/name/nmXXXXXXX/) NÃO estão bloqueadas pelo robots.txt. Os caminhos bloqueados incluem /find, /_json/*, /search/name-text, /user/ur*/ratings e vários endpoints AJAX. Não há diretiva Crawl-delay especificada.

Termos de uso do IMDb: a cláusula relevante diz: "You may not use data mining, robots, screen scraping, or similar data gathering and extraction tools on this site, except with our express written consent." Outra cláusula proíbe a revenda ou o uso comercial dos dados extraídos.

O que isto significa na prática: decisões judiciais recentes de 2024 (Meta v. Bright Data, X Corp v. Bright Data) concluíram que os termos de serviço podem não vincular utilizadores que nunca os aceitaram — se estiver a extrair dados publicamente disponíveis sem iniciar sessão, a aplicabilidade dos termos é discutível. Mas esta é uma área jurídica em evolução.

Alternativas seguras: os são explicitamente autorizados para uso pessoal e não comercial. A API do TMDb é permissiva com uma chave gratuita. Ambas são opções sólidas se quiser manter-se claramente dentro das regras.

Orientação prática: se for extrair, use uma taxa de acesso respeitosa (time.sleep(3) entre pedidos), defina cabeçalhos adequados e não aceda a caminhos bloqueados pelo robots.txt. Para projetos comerciais, consulte um profissional de direito ou use os conjuntos de dados/APIs oficiais.

Cobrimos em profundidade no blog do Thunderbit.

Conclusão: escolha a forma certa de extrair IMDb com Python

A versão curta:

• BeautifulSoup + seletores CSS: bom para aprender os fundamentos. Espere que quebre a cada 6 a 12 meses. Inclua sempre tratamento de erros.
• Extração de JSON-LD: a abordagem que eu recomendaria para qualquer projeto Python contínuo. Segue o padrão Schema.org, muda muito menos do que classes CSS e devolve dados estruturados e limpos sem renderização JavaScript.
• JSON __NEXT_DATA__: use-o como complemento para obter dados mais ricos em páginas individuais de títulos (duração, elenco completo, enredo, imagens do cartaz).
• Conjuntos de dados oficiais do IMDb: a melhor opção para análise em grande escala. Mais de 26 milhões de títulos, atualizados diariamente, sem necessidade de scraping. Apenas para uso pessoal/não comercial.
• : a melhor escolha para quem não programa ou para quem quer dados rapidamente sem manter código. A IA adapta-se a mudanças de layout, lida com paginação e exporta para Excel/Sheets/Airtable/Notion.

Guarde este guia nos favoritos — vou atualizá-lo quando a estrutura do IMDb mudar novamente. E, se quiser evitar o código por completo, e veja quão rápido consegue passar de uma página do IMDb para uma folha de cálculo limpa. Se também trabalha com outros sites, o nosso guia sobre cobre o fluxo de trabalho mais amplo.

FAQs

É legal extrair dados do IMDb?

Os Termos de Serviço do IMDb proíbem scraping sem consentimento, mas a aplicabilidade desses termos sobre dados acessíveis publicamente é juridicamente discutível após decisões judiciais recentes de 2024. As opções mais seguras são os do IMDb (uso pessoal/não comercial) ou a API do TMDb (chave gratuita). Se extrair dados, respeite o robots.txt, use atrasos razoáveis entre pedidos e evite caminhos bloqueados. Para uso comercial, consulte um profissional de direito.

Porque é que o meu scraper do IMDb devolve resultados vazios?

Quase sempre, a causa são seletores CSS desatualizados — nomes de classe como td.titleColumn e td.ratingColumn deixaram de existir desde junho de 2023. A correção é mudar para a extração de JSON-LD (analisar a tag <script type="application/ld+json">) ou atualizar os seus seletores para as classes atuais com prefixo ipc-. Verifique também se está a enviar um cabeçalho User-Agent adequado, porque a sua ausência dispara um erro 403 que pode parecer um resultado vazio.

Como extraio mais de 25 resultados do IMDb?

A página Top 250 carrega todos os 250 filmes numa única resposta — não precisa de paginação. Para resultados de pesquisa, use o parâmetro de URL start= (incrementando de 50 em 50) para percorrer as páginas. Por exemplo: start=1, start=51, start=101. Adicione time.sleep(3) entre os pedidos para evitar bloqueios. Em alternativa, os conjuntos de dados oficiais do IMDb em contêm mais de 26 milhões de títulos e não exigem paginação.

O que é __NEXT_DATA__ e por que devo usá-lo para extrair IMDb?

__NEXT_DATA__ é um objeto JSON incorporado numa tag <script id="__NEXT_DATA__"> nas páginas React/Next.js do IMDb. Contém todos os dados estruturados que o React usa para renderizar a página — títulos, avaliações, elenco, géneros, duração e muito mais. Como representa o modelo de dados subjacente, e não o layout visual, é mais resistente a redesigns da interface do que seletores CSS. Use-o em conjunto com JSON-LD para a abordagem mais robusta.

Consigo extrair dados do IMDb sem programar?

Sim. Duas opções principais: (1) descarregar os do IMDb — 7 ficheiros TSV que cobrem mais de 26 milhões de títulos, atualizados diariamente, gratuitos para uso não comercial. (2) usar o , que lê a página do IMDb, sugere os campos de extração automaticamente e exporta para Excel, Google Sheets ou CSV em dois cliques — sem código, sem seletores para manter.

Saiba mais