Extrair IMDb com Python: Código que Realmente Funciona

Se você pesquisou recentemente por "Extrair IMDb com Python", provavelmente notou uma coisa: a maioria dos tutoriais que aparece por aí está quebrada. Não é aquele tipo de quebrado “um pouco desatualizado” — é mais naquele nível “retorna zero resultados e uma chuva de erros NoneType” mesmo.

Passei as últimas semanas testando praticamente todos os principais tutoriais de scraping do IMDb que consegui achar — GeeksforGeeks, Medium, freeCodeCamp, notebooks do Kaggle, enfim, de tudo um pouco. Entre marcados para scraping do IMDb, a grande maioria ainda usa seletores CSS (td.titleColumn, td.ratingColumn) que deixaram de existir desde junho de 2023, quando o IMDb redesenhou a página do Top 250. O resultado? Fóruns cheios de desenvolvedores perguntando “por que meu código retorna vazio?” e mantenedores de bibliotecas populares como que “não há muito o que fazer, além de corrigir cada parser”. Este guia mostra dois métodos em Python que realmente funcionam hoje, como lidar com paginação e erros comuns, quando Python nem é a melhor escolha e como preparar seu scraper para o futuro — para ele não acabar no cemitério das soluções quebradas.

O que significa extrair dados do IMDb com Python?

Web scraping é o processo de extrair dados de páginas da web de forma programática — em vez de copiar e colar manualmente, você escreve um script para fazer isso por você. Quando falamos em “scraping do IMDb”, estamos falando de puxar dados estruturados de filmes (títulos, avaliações, gêneros, elenco, duração, número de votos) das páginas do IMDb usando Python.

O stack típico em Python para isso envolve três bibliotecas: requests (para buscar a página), BeautifulSoup (para interpretar 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 em JavaScript, mas, como você vai ver, existem abordagens mais rápidas.

Um aviso importante: tudo neste guia foi verificado com a estrutura atual das páginas do IMDb até meados de 2025. O IMDb costuma alterar a interface a cada 6–12 meses, então, se você estiver lendo isso em 2027, alguns seletores podem ter mudado. (Também vou mostrar como lidar com isso.)

Por que extrair IMDb com Python? Casos de uso reais

Antes de escrever uma linha de código, o que você realmente faria com os dados do IMDb? A resposta depende de quem você é.

O dataset de reviews do IMDb é um dos benchmarks de PLN mais usados no mundo — o artigo fundamental de Maas et al. (2011) já acumulou , e o conjunto de dados vem integrado ao TensorFlow, Keras e PyTorch. No Hugging Face, o dataset stanfordnlp/imdb recebe 213.321 downloads por mês e já foi usado para treinar mais de 1.500 modelos. Ou seja: se você trabalha com machine learning, provavelmente já conhece os dados do IMDb.

Mas os usos vão muito além da academia:

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

Suas opções para obter dados do IMDb (antes de escrever qualquer código)

Esta é a parte que a maioria dos tutoriais simplesmente ignora. Eles pulam direto para pip install beautifulsoup4 sem nem perguntar se scraping em Python é de fato a melhor solução para o seu caso.

Veja o cenário completo:

Algumas observações sobre essas opções. O Cinemagoer não teve release no PyPI desde maio de 2023 e a maior parte dos parsers quebrou depois do redesign do IMDb em junho de 2025 — eu não recomendaria para uso em produção agora. O TMDb é excelente, mas usa seu próprio sistema de avaliação, não o do IMDb. E a API oficial enterprise do IMDb custa via AWS Data Exchange, então não é uma opção viável para a maioria de nós.

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

Agora, para quem quer escrever Python — aqui estão dois métodos que funcionam.

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

Esta é a abordagem clássica que você encontra na maioria dos tutoriais. Funciona, mas vou ser direto: é o método mais frágil entre os que mostro aqui. Os nomes das classes CSS do IMDb são gerados automaticamente e mudam quando a interface é redesenhada. Ainda assim, é a melhor forma de aprender os fundamentos de web scraping.

Etapa 1: instalar e importar suas bibliotecas Python

Você vai precisar de quatro pacotes:

1pip install requests beautifulsoup4 pandas lxml

O que cada um faz:

• requests — envia requisições HTTP para buscar a página
• beautifulsoup4 — interpreta o HTML para que você possa procurar elementos específicos
• pandas — organiza os dados extraídos em tabelas e exporta para CSV/Excel
• lxml — um parser HTML rápido (o BeautifulSoup pode usá-lo como backend)

Seu bloco de imports:

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

Etapa 2: enviar uma requisição HTTP para o IMDb

É aqui que muita gente bate na primeira barreira. O IMDb bloqueia requisições que não incluem um cabeçalho User-Agent adequado — você recebe um erro 403 Forbidden. A string padrão do Requests (python-requests/2.31.0) é bloqueada na hora.

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

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

Etapa 3: interpretar 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 sobre um título de filme e selecione "Inspect" para ver a estrutura HTML subjacente.

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

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

• Contêiner 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 alerta: essas classes com prefixo ipc- são geradas pelo sistema de componentes do IMDb. Elas têm se mantido estáveis desde o redesign de junho de 2023, mas não há garantia de que continuarão assim.

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

Aqui eu me diferencio da maioria dos tutoriais: incluo tratamento de erros com try/except. Nenhum dos guias concorrentes que analisei faz isso, e é exatamente por isso que o código quebra em silêncio 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/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"Erro ao processar filme: {e}")
18        continue
19print(f"Extraídos {len(movies)} filmes")

