Is it legal to scrape Instagram?

Scraping publicly available Instagram data is allowed as long as you respect the platform’s terms and applicable laws for competitor analysis, brand monitoring, and sentiment analysis. However, always:* Follow Instagram’s Terms of Use* Avoid collecting personal data that is not intended to be public* Usan e Instagram scraping tool that complies with regional regulations

What Instagram data can you scrape?

You can scrape posts, public profiles, and comment data. This includes Instagram usernames, follower counts, posts count, engagement metrics, post details (likes, hashtags, media), and comment text with basic metadata.

Does Instagram block scraping?

Yes. Instagram blocks direct scraping, which is why our tutorial avoids hitting Instagram directly and uses a scraping API that handles blocking, rate limits, and fingerprinting for us.

Why not use the official Instagram API?

Instagram's API endpoints, like the Instagram Graph API, don’t provide the public profile, post, and comment data we scrape in this tutorial. It works for your own business account and requires permissions and app review, so we rely on scraper APIs instead.

Citar Este Benchmark

Melhores Scrapers do Instagram para Extrair Dados do Instagram

Gulbahar Karatas

atualizado em 1 jul. 2026

Veja o nosso normas éticas

Citar Este Benchmark

O Instagram continua a ser uma das plataformas mais agressivas no bloqueio de scraping automatizado devido a medidas anti-bot avançadas, como fingerprinting TLS e verificações de reputação de IP.

Quer precise de uma API de scraper de alto desempenho ou de um script Python personalizado, este guia avalia as principais ferramentas, incluindo o Apify Instagram Scraper e o Bright Data Instagram Scraper.

Fornecedor

Ideal para

Bright Data

Tempo de resposta mais rápido e melhor relação custo-eficiência em escala

Decodo

Taxa de sucesso superior a 90% em metadados de perfis e publicações

Apify

Configuração sem código com "Actors" de redes sociais pré-construídos para implementação rápida

As melhores ferramentas de scraper do Instagram de 2026

Scrapers	Páginas suportadas	Opções de scraping	Formatos	Tipo de scraper
Bright Data	Comentários Publicações Perfis Reels	Consulta URL	CSV JSON NDJSON JSON lines	API especializada ¹
Apify	Comentários Publicações Perfis Hashtags Reels	Consulta URL	Tabela JSON	API especializada ²
Decodo	Publicações Perfis Hashtags Reels	Consulta	Tabela JSON	API especializada ³
Nimble	Sem modelos predefinidos para o IG	Consulta	JHTML JSON	Uso geral

Os fornecedores com links são patrocinadores do AIMultiple.

API especializada: API de scraper específica para o Instagram, adaptada para a recolha de dados exclusivamente do Instagram. Por exemplo, a Bright Data oferece modelos adaptados a pontos de dados específicos do Instagram, como "instagram-comments-collect by URL".
Uso geral: Oferece um scraper versátil que não é especializado para o Instagram, mas que pode ser modificado para lidar com tarefas de web scraping do Instagram.
Tipos de páginas suportadas: Páginas onde a ferramenta de scraping do Instagram fornece dados num formato estruturado.

Resultados do benchmark dos scrapers do Instagram

Compare o tempo de resposta mediano dos fornecedores e o número médio de campos que devolveram no nosso benchmark:

Estabilidade das taxas de sucesso dos scrapers do Instagram ao longo do tempo

Relação custo-eficiência dos scrapers do Instagram por volume mensal

As opções de preços mensais destes fornecedores estão listadas abaixo.

Características dos melhores scrapers do Instagram

Bright Data

A Bright Data oferece duas soluções para o Instagram: uma API de Scraper em tempo real para perfis, publicações, comentários e reels, e Datasets pré-recolhidos para análise histórica em grande escala. Os tutoriais Python nesta página utilizam a API de Dataset.

A nossa API de Scraper oferece os tempos de resposta mais rápidos e a melhor eficiência de custos em escala, com uma taxa de sucesso superior a 90% para metadados de perfis e publicações nos nossos benchmarks. É faturado apenas pelos resultados bem-sucedidos; os pedidos falhados não são cobrados. A API inclui cinco endpoints específicos do Instagram: perfis, publicações, reels, comentários e datasets.

Decodo

