Valutazione in Mondo Aperto

Migliori scraper di Instagram per estrarre dati da Instagram

aggiornato il 21 ago. 2026

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 uno scraper ad alte prestazioni API 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

Tempi di risposta più rapidi e migliore efficienza dei costi su larga scala

Decodo

90%+ tasso di successo sui metadati di profili e post

Apify

Configurazione no-code con "Actors" social media predefiniti per una distribuzione rapida

I migliori strumenti di scraper 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	Specializzata API
Apify	Commenti Post Profili Hashtag Reels	Query URL	Tabella JSON	Specializzata API
Decodo	Post Profili Hashtag Reels	Query	Tabella JSON	Specializzata API
Nimble	Nessun modello predefinito per IG	Query	JHTML JSON	Uso generale

I fornitori con link sono sponsor di AIMultiple.

Specializzata API: scraper API specifico per Instagram, creato per raccogliere dati esclusivamente da Instagram. Ad esempio, Bright Data offre modelli personalizzati per specifici punti dati di Instagram, come “instagram-comments-collect by URL.”
Uso generale: Offre uno scraper versatile che non è specializzato per Instagram ma può essere modificato per gestire attività di web scraping su Instagram.
Tipi di pagina supportati: Pagine in cui lo strumento di scraping di Instagram fornisce dati in un formato strutturato.

Risultati del benchmark degli scraper di Instagram

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

Stabilità dei tassi di successo degli scraper di Instagram

Efficienza dei costi degli scraper Instagram per volume mensile

Di seguito sono elencate le opzioni di prezzo mensile per questi fornitori.

Caratteristiche dei migliori scraper di Instagram

Bright Data

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

La nostra Scraper API 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. Vieni fatturato solo per i risultati andati a buon fine; le richieste fallite non vengono addebitate. L'API include cinque endpoint specifici per Instagram: profili, post, reel, commenti e dataset.

Decodo

I Decodo’s Instagram targets (instagram_graphql_profile, instagram_graphql_user_posts, instagram_graphql_post) restituiscono JSON analizzato tramite REST, disponibili sui piani avanzati; i piani core restituiscono i dati grezzi della pagina senza parsing specifico per target.

Lo strumento ha raggiunto un alto tasso di successo nel nostro benchmark, simile a Bright Data, con una precisione superiore al 90% sui metadati di profili e post. Tuttavia, la sua copertura degli endpoint è più limitata rispetto a Bright Data o Apify, e al momento non offre supporto dedicato per reel o target hashtag.

Apify

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

La console no-code 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 ricerca per 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 gratuito è 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 menzionati sopra. Ad esempio, Nimble non offre un endpoint o uno schema specifico per Instagram. Si tratta invece di una Web API generale che elabora qualsiasi URL tramite un parser basato su IA e restituisce JSON strutturato. L'output dipende da ciò che il modello estrae dalla pagina al momento della richiesta, piuttosto che da un insieme fisso di campi.

Nimble non pubblica prezzi Instagram per record; l'accesso è basato su preventivo. È un'opzione adatta se hai bisogno di una singola API per più siti e puoi gestire modifiche allo schema.

Scraper Instagram API vs codice Python

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

Creare uno scraper per follower Instagram con Python

Passaggio 1: Setup e 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 le 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 vuoi).

Passaggio 2: Invio degli URL dei profili al 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()

Qui avvii il job di scraping dei profili:

Ogni URL di profilo viene racchiuso come oggetto nei dati e inviato al dataset dei profili.
L'API risponde con uno snapshot_id che rappresenta questo job; 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 sia i formati “pronto con download_url” sia “elementi incorporati nella risposta”, oltre a un endpoint di download di fallback.
Raccoglie tutti i record dei profili restituiti nell'elenco items prima di procedere.

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 gli attributi utili del profilo: ID account, flag business/professionali, stato di verifica, bio, nome completo e URL esterno.
Memorizza tutto in un DataFrame pandas e lo scrive in instagram_profiles_data.csv per ulteriori analisi o report.

Lascia che il nostro team automatizzi uno dei tuoi processi aziendali con agenti IA, gratuitamente.

Automatizza un processo

Scraper di post Instagram (tutorial Python)

Passaggio 1: Setup e configurazione

In questo esempio, useremo l'API del dataset Instagram più proxy per raccogliere i post di Instagram che corrispondono a una parola chiave in 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, le richieste HTTP, la gestione JSON e l'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 la finestra temporale (DATE_START → DATE_END).

Passaggio 2: Trovare i post di Instagram tramite la ricerca Google

Usiamo Google Search per trovare i post Instagram pertinenti che corrispondono ai nostri criteri in 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 usa Google Search per trovare i post. Lo script:

Costruisce una query come site:instagram.com/p/ “{KEYWORD}” after: DATE_START before: DATE_END e pagina tra i risultati di Google.
Usa espressioni regolari 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 job di scraping vero e proprio:

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

Passaggio 3: Polling dei 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')

Scraper di commenti Instagram (Python)

Passaggio 1: Setup e 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, le espressioni regolari, le richieste HTTP e pandas.
Imposta l'ID del dataset dei commenti e il API_TOKEN.
Configura il proxy da usare e definisce i parametri di ricerca: parola chiave, numero di post da cui estrarre i commenti e finestra temporale.

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

Qui:

Usa Google Search con la query site:instagram.com/p/ e i tuoi filtri per parola chiave e data per trovare i post pertinenti.
Estrai e normalizza gli URL dei post di Instagram con regex, rimuovi i duplicati e fermati una volta che hai NUM_POSTS post.
Memorizza l'elenco finale in instagram_urls, che alimenterà lo scraper dei commenti.

