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.

Cita Questo Benchmark

Migliori Instagram Scraper per l'Estrazione di Dati da Instagram

Gulbahar Karatas

aggiornato il 1 lug. 2026

Guarda il nostro norme etiche

Cita Questo Benchmark

Instagram rimane una delle piattaforme più aggressive nel bloccare lo scraping automatizzato a causa di misure anti-bot avanzate come il fingerprinting TLS e i controlli sulla reputazione IP.

Che tu abbia bisogno di un'API scraper ad alte prestazioni o di uno script Python personalizzato, questa guida valuta i migliori strumenti, tra cui Apify Instagram Scraper e Bright Data Instagram Scraper.

Fornitore

Per

Bright Data

Tempo di risposta più rapido e migliore efficienza dei costi su larga scala

Decodo

Tasso di successo superiore al 90% per i metadati di profili e post

Apify

Configurazione senza codice con "Actors" predefiniti per i social media per un'implementazione rapida

I migliori strumenti scraper per Instagram del 2026

Scraper	Pagine supportate	Opzioni di scraping	Formati	Tipo di scraper
Bright Data	Commenti Post Profili Reels	Query URL	CSV JSON NDJSON JSON lines	API specializzata ¹
Apify	Commenti Post Profili Hashtag Reels	Query URL	Tabella JSON	API specializzata ²
Decodo	Post Profili Hashtag Reels	Query	Tabella JSON	API specializzata ³
Nimble	Nessun modello predefinito per IG	Query	JHTML JSON	General-purpose

I fornitori con link sono sponsor di AIMultiple.

API specializzata: API scraper specifica per Instagram progettata per raccogliere dati esclusivamente da Instagram. Ad esempio, Bright Data offre modelli su misura per specifici punti dati di Instagram, come "instagram-comments-collect by URL."
General-purpose: Offre uno scraper versatile che non è specializzato per Instagram ma può essere modificato per gestire attività di scraping web su Instagram.
Tipi di pagine supportate: Pagine in cui lo strumento di scraping di Instagram fornisce dati in un formato strutturato.

Risultati del benchmark degli scraper per Instagram

Confronta il tempo di risposta mediano dei fornitori e il numero medio di campi che hanno restituito nel nostro benchmark:

Stabilità dei tassi di successo degli scraper di Instagram nel tempo

Efficienza dei costi degli scraper di Instagram in base al volume mensile

Le opzioni di prezzo mensili per questi fornitori sono elencate di seguito.

Caratteristiche dei migliori scraper per Instagram

Bright Data

Bright Data offre due soluzioni per Instagram: un'API Scraper in tempo reale per profili, post, commenti e reels, e dataset pre-raccolti per analisi storiche su larga scala. I tutorial Python in questa pagina utilizzano l'API Dataset.

La nostra API Scraper offre i tempi di risposta più rapidi e la migliore efficienza dei costi su larga scala, con un tasso di successo superiore al 90% per i metadati di profili e post nei nostri benchmark. Viene addebitato solo il costo per i risultati riusciti; le richieste non riuscite non vengono addebitate. L'API include cinque endpoint specifici per Instagram: profili, post, reels, commenti e dataset.

Decodo

Gli obiettivi Instagram di Decodo (instagram_graphql_profile, instagram_graphql_user_posts, instagram_graphql_post) restituiscono JSON analizzato via REST, disponibile nei piani avanzati; i piani base restituiscono dati di pagina grezzi senza analisi specifica per obiettivo.

Lo strumento ha ottenuto un alto tasso di successo nel nostro benchmark, simile a Bright Data, con oltre il 90% di accuratezza sui metadati di profili e post. Tuttavia, la sua copertura di endpoint è più limitata rispetto a Bright Data o Apify, e al momento non offre supporto dedicato per i target reels o hashtag.

Apify

L'Actor apify/instagram-scraper di Apify è uno degli otto strumenti focalizzati su Instagram disponibili nello store. Supporta lo scraping di post, reels, commenti, menzioni, profili e hashtag, oltre ai luoghi, e consente la scoperta basata su parole chiave oltre all'input URL.

La console senza codice consente agli utenti di incollare un URL o una parola chiave ed eseguire lo scraper senza integrazione API. Oltre allo scraping diretto degli URL, offre la scoperta basata su parole chiave per hashtag, luoghi o utenti. Le risposte ai commenti e l'ordinamento dei commenti dal più recente sono disponibili nei piani a pagamento, mentre il piano free è limitato a circa 15 commenti per post.