Os alvos do Instagram do Decodo (instagram_graphql_profile, instagram_graphql_user_posts, instagram_graphql_post) devolvem JSON analisado via REST, disponível nos planos avançados; os planos básicos devolvem dados de página em bruto sem análise específica do alvo.

A ferramenta alcançou uma elevada taxa de sucesso no nosso benchmark, semelhante à Bright Data, com mais de 90% de precisão em metadados de perfis e publicações. No entanto, a sua cobertura de endpoints é mais limitada do que a da Bright Data ou da Apify, e atualmente não oferece suporte dedicado para alvos de reels ou hashtags.

Apify

O Actor apify/instagram-scraper da Apify é uma das oito ferramentas focadas no Instagram disponíveis na loja. Suporta scraping de publicações, reels, comentários, menções, perfis e hashtags, bem como locais, e permite a descoberta baseada em palavras-chave, além da entrada de URL.

A consola sem código permite aos utilizadores colar um URL ou palavra-chave e executar o scraper sem integração de API. Além do scraping direto por URL, oferece descoberta baseada em palavras-chave para hashtags, locais ou utilizadores. As respostas a comentários e a ordenação de comentários por mais recentes estão disponíveis nos planos pagos, enquanto o plano gratuito está limitado a aproximadamente 15 comentários por publicação.

Nimble

Nem todos os fornecedores nesta comparação funcionam como scrapers do Instagram da mesma forma que os três mencionados acima. Por exemplo, a Nimble não oferece um endpoint ou esquema específico para o Instagram. Em vez disso, é uma API Web geral que processa qualquer URL através de um parser orientado por IA e devolve JSON estruturado. O resultado depende do que o modelo extrai da página no momento do pedido, em vez de um conjunto fixo de campos.

A Nimble não publica preços por registo do Instagram; o acesso é baseado em orçamento. É uma opção adequada se precisar de uma única API para vários sites e puder acomodar alterações de esquema.

API de scraper do Instagram vs código Python

O scraping básico em Python não funciona no Instagram devido aos fortes sistemas anti-bot, pelo que dependemos de APIs de scraper que gerem proxies, simulação de navegador e limites de taxa.
Construímos três scrapers em Python: perfis, publicações e comentários, cada um utilizando tarefas de API baseadas em snapshots e saídas CSV limpas.
Utilizámos a Pesquisa Google para descobrir URLs de publicações do Instagram dentro de filtros de palavras-chave e datas de forma fiável.
O nosso sistema de polling gere estados de snapshot, downloads de recurso, análise de linhas JSON e timeouts de 15 minutos.

Construir scraper de seguidores do Instagram com Python

Passo 1: Configuração

1import time
2import json
3import pandas as pd
4import requests
5import urllib3
6
7urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
8
9API_TOKEN = "your_api_token_here"
10INSTAGRAM_PROFILES_DATASET_ID = "dataset_id_for_instagram_profiles_from_brightdata"
11
12profile_urls = [
13    "https://www.instagram.com/langchain.ai/",
14]

Este passo:

Importa as bibliotecas Python para pedidos HTTP, JSON e pandas.
Define o seu token de API e o ID do dataset de perfis do Instagram.
Define profile_urls, a lista de contas do Instagram que pretende extrair (aqui é langchain.ai, mas pode adicionar quantas quiser).

Passo 2: Enviar URLs de perfis para o web scraper

1trigger_url = "api_trigger_endpoint_url"
2headers = {
3    "Authorization": f"Bearer {API_TOKEN}",
4    "Content-Type": "application/json",
5}
6params = {
7    "dataset_id": INSTAGRAM_PROFILES_DATASET_ID,
8    "include_errors": "true",
9}
10
11data = [{"url": u} for u in profile_urls]
12
13try:
14    response = requests.post(trigger_url, headers=headers, params=params, json=data)
15
16    if response.status_code == 200:
17        result = response.json()
18        snapshot_id = result.get("snapshot_id")
19    else:
20        exit()
21
22except Exception as e:
23    exit()

Aqui inicia a tarefa de scraping de perfis:

Cada URL de perfil é encapsulado como um objeto em dados e enviado para o dataset de perfis.
A API responde com um snapshot_id que representa esta tarefa; irá utilizá-lo no próximo passo para obter os dados de perfil extraídos.

Passo 3: Fazer polling à API até os dados do perfil estarem prontos