Etapa 5: salvar 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())

Saída de exemplo:

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

Funciona. Mas está apoiado em seletores CSS que podem quebrar a qualquer momento — e é aí que entra a abordagem que eu realmente recomendo.

Método 2: o truque do JSON-LD — pule a interpretação do HTML por completo

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

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

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

Classes CSS como ipc-metadata-list-summary-item são geradas automaticamente pelo sistema React do IMDb e mudam a cada redesign. O schema JSON-LD representa o modelo real dos dados, não a camada visual. É como a diferença entre ler o índice de um livro e tentar identificar os capítulos pela fonte usada no título.

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

Etapa 1: buscar a página

Igual ao método 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")

Etapa 2: localizar a tag 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 o tipo: {data.get('@type', 'desconhecido')}")

Etapa 3: interpretar 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, genre, description, diretor e arrays de atores.

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    })

Etapa 4: exportar para CSV

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

Saída de exemplo:

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 e sem malabarismo com seletores CSS. E como esses dados seguem o padrão Schema.org (que o Google usa para resultados enriquecidos), eles têm muito menos chance de mudar do que o layout visual.

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

Para dados mais ricos em páginas de títulos individuais (duração, elenco completo, sinopse, imagens do pôster), o IMDb também incorpora um objeto JSON __NEXT_DATA__. Esse é o dado que o React usa para hidratar a página — não dá para removê-lo sem quebrar o site.

1# Em uma 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 e __NEXT_DATA__ para páginas individuais de títulos. Essa é a abordagem certa para produção.

Por que seu scraper do IMDb continua quebrando (e como corrigir)

Esse é, de longe, o problema 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 normalmente é silêncio ou “tente Selenium”.

A causa raiz é a migração contínua do IMDb para uma interface baseada em React/Next.js. Veja a linha do tempo das principais mudanças que quebraram scrapers:

É basicamente uma grande quebra a cada 6–12 meses. Se o seu scraper depende de nomes de classes CSS, você está correndo numa esteira.

Erros comuns e como resolver

Resultados vazios / erros NoneType

Esse é o erro mais comum. Você vai ver AttributeError: 'NoneType' object has no attribute 'text'. Isso significa que o BeautifulSoup não encontrou o elemento procurado — geralmente porque o nome da classe CSS mudou ou o conteúdo é renderizado via JavaScript.

Correção: mude para a extração via JSON-LD (Método 2 acima). Os dados já vêm na resposta HTML inicial, sem precisar de JavaScript.

403 Forbidden

O IMDb usa para detectar e bloquear bots. O principal gatilho é a ausência de um cabeçalho User-Agent realista ou o uso de um cabeçalho obviamente falso. Isso está documentado em projetos open source e nos , onde um funcionário do IMDb reconheceu o problema.

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

Apenas 25 resultados retornados

As páginas de busca do IMDb e listas “Most Popular” usam lazy loading — elas exibem cerca de 25 resultados inicialmente e carregam o restante via AJAX conforme você rola a página.

Correção: use paginação por parâmetro de URL (explicada na próxima seção) ou mude para a página Top 250, que carrega os 250 filmes de uma vez só.