Nimble

Non tutti i fornitori in questo confronto funzionano come scraper di Instagram allo stesso modo dei tre sopra menzionati. Ad esempio, Nimble non offre un endpoint o uno schema specifico per Instagram. Si tratta invece di un'API Web generica che elabora qualsiasi URL attraverso un parser basato sull'IA e restituisce JSON strutturato. L'output dipende da ciò che il modello estrae dalla pagina al momento della richiesta, anziché da un insieme fisso di campi.

Nimble non pubblica prezzi per record Instagram; l'accesso è basato su preventivo. È un'opzione adatta se hai bisogno di un'unica API per più siti e puoi adattarti ai cambiamenti dello schema.

API scraper per Instagram vs codice Python

Lo scraping di base in Python non funziona su Instagram a causa dei forti sistemi anti-bot, quindi ci affidiamo a API scraper che gestiscono proxy, simulazione del browser e limiti di velocità.
Abbiamo creato tre scraper in Python: profili, post e commenti, ciascuno utilizzando lavori API basati su snapshot e output CSV puliti.
Utilizzato Google Search per scoprire in modo affidabile gli URL dei post di Instagram con filtri di parole chiave e data.
Il nostro sistema di polling gestisce gli stati degli snapshot, i download di fallback, l'analisi JSON-line e i timeout di 15 minuti.

Creare uno scraper per follower Instagram con Python

Passaggio 1: Configurazione

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]

Questo passaggio:

Importa le librerie Python per richieste HTTP, JSON e pandas.
Imposta il tuo token API e l'ID del dataset dei profili Instagram.
Definisce profile_urls, l'elenco degli account Instagram che vuoi estrarre (qui è langchain.ai, ma puoi aggiungerne quanti ne vuoi).

Passaggio 2: Invio degli URL dei profili allo scraper web

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

Qui avvii il lavoro di scraping dei profili:

Ogni URL del profilo viene racchiuso come oggetto nei dati e inviato al dataset dei profili.
L'API risponde con un snapshot_id che rappresenta questo lavoro; lo userai nel passaggio successivo per recuperare i dati del profilo estratti.

Passaggio 3: Polling dell'API fino a quando i dati del profilo sono pronti

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

Questo ciclo:

Controlla lo stato dello snapshot ogni 10 secondi, fino a un timeout di 15 minuti.
Gestisce entrambi i formati "pronto con download_url" e "elementi incorporati nella risposta", oltre a un endpoint di download di fallback.
Raccoglie tutti i record del profilo restituiti nella lista items prima di proseguire.

Passaggio 4: Elaborazione e salvataggio dei dati del profilo 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')

Infine, trasformi i record grezzi dell'API in un dataset pulito:

Analizza in modo sicuro i campi numerici come followers, posts_count e avg_engagement.
Conserva attributi utili del profilo: ID account, flag business/professional, stato di verifica, biografia, nome completo e URL esterno.
Memorizza tutto in un DataFrame pandas e lo scrive in instagram_profiles_data.csv per ulteriori analisi o report.

Scraper per post Instagram (tutorial Python)

Passaggio 1: Configurazione

In questo esempio, useremo l'API del dataset di Instagram più proxy per raccogliere post di Instagram che corrispondono a una parola chiave entro un intervallo di date.

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"

Questo blocco:

Importa le librerie Python per l'analisi degli URL, richieste HTTP, gestione JSON e analisi dei dati con pandas.
Imposta il tuo token API e l'ID del dataset Instagram.
Configura il proxy per lo scraping di Instagram.
Definisce i parametri di ricerca: KEYWORD, il numero di post da recuperare (NUM_POSTS) e l'intervallo di date (DATE_START → DATE_END).

Passaggio 2: Trovare i post di Instagram tramite Google Search

Utilizziamo Google Search per trovare post di Instagram pertinenti che corrispondono ai nostri criteri entro un intervallo di date specifico.

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

Questo passaggio utilizza Google Search per trovare i post. Lo script:

Crea una query come site:instagram.com/p/ “{KEYWORD}” after: DATE_START before: DATE_END e pagina attraverso i risultati di Google.
Utilizza pattern regex per estrarre gli URL dei post di Instagram dall'HTML, li normalizza (www.instagram.com vs instagram.com) e rimuove i duplicati.
Si ferma quando ha raccolto NUM_POSTS URL unici o quando raggiunge il numero massimo di pagine di risultati di Google.