1snapshot_url = f"api_snapshot_endpoint_url/{snapshot_id}"
2headers = {"Authorization": f"Bearer {API_TOKEN}"}
3
4start_time = time.time()
5max_wait_seconds = 15 * 60
6
7items = []
8while True:
9    elapsed = time.time() - start_time
10    if elapsed > max_wait_seconds:
11        exit()
12
13    try:
14        response = requests.get(snapshot_url, headers=headers)
15
16        if response.status_code not in [200, 202]:
17            time.sleep(10)
18            continue
19
20        if response.status_code == 202:
21            time.sleep(10)
22            continue
23
24        try:
25            data = response.json()
26            status = data.get("status")
27
28            if status in ["ready", "done", "complete"]:
29                download_url = data.get("download_url")
30                if download_url:
31                    download_response = requests.get(download_url)
32
33                    for line in download_response.text.strip().split('\n'):
34                        if line.strip():
35                            try:
36                                items.append(json.loads(line))
37                            except json.JSONDecodeError:
38                                pass
39
40                if items:
41                    break
42
43            items = data.get("items", [])
44            if items:
45                break
46
47            download_response = requests.get(
48                f"api_download_endpoint/{snapshot_id}/download",
49                headers=headers
50            )
51
52            for line in download_response.text.strip().split('\n'):
53                if line.strip():
54                    try:
55                        items.append(json.loads(line))
56                    except:
57                        pass
58
59            if items:
60                break
61            else:
62                exit()
63
64            elif status == "failed":
65                exit()
66
67        except json.JSONDecodeError:
68            for line in response.text.strip().split('\n'):
69                if line.strip():
70                    try:
71                        items.append(json.loads(line))
72                    except:
73                        pass
74
75            if items:
76                break
77
78        time.sleep(10)
79
80    except Exception as e:
81        time.sleep(10)
82
83if not items:
84    exit()

Este ciclo:

Verifica o estado do snapshot a cada 10 segundos, até um timeout de 15 minutos.
Lida com os formatos "pronto com download_url" e "itens incorporados na resposta", além de um endpoint de download de recurso.
Recolhe todos os registos de perfil devolvidos na lista items antes de avançar.

Passo 4: Processar e guardar dados de perfis do Instagram

1csv_data = []
2
3for item in items:
4    try:
5        followers = int(item.get('followers', 0))
6    except (ValueError, TypeError):
7        followers = 0
8
9    try:
10        posts_count = int(item.get('posts_count', 0))
11    except (ValueError, TypeError):
12        posts_count = 0
13
14    try:
15        avg_engagement = float(item.get('avg_engagement', 0.0))
16    except (ValueError, TypeError):
17        avg_engagement = 0.0
18
19    csv_data.append({
20        'account': item.get('account', 'N/A'),
21        'fbid': item.get('fbid', 'N/A'),
22        'id': item.get('id', 'N/A'),
23        'followers': followers,
24        'posts_count': posts_count,
25        'is_business_account': item.get('is_business_account', False),
26        'is_professional_account': item.get('is_professional_account', False),
27        'is_verified': item.get('is_verified', False),
28        'avg_engagement': avg_engagement,
29        'external_url': item.get('external_url', 'N/A'),
30        'biography': item.get('biography', 'N/A'),
31        'full_name': item.get('full_name', 'N/A')
32    })
33
34df = pd.DataFrame(csv_data)
35output_filename = 'instagram_profiles_data.csv'
36df.to_csv(output_filename, index=False, encoding='utf-8-sig')

Finalmente, transforma os registos em bruto da API num dataset limpo:

Analisa de forma segura campos numéricos como seguidores, posts_count e avg_engagement.
Mantém atributos úteis do perfil: IDs de conta, indicadores de negócio/profissional, estado de verificação, bio, nome completo e URL externo.
Armazena tudo num DataFrame do pandas e escreve-o em instagram_profiles_data.csv para análise ou relatórios posteriores.

Scraper de publicações do Instagram (tutorial Python)

Passo 1: Configuração

Neste exemplo, utilizaremos a API de dataset do Instagram mais proxies para recolher publicações do Instagram que correspondam a uma palavra-chave dentro de um intervalo de datas.