Seletores param de funcionar de repente

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

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

Um framework 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 status HTTP e registre erros em vez de deixar o programa travar
• Correção de médio prazo: troque seletores CSS por extração de JSON-LD (Método 2)
• Correção de longo prazo: use os para análises em larga escala, ou uma ferramenta como o que usa IA para reler a estrutura da página a cada execução — sem seletores para manter, e a IA se adapta automaticamente às mudanças de layout

Além do limite de 25 resultados: paginação e grandes volumes no IMDb

Todo tutorial concorrente que analisei extrai exatamente uma página. Ninguém cobre paginação. Mas, se você precisar de mais de uma lista, vai bater em limites rápido.

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

Boa notícia: a página Top 250 carrega todos os 250 filmes em uma única resposta renderizada no servidor. Tanto o JSON-LD quanto o __NEXT_DATA__ contêm o conjunto completo de dados. Não é preciso paginação.

Como a paginação da busca do IMDb funciona

As páginas de busca do IMDb usam o parâmetro de URL start=, aumentando 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 vai um loop em Python para percorrer os resultados:

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 de sua preferência
11    # ...
12    print(f"Página coletada a partir de {start}")
13    time.sleep(3)  # Seja respeitoso — o IMDb costuma bloquear após ~50 requisições rápidas

Esse time.sleep(3) importa. Relatos da comunidade indicam que o IMDb começa a bloquear IPs depois de cerca de 50 requisições rápidas. Um intervalo aleatório entre 2 e 5 segundos é uma boa prática.

Quando ignorar o scraping por completo: datasets oficiais do IMDb

Para necessidades realmente grandes, o IMDb disponibiliza 7 arquivos 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# Fazer merge com tconst (ID do título no IMDb)
4merged = basics.merge(ratings, on="tconst")
5top_movies = merged[merged["titleType"] == "movie"].nlargest(250, "averageRating")

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

O atalho sem código: o Thunderbit cuida da paginação para você

Para quem precisa de dados do IMDb paginados, mas não quer escrever lógica de paginação, o oferece suporte nativo tanto para paginação por clique quanto para rolagem infinita. Você diz para ele extrair os dados, e ele faz o resto — incluindo percorrer conteúdo carregado dinamicamente.

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

Aqui estão dois scripts completos que você pode executar agora mesmo.