Passaggio 3: Invio degli URL dei post all'API dello scraper dei 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 unico batch.
Ogni URL viene racchiuso come {“url”: …} in modo che l'API sappia da quale post estrarre i commenti.
L'API restituisce uno snapshot_id che identifica questo job di estrazione dei commenti.

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

Controlliamo continuamente se lo scraping è completo, 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 esegue 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 like, le risposte, gli hashtag utilizzati e gli utenti taggati. I dati vengono strutturati in un DataFrame pandas e salvati come file CSV.

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

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

Gli script Python semplici che usano requests falliscono immediatamente perché non hanno un comportamento reale del browser e si affidano a un singolo IP che viene bloccato in pochi minuti. La piattaforma può rilevare istantaneamente gli scraper web di Instagram attraverso molteplici livelli di difesa:

Nessuna esecuzione di JavaScript: Instagram carica la pagina in modo dinamico e gli script Python non possono eseguire JavaScript, quindi le pagine appaiono vuote. Questo rivela immediatamente un comportamento non umano.
Limitazione della frequenza: Gli utenti umani non effettuano 50 richieste al secondo. Gli scraper di base ritentano con tempi prevedibili e Instagram li blocca immediatamente.
Reputazione IP: Instagram mantiene punteggi di fiducia IP in tempo reale, IP di datacenter e duplicazione IP. Non usare proxy gratuito; questi vengono bloccati dopo poche richieste.

Abbiamo usato una web scraper API che gestisce la simulazione del browser, la rotazione IP, JavaScript, i limiti di velocità e la risoluzione di captcha.

Proxy, limiti di velocità & esecuzione del tuo scraper Instagram su larga scala

Instagram banna qualsiasi script che riutilizza ripetutamente lo stesso IP. Per estrarre dati da Instagram su larga scala, devi usare proxy residenziali rotanti, rispettare i limiti di velocità, introdurre ritardi ed evitare richieste dirette a Instagram. Ecco come abbiamo usato i proxy durante l'estrazione 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:

mettendo in pausa tra le pagine di Google Search (time.sleep(2))
eseguendo il polling delle APIs ogni 10 secondi,
non contattando mai Instagram direttamente.

Scraper di Instagram usati nel benchmark

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

Tipo di pagina	Apify	Bright Data	Oxylabs	Smartproxy	Zyte
Post di 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 grandi aziende di infrastrutture web offrono scraper specifici per le pagine Instagram:

Provider	Post Instagram	Profilo Instagram
Bright Data	✅	✅
Apify	✅	✅
Decodo	✅	✅
Oxylabs	❌	❌
Zyte	❌	❌

Che 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 Instagram, inclusi post, hashtag e commenti.

Piuttosto che far visitare manualmente un profilo a una persona per copiare la bio 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 dei dati Instagram pubblicamente disponibili è consentito purché tu rispetti i termini della piattaforma e le leggi applicabili per l'analisi della concorrenza, il monitoraggio del brand e l'analisi del sentiment. Tuttavia, ricorda sempre di:

* Segui i Termini di utilizzo di Instagram
* Evita di raccogliere dati personali che non sono destinati a essere pubblici
* Usa uno strumento di scraping di Instagram conforme alle normative regionali

Puoi estrarre post, profili pubblici e dati dei commenti. Questo include nomi utente Instagram, numero di follower, numero di post, metriche di engagement, dettagli dei post (like, hashtag, media) e testo dei commenti con metadati di base.

Sì. Instagram blocca lo scraping diretto, motivo per cui il nostro tutorial evita di contattare Instagram direttamente e usa un'API di scraping che gestisce il blocco, i limiti di velocità e il fingerprinting per noi.

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

Cita questa ricerca

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

Gulbahar Karatas (2026) - "Migliori scraper di Instagram per estrarre dati da Instagram". Pubblicato online su AIMultiple.com. Consultato il 21 Agosto 2026, da: https://aimultiple.com/instagram-scraping [Risorsa online]

Karatas, G. (2026, 21 Agosto). Migliori scraper di Instagram per estrarre dati da Instagram. AIMultiple. https://aimultiple.com/instagram-scraping

@misc{karatas2026,
  author = {Karatas, Gulbahar},
  title  = {{Migliori scraper di Instagram per estrarre dati da Instagram}},
  year   = {2026},
  month  = aug,
  howpublished    = {\url{https://aimultiple.com/instagram-scraping}},
  note   = {AIMultiple. Consultato il 21 Agosto 2026}
}

Scarica tutti i dati

Risultati e timestamp di 11 punti dati. Scarica i dati utilizzati in questo articolo come file ZIP contenente 3 file CSV.

Ultimo aggiornamento: 17 Agosto 2026

Scarica

Registro delle modifiche

8 aggiornamenti

202526 Dic
Aggiunta una sezione, Stabilità dei tassi di successo degli scraper di Instagram nel tempo.
19 Nov
L'articolo è stato ampliato con esempi di codice Python per lo scraping di profili, post e commenti di Instagram.
11 Nov
Rimossa la sezione di panoramica delle prestazioni dell'API dello scraper di Instagram.
12 Mar
Aggiunto Instagram scrapers used in benchmark alla sezione Instagram scraper APIs benchmark results.
17 Feb
Aggiornata la metodologia di benchmark nell'introduzione.
202410 Dic
Aggiunta una definizione di scraping di Instagram alla sezione 'Cos'è lo scraping di Instagram?'.
9 Dic
Aggiornata la sezione "Come estrarre dati da Instagram" con nuovi metodi.
28 Nov
Aggiunti i risultati del benchmark e i prezzi per le API di scraper dedicate all'introduzione.

Gulbahar Karatas

Analista di settore

Segui

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

Visualizza il profilo completo