1import urllib.parse
2import re
3import time
4import json
5import pandas as pd
6import requests
7import urllib3
8from datetime import datetime
9
10urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
11
12API_TOKEN = "your_api_token_here"
13INSTAGRAM_DATASET_ID = "dataset_id_for_instagram_from_brightdata"
14
15proxy = {
16    "http": 'http://your_proxy_url',
17    "https": 'http://your_proxy_url'
18}
19
20KEYWORD = "Agentic AI Frameworks"
21NUM_POSTS = 5
22DATE_START = "11.05.2025"
23DATE_END = "11.10.2025"

Este bloco:

Importa as bibliotecas Python para análise de URLs, pedidos HTTP, manipulação de JSON e análise de dados com pandas.
Define o seu token de API e o ID do dataset do Instagram.
Configura o proxy para scraping do Instagram.
Define os parâmetros de pesquisa: KEYWORD, o número de publicações a obter (NUM_POSTS) e a janela de datas (DATE_START → DATE_END).

Passo 2: Encontrar publicações do Instagram via Pesquisa Google

Utilizamos a Pesquisa Google para encontrar publicações relevantes do Instagram que correspondam aos nossos critérios dentro de um intervalo de datas específico.

1all_urls = []
2start = 0
3max_pages = 5
4
5while len(all_urls) < NUM_POSTS and start < max_pages * 10:
6    query = f'site:instagram.com/p/ "{KEYWORD}" after:2025-05-11 before:2025-10-11'
7    encoded_query = urllib.parse.quote(query)
8    url = f"https://google.com/search?q={encoded_query}&start={start}&gl=us&hl=en&num=20"
9
10    headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'}
11
12    try:
13        response = requests.get(url, headers=headers, proxies=proxy, verify=False, timeout=30)
14        html = response.text
15    except Exception as e:
16        break
17
18    patterns = [
19        r'https://www\.instagram\.com/p/[A-Za-z0-9_-]+/?',
20        r'https://instagram\.com/p/[A-Za-z0-9_-]+/?',
21    ]
22
23    found_urls = []
24    seen_urls = set()
25
26    for pattern in patterns:
27        matches = re.findall(pattern, html)
28        for match in matches:
29            clean_url = match.split('?')[0].split('#')[0].rstrip('/')
30
31            if 'www.instagram.com' not in clean_url:
32                clean_url = clean_url.replace('instagram.com', 'www.instagram.com')
33
34            if clean_url not in seen_urls:
35                seen_urls.add(clean_url)
36                found_urls.append(clean_url)
37
38    if not found_urls:
39        break
40
41    for found_url in found_urls:
42        if found_url not in all_urls:
43            all_urls.append(found_url)
44            if len(all_urls) >= NUM_POSTS:
45                break
46
47    if len(all_urls) >= NUM_POSTS:
48        break
49
50    start += 10
51    time.sleep(2)
52
53instagram_urls = all_urls[:NUM_POSTS]
54
55if not instagram_urls:
56    exit()

Este passo utiliza a Pesquisa Google para encontrar publicações. O script:

Constrói uma consulta como site:instagram.com/p/ "{KEYWORD}" after: DATE_START before: DATE_END e pagina pelos resultados do Google.
Utiliza padrões regex para extrair URLs de publicações do Instagram do HTML, normaliza-as (www.instagram.com vs instagram.com) e remove duplicados.
Para quando tiver recolhido NUM_POSTS URLs únicos ou quando atingir o número máximo de páginas de resultados do Google.

Passo 3: Enviar URLs de publicações do Instagram para a API para scraping

1trigger_url = "api_trigger_endpoint_url"
2headers = {
3    "Authorization": f"Bearer {API_TOKEN}",
4    "Content-Type": "application/json",
5}
6params = {
7    "dataset_id": INSTAGRAM_DATASET_ID,
8    "include_errors": "true",
9}
10
11data = [{"url": u} for u in instagram_urls]
12
13try:
14    response = requests.post(trigger_url, headers=headers, params=params, json=data)
15
16    if response.status_code == 200:
17        result = response.json()
18        snapshot_id = result.get("snapshot_id")
19    else:
20        exit()
21
22except Exception as e:
23    exit()

Este passo inicia a tarefa de scraping propriamente dita:

Envia todos os URLs do Instagram recolhidos para o dataset do Instagram num único pedido em lote.
A API devolve um snapshot_id que identifica esta tarefa de scraping e é utilizado no próximo passo para obter os resultados assim que o processamento estiver concluído.

