Avaliação em Mundo Aberto

Melhores Scrapers do Instagram para Raspar Dados do Instagram

atualizado em 23 jul. 2026

O Instagram continua sendo uma das plataformas mais agressivas para bloquear raspagem automatizada devido a medidas avançadas anti-bot, como fingerprinting TLS e verificações de reputação de IP.

Se você precisa 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

Para

Bright Data

Tempo de resposta mais rápido e melhor relação custo-benefício em escala

Decodo

Taxa de sucesso de 90%+ em metadados de perfil e post

Apify

Configuração sem código com 'Actors' pré-construídos de mídia social para implantação rápida

As melhores ferramentas de scraper do Instagram de 2026

Scrapers	Páginas suportadas	Opções de raspagem	Formatos	Tipo de scraper
Bright Data	Comentários Postagens Perfis Reels	Consulta URL	CSV JSON NDJSON JSON lines	Especializada API
Apify	Comentários Postagens Perfis Hashtags Reels	Consulta URL	Table JSON	Especializada API
Decodo	Postagens Perfis Hashtags Reels	Consulta	Table JSON	Especializada API
Nimble	Sem modelos predefinidos para o IG	Consulta	JHTML JSON	Propósito geral

Os fornecedores com links são patrocinadores do AIMultiple.

API especializada: API de scraper específica do Instagram, adaptada para coletar dados exclusivamente do Instagram. Por exemplo, o Bright Data oferece modelos adaptados a pontos de dados específicos do Instagram, como “instagram-comments-collect by URL.”
Propósito geral: Oferece um scraper versátil que não é especializado para o Instagram, mas pode ser modificado para lidar com tarefas de raspagem web do Instagram.
Tipos de página suportados: Páginas onde a ferramenta de raspagem do Instagram entrega dados em um formato estruturado.

Resultados do benchmark de scrapers do Instagram

Compare o tempo de resposta mediano dos provedores e o número médio de campos que eles retornaram em nosso benchmark:

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

Custo-eficiência de scraper do Instagram por volume mensal

As opções de preços mensais para esses provedores estão listadas abaixo.

Recursos dos principais scrapers do Instagram

Bright Data

Bright Data oferece duas soluções para Instagram: uma API de Scraper em tempo real para perfis, postagens, comentários e reels, e Datasets pré-coletados para análise histórica em larga escala. Os tutoriais em Python desta página usam a API de Dataset.

Nossa API de Scraper oferece os tempos de resposta mais rápidos e a melhor eficiência de custo em escala, com uma taxa de sucesso superior a 90% para metadados de perfil e post em nossos benchmarks. Você é cobrado apenas pelos resultados bem-sucedidos; solicitações com falha não são cobradas. A API inclui cinco endpoints específicos do Instagram: perfis, postagens, reels, comentários e datasets.

Decodo

Decodo’s Instagram targets (instagram_graphql_profile, instagram_graphql_user_posts, instagram_graphql_post) retornam JSON analisado via REST, disponível em planos avançados; os planos básicos retornam dados brutos da página sem análise específica do alvo.

A ferramenta alcançou uma alta taxa de sucesso em nosso benchmark, semelhante ao Bright Data, com uma precisão superior a 90% em metadados de perfil e post. No entanto, sua cobertura de endpoints é mais restrita do que a do Bright Data ou Apify, e atualmente não oferece suporte dedicado para alvos de reels ou hashtags.

Apify

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

O console no-code permite que os usuários colem uma URL ou palavra-chave e executem o scraper sem integração de API. Além da raspagem direta por URL, oferece descoberta baseada em palavras-chave para hashtags, lugares ou usuários. Respostas a comentários e ordenação de comentários do mais recente primeiro estão disponíveis nos planos pagos, enquanto o plano gratuito é limitado a aproximadamente 15 comentários por post.

Nimble

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

O Nimble não publica preços por registro para o Instagram; o acesso é baseado em cotação. É uma opção adequada se você precisa de uma única API para vários sites e pode acomodar mudanças de esquema.

API de scraper do Instagram vs código Python

A raspagem básica em Python não funciona no Instagram devido a sistemas anti-bot fortes, por isso contamos com scraper APIs que lidam com proxies, simulação de navegador e limites de taxa.
Construímos três scrapers em Python: perfis, postagens e comentários, cada um usando jobs de API baseados em snapshot e saídas CSV limpas.
Usamos o Google Search para descobrir URLs de postagens do Instagram dentro de filtros de palavra-chave e data de forma confiável.
Nosso sistema de polling lida com estados de snapshot, downloads de fallback, análise de JSON-line e timeouts de 15 minutos.