Passaggio 3: Invio degli URL dei post di Instagram all'API per lo 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()

Questo passaggio avvia il lavoro di scraping effettivo:

Invia tutti gli URL di Instagram raccolti al dataset di Instagram in un'unica richiesta batch.
L'API restituisce un snapshot_id che identifica questo lavoro di scraping e viene utilizzato nel passaggio successivo per recuperare i risultati una volta completata l'elaborazione.

Passaggio 3: Polling per i risultati e salvataggio dei dati

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

Non perderti i nostri benchmark e approfondimenti basati sui dati. Il pulsante apre Google; selezionare AIMultiple conferma che desideri vedere AIMultiple più spesso nei risultati di ricerca di Google.

Aggiungi come fonte preferita

Scraper per commenti Instagram (Python)

Passaggio 1: Configurazione

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"

Questo passaggio:

Importa le librerie per la gestione degli URL, espressioni regolari, richieste HTTP e pandas.
Imposta l'ID del dataset dei commenti e API_TOKEN.
Configura il proxy da utilizzare e definisce i parametri di ricerca: parola chiave, numero di post da cui estrarre i commenti e intervallo di date.

Passaggio 2: Trovare i post di Instagram tramite 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

Qui tu:

Utilizzi Google Search con la query site:instagram.com/p/ e i filtri di parola chiave e data per trovare post pertinenti.
Estrai e normalizzi gli URL dei post di Instagram con regex, li deduplicate e ti fermi quando hai NUM_POSTS post.
Memorizzi l'elenco finale in instagram_urls, che alimenterà lo scraper per i commenti.

Passaggio 3: Invio degli URL dei post all'API scraper per commenti

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

Questo passaggio:

Invia tutti gli URL di Instagram al dataset dei commenti di Instagram in un'unica operazione batch.
Ogni URL è racchiuso come {"url": …} in modo che l'API sappia da quale post estrarre i commenti.
L'API restituisce un snapshot_id che identifica questo lavoro di scraping dei commenti.

Passaggio 4: Polling per i risultati e salvataggio dei dati dei commenti

Controlliamo continuamente se lo scraping è completato, quindi elaboriamo e salviamo i dati dei commenti.

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

Questa sezione effettua il polling dell'API ogni 10 secondi fino al completamento dello scraping. Una volta pronto, recupera tutti i dati dei commenti, estraendo informazioni chiave come il nome utente del commentatore, il testo del commento, i "Mi piace", le risposte, gli hashtag utilizzati e gli utenti taggati. I dati vengono strutturati in un DataFrame pandas e salvati come file CSV.

Come Instagram rileva gli scraper (perché gli script Python di base falliscono)

Semplici script Python che utilizzano requests falliscono immediatamente perché mancano del comportamento reale del browser e si basano su un singolo IP che viene bloccato in pochi minuti. La piattaforma può rilevare istantaneamente gli scraper web di Instagram attraverso più livelli di difesa:

Nessuna esecuzione di JavaScript: Instagram carica la pagina dinamicamente e gli script Python non possono eseguire JavaScript, quindi le pagine appaiono vuote. Ciò rivela immediatamente un comportamento non umano.
Limitazione della velocità: gli utenti umani non fanno 50 richieste al secondo. Gli scraper di base riprovano con tempi prevedibili e Instagram lo blocca immediatamente.
Reputazione IP: Instagram mantiene punteggi di fiducia IP in tempo reale, IP di datacenter e duplicazione IP. Non utilizzare proxy free; questi vengono bloccati dopo poche richieste.

Abbiamo utilizzato un'API di web scraper che gestisce la simulazione del browser, la rotazione IP, JavaScript, i limiti di velocità e la risoluzione dei captcha.

Proxy, limiti di velocità e esecuzione dello scraper Instagram su larga scala

Instagram banna qualsiasi script che riutilizza ripetutamente lo stesso IP. Per eseguire lo scraping di Instagram su larga scala, è necessario utilizzare proxy residenziali rotanti, rispettare i limiti di velocità, introdurre ritardi ed evitare richieste dirette a Instagram. Ecco come abbiamo utilizzato i proxy durante lo scraping dei dati da Instagram:

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