Passo 3: Fazer polling pelos resultados e guardar dados

1snapshot_url = f"api_snapshot_endpoint_url/{snapshot_id}"
2headers = {"Authorization": f"Bearer {API_TOKEN}"}
3
4start_time = time.time()
5max_wait_seconds = 15 * 60
6
7items = []
8while True:
9    elapsed = time.time() - start_time
10    if elapsed > max_wait_seconds:
11        exit()
12
13    try:
14        response = requests.get(snapshot_url, headers=headers)
15
16        if response.status_code not in [200, 202]:
17            time.sleep(10)
18            continue
19
20        if response.status_code == 202:
21            time.sleep(10)
22            continue
23
24        try:
25            data = response.json()
26            status = data.get("status")
27
28            if status in ["ready", "done", "complete"]:
29                download_url = data.get("download_url")
30                if download_url:
31                    download_response = requests.get(download_url)
32
33                    for line in download_response.text.strip().split('\n'):
34                        if line.strip():
35                            try:
36                                items.append(json.loads(line))
37                            except json.JSONDecodeError:
38                                pass
39
40                if items:
41                    break
42
43            items = data.get("items", [])
44            if items:
45                break
46
47            download_response = requests.get(
48                f"api_download_endpoint/{snapshot_id}/download",
49                headers=headers
50            )
51
52            for line in download_response.text.strip().split('\n'):
53                if line.strip():
54                    try:
55                        items.append(json.loads(line))
56                    except:
57                        pass
58
59            if items:
60                break
61            else:
62                exit()
63
64            elif status == "failed":
65                exit()
66
67        except json.JSONDecodeError:
68            for line in response.text.strip().split('\n'):
69                if line.strip():
70                    try:
71                        items.append(json.loads(line))
72                    except:
73                        pass
74
75            if items:
76                break
77
78        time.sleep(10)
79
80    except Exception as e:
81        time.sleep(10)
82
83if not items:
84    exit()
85
86csv_data = []
87
88for item in items:
89    try:
90        likes = int(item.get('likes', 0))
91    except (ValueError, TypeError):
92        likes = 0
93
94    try:
95        num_comments = int(item.get('num_comments', 0))
96    except (ValueError, TypeError):
97        num_comments = 0
98
99    hashtags = item.get('hashtags', [])
100    hashtags_str = ', '.join(hashtags) if isinstance(hashtags, list) else str(hashtags)
101
102    photos = item.get('photos', [])
103    photos_str = ', '.join(photos) if isinstance(photos, list) else str(photos)
104
105    videos = item.get('videos', [])
106    videos_str = ', '.join(videos) if isinstance(videos, list) else str(videos)
107
108    csv_data.append({
109        'user_posted': item.get('user_posted', 'N/A'),
110        'description': item.get('description', 'N/A'),
111        'date_posted': item.get('date_posted', 'N/A'),
112        'likes': likes,
113        'num_comments': num_comments,
114        'hashtags': hashtags_str,
115        'location': item.get('location', 'N/A'),
116        'photos': photos_str,
117        'videos': videos_str
118    })
119
120df = pd.DataFrame(csv_data)
121output_filename = f'instagram_{KEYWORD.replace(" ", "_").lower()}_posts.csv'
122df.to_csv(output_filename, index=False, encoding='utf-8-sig')

Não perca os nossos benchmarks e insights baseados em dados. O botão abre o Google; selecionar a AIMultiple confirma que deseja ver a AIMultiple com mais frequência nos resultados de pesquisa do Google.

Adicionar como fonte preferencial

Scraper de comentários do Instagram (Python)

Passo 1: Configuração

1import urllib.parse
2import re
3import time
4import json
5import pandas as pd
6import requests
7import urllib3
8from datetime import datetime
9
10urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
11
12API_TOKEN = "your_api_token_here"
13INSTAGRAM_COMMENTS_DATASET_ID = "dataset_id_for_instagram_comments_from_brightdata"
14
15proxy = {
16    "http": 'http://your_proxy_url',
17    "https": 'http://your_proxy_url'
18}
19
20KEYWORD = "Agentic AI Frameworks"
21NUM_POSTS = 5
22DATE_START = "11.05.2025"
23DATE_END = "11.10.2025"