Construir scraper de seguidores do Instagram com Python

Passo 1: Configuração e definições

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 requisições HTTP, JSON e pandas.
Define seu token de API e o ID do dataset de perfis do Instagram.
Define profile_urls, a lista de contas do Instagram que você deseja raspar (aqui é langchain.ai, mas você pode adicionar quantas quiser).

Passo 2: Enviando URLs de perfil 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 você inicia o job de raspagem de perfil:

Cada URL de perfil é encapsulada como um objeto em data e enviada para o dataset de perfis.
A API responde com um snapshot_id que representa este job; você o usará na próxima etapa para buscar os dados de perfil raspados.

Passo 3: Consultando a API até que os dados do perfil estejam 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 loop:

Verifica o status do snapshot a cada 10 segundos, até um timeout de 15 minutos.
Lida com os formatos “ready with download_url” e “items embedded in the response”, além de um endpoint de download de fallback.
Coleta todos os registros de perfil retornados na lista items antes de prosseguir.

Passo 4: Processando e salvando dados de perfil 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, você transforma os registros brutos da API em um dataset limpo:

Analisa com segurança campos numéricos como followers, posts_count e avg_engagement.
Mantém atributos úteis do perfil: IDs de conta, flags de negócio/profissional, status de verificação, bio, nome completo e URL externa.
Armazena tudo em um DataFrame pandas e grava em instagram_profiles_data.csv para análise ou relatórios adicionais.

Deixe nossa equipe automatizar um dos seus processos de negócio com agentes de IA, gratuitamente.

Automatizar um processo

Scraper de postagens do Instagram (tutorial em Python)

Passo 1: Configuração e definições

Neste exemplo, usaremos a API de dataset do Instagram mais proxies para coletar postagens 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 URL, requisições HTTP, manipulação de JSON e análise de dados com pandas.
Define seu token de API e ID do dataset do Instagram.
Configura o proxy para raspagem do Instagram.
Define os parâmetros de busca: KEYWORD, o número de postagens a buscar (NUM_POSTS) e a janela de datas (DATE_START → DATE_END).

Passo 2: Encontrando postagens do Instagram via Google search

Usamos o Google Search para encontrar postagens 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 usa o Google Search para encontrar postagens. O script:

Constrói uma consulta como site:instagram.com/p/ “{KEYWORD}” after: DATE_START before: DATE_END e pagina pelos resultados do Google.
Usa padrões regex para extrair URLs de postagens do Instagram do HTML, normaliza-as (www.instagram.com vs instagram.com) e remove duplicatas.
Pára quando tiver coletado NUM_POSTS URLs únicas ou quando atingir o número máximo de páginas de resultados do Google.

Passo 3: Enviando URLs de postagens do Instagram para a API para raspagem

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 o job de raspagem real:

Envia todas as URLs coletadas do Instagram para o dataset do Instagram em uma única requisição em lote.
A API retorna um snapshot_id que identifica este job de raspagem e é usado na próxima etapa para buscar os resultados quando o processamento estiver concluído.

Passo 3: Consultando os resultados e salvando 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')

Scraper de comentários do Instagram (Python)

Passo 1: Configuração e definições

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 URL, expressões regulares, requisições HTTP e pandas.
Define seu ID de dataset de comentários e API_TOKEN.
Configura o proxy a ser usado e define os parâmetros de busca: palavra-chave, o número de postagens das quais extrair comentários e a janela de datas.

Passo 2: Encontrando postagens do Instagram via Google search

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 você:

Usa o Google Search com a consulta site:instagram.com/p/ e seus filtros de palavra-chave e data para encontrar postagens relevantes.
Extrai e normaliza URLs de postagens do Instagram com regex, as desduplica e para quando tiver NUM_POSTS postagens.
Armazena a lista final em instagram_urls, que alimentará o scraper de comentários.

Passo 3: Enviando URLs de postagens para a API de 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 todas as URLs do Instagram para o dataset de comentários do Instagram em um único lote.
Cada URL é encapsulada como {“url”: …} para que a API saiba de qual postagem raspar os comentários.
A API retorna um snapshot_id que identifica este job de raspagem de comentários.

