Valutazione in Mondo Aperto

I migliori scraper di Instagram per estrarre dati da Instagram

aggiornato il 14 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 dell'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" predefiniti per i social media per una distribuzione 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 righe	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 preimpostato per IG	Query	JHTML JSON	Uso generale

I fornitori con link sono sponsor di AIMultiple.

Specializzata API: scraper API specifica per Instagram, pensata 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.”
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 provider e il numero medio di campi restituiti nel nostro benchmark:

Stabilità dei tassi di successo degli scraper di Instagram

Efficienza dei costi degli scraper di Instagram per volume mensile

Di seguito sono elencate le opzioni di prezzo mensili per questi provider.

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 di questa pagina usano 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 riusciti; le richieste non riuscite non vengono addebitate. La API include cinque endpoint specifici per Instagram: profili, post, reel, commenti e dataset.

Decodo

Decodo target Instagram (instagram_graphql_profile, instagram_graphql_user_posts, instagram_graphql_post) restituiscono JSON analizzato via REST, disponibile nei piani avanzati; i piani core restituiscono dati grezzi della pagina senza parsing specifico per il target.

Lo strumento ha ottenuto un alto tasso di successo nel nostro benchmark, simile a Bright Data, con un'accuratezza superiore al 90% sui metadati di profili e post. Tuttavia, la copertura degli endpoint è più limitata rispetto a Bright Data o Apify, e al momento non offre supporto dedicato per i target reel o 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 scoperta tramite parole chiave oltre all'input 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 tramite 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 gratuito è limitato a circa 15 commenti per post.

Nimble

Non tutti i provider 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 intelligenza artificiale 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 le modifiche dello schema.

Instagram scraper 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 API 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 entro 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.

Crea uno scraper di follower Instagram con Python

Passaggio 1: Configurazione e impostazione

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 desideri).

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 job di scraping dei profili:

Ogni URL di profilo viene racchiuso come oggetto nei dati e inviato al dataset dei profili.
La 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 della 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 di 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 della API in un dataset pulito:

Analizza in modo sicuro i campi numerici come follower, posts_count e avg_engagement.
Conserva attributi utili del profilo: ID account, flag aziendali/professionali, 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.

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: Configurazione e impostazione

In questo esempio, useremo la API del dataset Instagram e i 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, le richieste HTTP, la gestione di 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 l'intervallo di date (DATE_START → DATE_END).

Passaggio 2: Trovare post di Instagram tramite la ricerca Google

Usiamo Google Search per trovare post 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 usa 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 dei risultati di Google.

Passaggio 3: Invio degli URL dei post Instagram alla 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 Instagram in un'unica richiesta batch.
La API restituisce uno snapshot_id che identifica questo job di scraping e viene utilizzato 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: Configurazione e impostazione

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 API_TOKEN.
Configura il proxy da usare e definisce i parametri di ricerca: parola chiave, numero di post da cui estrarre i commenti e intervallo di date.

Passaggio 2: Trovare 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 puoi:

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

Passaggio 3: Invio degli URL dei post alla 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 la API sappia da quale post estrarre i commenti.
La API restituisce uno snapshot_id che identifica questo job di scraping 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 interroga la API ogni 10 secondi fino al completamento dello scraping. Una volta pronta, 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.

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)

I semplici script Python che usano requests falliscono immediatamente perché non riproducono il comportamento reale del browser e si affidano a un singolo IP che viene bloccato nel giro di pochi minuti. La piattaforma è in grado di rilevare immediatamente gli scraper web di Instagram attraverso molteplici 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. Questo rivela immediatamente un comportamento non umano.
Limitazione della velocità: Gli utenti umani non effettuano 50 richieste al secondo. Gli scraper di base ritentano con tempi prevedibili e Instagram lo blocca immediatamente.
Reputazione IP: Instagram mantiene punteggi di affidabilità 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 dei captcha.

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

Instagram banna qualsiasi script che riutilizzi 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 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:

mettendo in pausa tra le pagine di ricerca Google (time.sleep(2))
interrogando le API ogni 10 secondi,
senza mai contattare direttamente Instagram.

Scraper di Instagram utilizzati nel benchmark

Il nostro benchmark ha testato le soluzioni dedicate di scraper API per Instagram elencate di seguito. Per saperne di più, consulta la benchmark metodologia per le API 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 di 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.

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 Instagram pubblicamente disponibili è 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 necessario:

* 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. Ciò include nomi utente Instagram, numero di follower, numero di post, metriche di coinvolgimento, dettagli dei post (mi piace, hashtag, media) e testo dei commenti con metadati di base.

Sì. Instagram blocca lo scraping diretto, per questo il nostro tutorial evita di contattare direttamente Instagram e usa una API di scraping che gestisce blocchi, limiti di velocità e fingerprinting al posto nostro.

Le endpoint della API di Instagram, come la Instagram Graph API, non forniscono i dati pubblici di profili, post e commenti che estraiamo in questo tutorial. Funziona per il proprio 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) - "I migliori scraper di Instagram per estrarre dati da Instagram". Pubblicato online su AIMultiple.com. Consultato il 14 Agosto 2026, da: https://aimultiple.com/instagram-scraping [Risorsa online]

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

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

Gulbahar Karatas

Analista del settore

Segui

Gülbahar è un'analista del settore AIMultiple focalizzata sulla raccolta di dati web, sulle applicazioni dei dati web e sulla sicurezza delle applicazioni.

Visualizza il profilo completo