Este passo:

Importa bibliotecas para manipulação de URLs, expressões regulares, pedidos HTTP e pandas.
Define o seu ID de dataset de comentários e API_TOKEN.
Configura o proxy a utilizar e define os parâmetros de pesquisa: palavra-chave, o número de publicações das quais extrair comentários e a janela de datas.

Passo 2: Encontrar publicações do Instagram via Pesquisa Google

1all_urls = []
2start = 0
3max_pages = 5
4
5while len(all_urls) < NUM_POSTS and start < max_pages * 10:
6    query = f'site:instagram.com/p/ "{KEYWORD}" after:2025-05-11 before:2025-10-11'
7    encoded_query = urllib.parse.quote(query)
8    url = f"https://google.com/search?q={encoded_query}&start={start}&gl=us&hl=en&num=20"
9
10    headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'}
11
12    try:
13        response = requests.get(url, headers=headers, proxies=proxy, verify=False, timeout=30)
14        html = response.text
15    except Exception as e:
16        break
17
18    patterns = [
19        r'https://www\.instagram\.com/p/[A-Za-z0-9_-]+/?',
20        r'https://instagram\.com/p/[A-Za-z0-9_-]+/?',
21    ]
22
23    found_urls = []
24    seen_urls = set()
25
26    for pattern in patterns:
27        matches = re.findall(pattern, html)
28        for match in matches:
29            clean_url = match.split('?')[0].split('#')[0].rstrip('/')
30
31            if 'www.instagram.com' not in clean_url:
32                clean_url = clean_url.replace('instagram.com', 'www.instagram.com')
33
34            if clean_url not in seen_urls:
35                seen_urls.add(clean_url)
36                found_urls.append(clean_url)
37
38    if not found_urls:
39        break
40
41    for found_url in found_urls:
42        if found_url not in all_urls:
43            all_urls.append(found_url)
44            if len(all_urls) >= NUM_POSTS:
45                break
46
47    if len(all_urls) >= NUM_POSTS:
48        break
49
50    start += 10

Aqui:

Utiliza a Pesquisa Google com a consulta site:instagram.com/p/ e os seus filtros de palavra-chave e data para encontrar publicações relevantes.
Extrai e normaliza URLs de publicações do Instagram com regex, remove duplicados e para quando tiver NUM_POSTS publicações.
Armazena a lista final em instagram_urls, que alimentará o scraper de comentários.

Passo 3: Enviar URLs de publicações para a API do scraper de comentários

1trigger_url = "api_trigger_endpoint_url"
2headers = {
3    "Authorization": f"Bearer {API_TOKEN}",
4    "Content-Type": "application/json",
5}
6params = {
7    "dataset_id": INSTAGRAM_COMMENTS_DATASET_ID,
8    "include_errors": "true",
9}
10
11data = [{"url": u} for u in instagram_urls]
12
13try:
14    response = requests.post(trigger_url, headers=headers, params=params, json=data)
15
16    if response.status_code == 200:
17        result = response.json()
18        snapshot_id = result.get("snapshot_id")
19    else:
20        exit()
21
22except Exception as e:
23    exit()

Este passo:

Envia todos os URLs do Instagram para o dataset de comentários do Instagram num único lote.
Cada URL é encapsulado como {"url": …} para que a API saiba de qual publicação extrair comentários.
A API devolve um snapshot_id que identifica esta tarefa de scraping de comentários.

Passo 4: Fazer polling pelos resultados e guardar dados de comentários

Verificamos continuamente se o scraping está concluído e, em seguida, processamos e guardamos os dados dos comentários.