Script A: método com 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/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"Pulando filme por causa do erro: {e}")
28df = pd.DataFrame(movies)
29df.to_csv("imdb_top250_bs4.csv", index=False)
30print(f"Salvos {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"Salvos {len(df)} filmes")
42print(df.head())

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

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

Nem todo mundo quer ou precisa programar em Python. Talvez você seja analista de operações e só precise desta semana dos filmes mais bem avaliados em uma planilha. Talvez você trabalhe com conteúdo e queira comparar tendências de gêneros ao longo dos anos. Nesses casos, criar um scraper é exagero.

Veja como obter os mesmos dados usando o :

Antes de começar:

• Dificuldade: Iniciante
• Tempo necessário: ~2 minutos
• O que você vai precisar: navegador Chrome, (a versão gratuita funciona)

Etapa 1: abra a página do IMDb que você quer extrair. Abra o Top 250 do IMDb (ou qualquer outra lista/página de busca do IMDb) no Chrome.

Etapa 2: clique em "AI Suggest Fields" na barra lateral do Thunderbit. A IA analisa a página e sugere colunas — normalmente Título, Ano, Avaliação, Gênero e outras, dependendo da página. Você verá uma tabela de prévia com os campos sugeridos.

Etapa 3: ajuste os campos se necessário. Remova colunas que não precisa ou adicione novas clicando em "+ Add Column" e descrevendo, em linguagem natural, o que deseja (por exemplo: "Nome do diretor" ou "Número de votos").

Etapa 4: clique em "Scrape". O Thunderbit extrai os dados. Em páginas com rolagem infinita ou paginação, ele lida com isso automaticamente.

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

O grande diferencial aqui não é só a praticidade — é que a IA do Thunderbit relembra a estrutura da página a cada execução. Quando o IMDb muda o layout (e vai mudar), a IA se adapta. Sem seletores para atualizar, sem código para corrigir. Para quem já sofreu com um scraper quebrado às 2 da manhã antes de um prazo, isso vale muito.

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

É legal extrair dados do IMDb? O que você precisa saber

Usuários perguntam isso explicitamente nos fóruns: “Isso é legal?… O IMDb não quer que as pessoas façam scraping no site.” É uma pergunta justa, e nenhum artigo concorrente aborda isso.

robots.txt do IMDb: o chart 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: “Você não pode usar data mining, robots, screen scraping ou ferramentas semelhantes de coleta e extração de dados neste site, exceto com nosso consentimento expresso por escrito.” Outra cláusula proíbe revenda ou uso comercial de dados extraídos.

O que isso significa na prática: decisões judiciais recentes de 2024 (Meta v. Bright Data, X Corp v. Bright Data) entenderam que Termos de Serviço podem não vincular usuários que nunca concordaram com eles — se você estiver extraindo dados publicamente acessíveis sem login, a aplicabilidade dos ToS é discutível. Mas essa é uma área jurídica em evolução.

Alternativas mais seguras: os são explicitamente autorizados para uso pessoal e não comercial. A API do TMDb tem política permissiva com chave gratuita. Ambas são ótimas opções se você quiser ficar claramente dentro das regras.

Orientação prática: se você for extrair, use uma taxa de coleta respeitosa (time.sleep(3) entre requisições), defina cabeçalhos corretos e não acesse caminhos bloqueados pelo robots.txt. Para projetos comerciais, consulte um profissional jurídico ou use os datasets/API oficiais.

Já cobrimos em profundidade no blog da Thunderbit.

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

Resumo rápido:

• BeautifulSoup + seletores CSS: bom para aprender os fundamentos. Espere que quebre a cada 6–12 meses. Sempre inclua tratamento de erros.
• Extração via 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 entrega dados estruturados limpos sem renderização em JavaScript.
• __NEXT_DATA__ JSON: use como complemento para obter dados mais ricos em páginas individuais de títulos (duração, elenco completo, sinopse, imagens do pôster).
• Datasets oficiais do IMDb: a melhor escolha para análises em larga escala. Mais de 26 milhões de títulos, atualização diária, sem necessidade de scraping. Uso pessoal/não comercial apenas.
• : a melhor escolha para quem não programa ou para quem quer dados rápido sem manter código. A IA se adapta a mudanças de layout, lida com paginação e exporta para Excel/Sheets/Airtable/Notion.

Salve este guia nos favoritos — vou atualizá-lo quando a estrutura do IMDb mudar novamente. E se quiser pular o código por completo, e veja como é rápido sair de uma página do IMDb para uma planilha limpa. Se você também trabalha com outros sites, nosso guia sobre cobre o fluxo completo.

FAQs

É legal extrair dados do IMDb?

Os Termos de Uso do IMDb proíbem scraping sem consentimento, mas a validade desses termos em relação a dados publicamente acessíveis é juridicamente discutível após decisões judiciais de 2024. As opções mais seguras são os (uso pessoal/não comercial) ou a API do TMDb (chave gratuita). Se for fazer scraping, respeite o robots.txt, use intervalos razoáveis entre requisições e evite caminhos bloqueados. Para uso comercial, consulte um profissional jurídico.

Por que meu scraper do IMDb retorna resultados vazios?

Quase sempre a causa é um seletor CSS desatualizado — classes como td.titleColumn e td.ratingColumn não existem mais desde junho de 2023. A solução é migrar para extração via JSON-LD (fazendo parse da tag <script type="application/ld+json">) ou atualizar os seletores para as classes atuais com prefixo ipc-. Também verifique se você está enviando um cabeçalho User-Agent adequado, porque a ausência dele gera um erro 403 que pode parecer resultado vazio.

Como extrair mais de 25 resultados do IMDb?

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

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

__NEXT_DATA__ é um objeto JSON incorporado em uma tag <script id="__NEXT_DATA__"> nas páginas React/Next.js do IMDb. Ele contém os dados estruturados completos 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 subjacente de dados, e não o layout visual, ele é mais resistente a redesigns de interface do que seletores CSS. Use-o junto com JSON-LD para a abordagem mais robusta.

Posso extrair IMDb sem programar?

Sim. Duas opções principais: (1) baixar os — 7 arquivos TSV cobrindo 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 campos de extração automaticamente e exporta para Excel, Google Sheets ou CSV em dois cliques — sem código e sem manter seletores.

Saiba mais