Su larga scala, Instagram esegue controlli di velocità (troppe richieste troppo veloci) e controlli di concorrenza (troppe richieste contemporaneamente). Il nostro tutorial evita questo problema:

dormendo tra le pagine di Google Search (time.sleep(2))
effettuando il polling delle API ogni 10 secondi,
mai colpendo Instagram direttamente.

Scraper Instagram utilizzati nel benchmark

Il nostro benchmark ha testato le soluzioni API di scraper Instagram dedicate elencate di seguito. Per saperne di più, consulta la metodologia del benchmark per le API di web scraping.

Tipo di pagina	Apify	Bright Data	Oxylabs	Smartproxy	Zyte
Post Instagram	apify/instagram-scraper	Instagram – Posts-collect by URL	❌	Social Media Scraping API – instagram_grap hql_post	❌
Profilo Instagram	apify/instagram-profile-scraper	Instagram – Profiles – collect by URL	❌	Social Media Scraping API – instagram_grap hql_post	❌

Scopri quali importanti aziende di infrastrutture web offrono scraper specifici per le pagine di Instagram:

Fornitore	Post Instagram	Profilo Instagram
Bright Data	✅	✅
Apify	✅	✅
Decodo	✅	✅
NetNut	❌	❌
Oxylabs	❌	❌
Zyte	❌	❌

Cos'è lo scraping di Instagram?

Lo scraping di Instagram si riferisce al processo di utilizzo di software automatizzato, come bot o script, per raccogliere dati pubblici dalle pagine di Instagram, inclusi post, hashtag e commenti.

Invece di far visitare manualmente un profilo a un essere umano per copiare la biografia e incollarla in Excel, uno script automatizza questo processo migliaia di volte, organizzando i dati in un formato strutturato come CSV o JSON per l'analisi.

FAQ

Lo scraping di dati pubblicamente disponibili su Instagram è consentito purché si rispettino i termini della piattaforma e le leggi applicabili per l'analisi della concorrenza, il monitoraggio del marchio e l'analisi del sentiment. Tuttavia, sempre:

* Segui i Termini di utilizzo di Instagram
* Evita di raccogliere dati personali che non sono destinati a essere pubblici
* Utilizza uno strumento di scraping di Instagram che rispetti le normative regionali

Puoi estrarre post, profili pubblici e dati dei commenti. Ciò include i nomi utente di Instagram, il conteggio dei follower, il numero di post, le metriche di coinvolgimento, i dettagli del post (mi piace, hashtag, media) e il testo del commento con i metadati di base.

Sì. Instagram blocca lo scraping diretto, ecco perché il nostro tutorial evita di colpire Instagram direttamente e utilizza un'API di scraping che gestisce il blocco, i limiti di velocità e il fingerprinting per noi.

Gli endpoint API di Instagram, come l'API Graph di Instagram, non forniscono i dati di profili pubblici, post e commenti che estraiamo in questo tutorial. Funziona per il tuo account aziendale e richiede autorizzazioni e revisione dell'app, quindi ci affidiamo invece alle API scraper.

Cita questo benchmark

Scegli il formato adatto a dove pubblicherai. Incollare la versione con link nel tuo CMS preserva il backlink.

Gulbahar Karatas (2026) - "Migliori Instagram Scraper per l'Estrazione di Dati da Instagram". Pubblicato online su AIMultiple.com. Consultato il 1 Luglio 2026, da: https://aimultiple.com/instagram-scraping [Risorsa online]

Karatas, G. (2026, 1 Luglio). Migliori Instagram Scraper per l'Estrazione di Dati da Instagram. AIMultiple. https://aimultiple.com/instagram-scraping

@misc{karatas2026,
  author = {Karatas, Gulbahar},
  title  = {{Migliori Instagram Scraper per l'Estrazione di Dati da Instagram}},
  year   = {2026},
  month  = jul,
  howpublished    = {\url{https://aimultiple.com/instagram-scraping}},
  note   = {AIMultiple. Consultato il 1 Luglio 2026}
}

Collegamenti di riferimento

Instagram

Gulbahar Karatas

Analista di settore

Segui

Gülbahar è un analista di settore di AIMultiple specializzato nella raccolta di dati web, nelle applicazioni dei dati web e nella sicurezza delle applicazioni.

Visualizza il profilo completo