1snapshot_url = f"api_snapshot_endpoint_url/{snapshot_id}"
2headers = {"Authorization": f"Bearer {API_TOKEN}"}
3
4start_time = time.time()
5max_wait_seconds = 15 * 60
6
7items = []
8while True:
9    elapsed = time.time() - start_time
10    if elapsed > max_wait_seconds:
11        exit()
12
13    try:
14        response = requests.get(snapshot_url, headers=headers)
15
16        if response.status_code not in [200, 202]:
17            time.sleep(10)
18            continue
19
20        if response.status_code == 202:
21            time.sleep(10)
22            continue
23
24        try:
25            data = response.json()
26
27            status = data.get("status")
28
29            if status in ["ready", "done", "complete"]:
30                download_url = data.get("download_url")
31                if download_url:
32                    download_response = requests.get(download_url)
33
34                    for line in download_response.text.strip().split('\n'):
35                        if line.strip():
36                            try:
37                                items.append(json.loads(line))
38                            except json.JSONDecodeError:
39                                pass
40
41                    if items:
42                        break
43
44                items = data.get("items", [])
45                if items:
46                    break
47
48                download_response = requests.get(
49                    f"api_download_endpoint/{snapshot_id}/download",
50                    headers=headers
51                )
52
53                for line in download_response.text.strip().split('\n'):
54                    if line.strip():
55                        try:
56                            items.append(json.loads(line))
57                        except:
58                            pass
59
60                if items:
61                    break
62                else:
63                    exit()
64
65            elif status == "failed":
66                exit()
67
68        except json.JSONDecodeError:
69            for line in response.text.strip().split('\n'):
70                if line.strip():
71                    try:
72                        items.append(json.loads(line))
73                    except:
74                        pass
75
76            if items:
77                break
78
79        time.sleep(10)
80
81    except Exception as e:
82        time.sleep(10)
83
84if not items:
85    exit()
86
87csv_data = []
88
89for item in items:
90    try:
91        likes_number = int(item.get('likes_number', 0))
92    except (ValueError, TypeError):
93        likes_number = 0
94
95    try:
96        replies_number = int(item.get('replies_number', 0))
97    except (ValueError, TypeError):
98        replies_number = 0
99
100    hashtag_comment = item.get('hashtag_comment', [])
101    hashtag_comment_str = ', '.join(hashtag_comment) if isinstance(hashtag_comment, list) else str(hashtag_comment)
102
103    tagged_users = item.get('tagged_users_in_comment', [])
104    tagged_users_str = ', '.join(tagged_users) if isinstance(tagged_users, list) else str(tagged_users)
105
106    csv_data.append({
107        'url': item.get('url', 'N/A'),
108        'comment_user': item.get('comment_user', 'N/A'),
109        'comment_user_url': item.get('comment_user_url', 'N/A'),
110        'comment_date': item.get('comment_date', 'N/A'),
111        'comment': item.get('comment', 'N/A'),
112        'likes_number': likes_number,
113        'replies_number': replies_number,
114        'hashtag_comment': hashtag_comment_str,
115        'tagged_users_in_comment': tagged_users_str
116    })
117
118df = pd.DataFrame(csv_data)
119output_filename = f'instagram_{KEYWORD.replace(" ", "_").lower()}_comments.csv'
120df.to_csv(output_filename, index=False, encoding='utf-8-sig')

Esta secção faz polling à API a cada 10 segundos até o scraping estar concluído. Quando estiver pronto, recupera todos os dados dos comentários, extraindo informações-chave como o nome de utilizador do comentador, texto do comentário, gostos, respostas, hashtags utilizadas e utilizadores marcados. Os dados são estruturados num DataFrame do pandas e guardados como um ficheiro CSV.

Como o Instagram deteta scrapers (por que razão os scripts Python básicos falham)

Scripts Python simples que utilizam requests falham imediatamente porque não têm comportamento real de navegador e dependem de um único IP que é bloqueado em minutos. A plataforma pode detetar web scrapers do Instagram instantaneamente através de múltiplas camadas de defesa:

Sem execução de JavaScript: O Instagram carrega a página dinamicamente, e os scripts Python não conseguem executar JavaScript, pelo que as páginas aparecem vazias. Isto revela instantaneamente comportamento não humano.
Limitação de taxa: Os utilizadores humanos não fazem 50 pedidos por segundo. Os scrapers básicos tentam novamente com um timing previsível, e o Instagram bloqueia isto imediatamente.
Reputação de IP: O Instagram mantém pontuações de confiança de IP em tempo real, IPs de datacenter e duplicação de IP. Não utilize proxies gratuitos; estes são bloqueados após alguns pedidos.

Utilizámos uma API de web scraper que lida com simulação de navegador, rotação de IP, JavaScript, limites de taxa e resolução de captchas.

Proxies, limites de taxa e execução do seu scraper do Instagram em escala