Passo 4: Consultando os resultados e salvando dados de comentários

Verificamos continuamente se a raspagem está concluída e, em seguida, processamos e salvamos 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 seção consulta a API a cada 10 segundos até que a raspagem seja concluída. Uma vez pronta, recupera todos os dados de comentários, extraindo informações-chave como nome de usuário do comentarista, texto do comentário, curtidas, respostas, hashtags usadas e usuários marcados. Os dados são estruturados em um DataFrame pandas e salvos como um arquivo CSV.

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

Como o Instagram detecta scrapers (por que scripts básicos em Python falham)

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

Sem execução de JavaScript: O Instagram carrega a página dinamicamente, e scripts Python não podem executar JavaScript, então as páginas aparecem vazias. Isso revela instantaneamente comportamento não humano.
Limitação de taxa: Usuários humanos não fazem 50 requisições por segundo. Scrapers básicos tentam novamente com temporização previsível, e o Instagram bloqueia isso 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 use proxies gratuito; estes são bloqueados após algumas requisições.

Usamos uma API de web scraper que lida com simulação de navegador, rotação de IP, JavaScript, limites de taxa e resolução de captcha.

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

O Instagram banirá qualquer script que reutilize o mesmo IP repetidamente. Para raspar o Instagram em escala, você deve usar proxies residenciais rotativos, respeitar os limites de taxa, introduzir atrasos e evitar requisições diretas ao Instagram. Veja como usamos proxies ao raspar 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 (muitas requisições muito rápidas) e verificações de concorrência (muitas requisições ao mesmo tempo). Nosso tutorial evita isso:

dormindo entre as páginas do Google Search (time.sleep(2))
consultando APIs a cada 10 segundos,
nunca acessando o Instagram diretamente.

Scrapers do Instagram usados no benchmark

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

Tipo de página	Apify	Bright Data	Oxylabs	Smartproxy	Zyte
Postagem do Instagram	apify/instagram-scraper	Instagram – Posts-collect by URL	❌	Raspagem de Mídia Social API – instagram_grap hql_post	❌
Perfil do Instagram	apify/instagram-profile-scraper	Instagram – Profiles – collect by URL	❌	Raspagem de Mídia Social API – instagram_grap hql_post	❌

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

Provedor	Postagem do Instagram	Perfil do Instagram
Bright Data	✅	✅
Apify	✅	✅
Decodo	✅	✅
NetNut	❌	❌
Oxylabs	❌	❌
Zyte	❌	❌

O que é raspagem do Instagram?

A raspagem do Instagram refere-se ao processo de usar software automatizado, como bots ou scripts, para coletar dados públicos de páginas do Instagram, incluindo postagens, hashtags e comentários.

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

Perguntas frequentes

Raspar dados públicos do Instagram é permitido desde que você respeite os termos da plataforma e as leis aplicáveis para análise de concorrência, monitoramento de marca e análise de sentimento. No entanto, sempre:

* Siga os Termos de Uso do Instagram
* Evite coletar dados pessoais que não sejam destinados ao público
* Use uma ferramenta de raspagem do Instagram que esteja em conformidade com as regulamentações regionais

Você pode raspar postagens, perfis públicos e dados de comentários. Isso inclui nomes de usuário do Instagram, contagem de seguidores, número de postagens, métricas de engajamento, detalhes da postagem (curtidas, hashtags, mídia) e texto do comentário com metadados básicos.

Sim. O Instagram bloqueia a raspagem direta, e é por isso que nosso tutorial evita acessar o Instagram diretamente e usa uma API de raspagem que lida com bloqueios, limites de taxa e fingerprinting para nós.

Os endpoints da API do Instagram, como a Instagram Graph API, não fornecem os dados públicos de perfil, postagem e comentário que raspamos neste tutorial. Funciona para sua própria conta comercial e requer permissões e revisão de aplicativo, por isso contamos com scraper APIs.

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 Raspar Dados do Instagram". Publicado on-line em AIMultiple.com. Acessado em 23 Julho 2026, em: https://aimultiple.com/instagram-scraping [Recurso on-line]

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

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

Gulbahar Karatas

Analista do Setor

Gülbahar é uma analista do setor da AIMultiple focada em coleta de dados da web, aplicações de dados da web e segurança de aplicações.

Ver perfil completo