O Instagram irá banir qualquer script que reutilize o mesmo IP repetidamente. Para fazer scraping do Instagram em escala, deve utilizar proxies residenciais rotativos, respeitar os limites de taxa, introduzir atrasos e evitar pedidos diretos ao Instagram. Eis como utilizámos proxies ao extrair dados do Instagram:

1proxy = {
2    "http": 'http://your_proxy_url',
3    "https": 'http://your_proxy_url'
4}

Em escala, o Instagram realiza verificações de velocidade (demasiados pedidos demasiado rápido) e verificações de concorrência (demasiados pedidos ao mesmo tempo). O nosso tutorial evita isto:

dormindo entre páginas da Pesquisa Google (time.sleep(2))
fazendo polling às APIs a cada 10 segundos,
nunca acedendo ao Instagram diretamente.

Scrapers do Instagram utilizados no benchmark

O nosso benchmark testou as soluções de API de scraper dedicadas ao Instagram listadas abaixo. Para saber mais, consulte a metodologia do benchmark para APIs de web scraping.

Tipo de página	Apify	Bright Data	Oxylabs	Smartproxy	Zyte
Publicação do Instagram	apify/instagram-scraper	Instagram – Posts-collect by URL	❌	Social Media Scraping API – instagram_grap hql_post	❌
Perfil do Instagram	apify/instagram-profile-scraper	Instagram – Profiles – collect by URL	❌	Social Media Scraping API – instagram_grap hql_post	❌

Veja quais as principais empresas de infraestrutura web que oferecem scrapers específicos para páginas do Instagram:

Fornecedor	Publicação do Instagram	Perfil do Instagram
Bright Data	✅	✅
Apify	✅	✅
Decodo	✅	✅
NetNut	❌	❌
Oxylabs	❌	❌
Zyte	❌	❌

O que é scraping do Instagram?

Scraping do Instagram refere-se ao processo de utilização de software automatizado, como bots ou scripts, para recolher dados públicos de páginas do Instagram, incluindo publicações, hashtags e comentários.

Em vez de ter um humano a visitar manualmente um perfil para copiar a bio e colá-la no Excel, um script automatiza este processo milhares de vezes, organizando os dados num formato estruturado como CSV ou JSON para análise.

Perguntas frequentes

Fazer scraping de dados publicamente disponíveis do Instagram é permitido, desde que respeite os termos da plataforma e as leis aplicáveis para análise de concorrência, monitorização de marca e análise de sentimento. No entanto:

* Siga os Termos de Utilização do Instagram
* Evite recolher dados pessoais que não se destinam a ser públicos
* Utilize uma ferramenta de scraping do Instagram que cumpra os regulamentos regionais

Pode extrair publicações, perfis públicos e dados de comentários. Isto inclui nomes de utilizador do Instagram, contagem de seguidores, contagem de publicações, métricas de engagement, detalhes das publicações (gostos, hashtags, media) e texto dos comentários com metadados básicos.

Sim. O Instagram bloqueia o scraping direto, razão pela qual o nosso tutorial evita aceder ao Instagram diretamente e utiliza uma API de scraping que lida com bloqueios, limites de taxa e fingerprinting por nós.

Os endpoints da API do Instagram, como a Instagram Graph API, não fornecem os dados públicos de perfil, publicações e comentários que extraímos neste tutorial. Funciona para a sua própria conta empresarial e requer permissões e revisão da aplicação, pelo que dependemos de APIs de scraper.

Cite este benchmark

Escolha o formato adequado ao local onde você vai publicar. Colar a versão com link no seu CMS preserva o backlink.

Gulbahar Karatas (2026) - "Melhores Scrapers do Instagram para Extrair Dados do Instagram". Publicado on-line em AIMultiple.com. Acessado em 1 Julho 2026, em: https://aimultiple.com/instagram-scraping [Recurso on-line]

Karatas, G. (2026, 1 Julho). Melhores Scrapers do Instagram para Extrair Dados do Instagram. AIMultiple. https://aimultiple.com/instagram-scraping

@misc{karatas2026,
  author = {Karatas, Gulbahar},
  title  = {{Melhores Scrapers do Instagram para Extrair Dados do Instagram}},
  year   = {2026},
  month  = jul,
  howpublished    = {\url{https://aimultiple.com/instagram-scraping}},
  note   = {AIMultiple. Acessado em 1 Julho 2026}
}