Valutazione in Mondo Aperto

I migliori scraper di Instagram per estrarre dati da Instagram

aggiornato il 23 lug. 2026

Instagram rimane una delle piattaforme più aggressive nel bloccare lo scraping automatizzato grazie a 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 miglior rapporto costo-efficienza su larga scala

Decodo

Tasso di successo superiore al 90% sui metadati di profili e post

Apify

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

I migliori strumenti di scraping 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	Uso generico

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 personalizzati per specifici punti dati di Instagram, come "instagram-comments-collect by URL".
Uso generico: 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 che hanno restituito nel nostro benchmark:

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

Rapporto costo-efficienza degli scraper di Instagram per volume mensile

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

Caratteristiche dei migliori scraper di 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 in termini di 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, reels, commenti e dataset.

Decodo

I target Instagram di Decodo (instagram_graphql_profile, instagram_graphql_user_posts, instagram_graphql_post) restituiscono JSON analizzato tramite REST, disponibile nei piani avanzati; i piani base restituiscono 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 oltre il 90% di accuratezza 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 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 che luoghi, e consente la scoperta basata su 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 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. È invece un'API Web generica che elabora qualsiasi URL tramite un parser guidato dall'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 su Instagram; l'accesso è basato su preventivo. È un'opzione adatta se hai bisogno di un'unica API per più siti e puoi gestire modifiche allo schema.

API scraper di Instagram vs codice Python

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

Creare uno scraper per i follower di 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 di cui vuoi fare lo scraping (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 job di scraping dei profili:

Ogni URL del profilo viene racchiuso come oggetto in data e inviato al dataset dei profili.
L'API risponde con uno snapshot_id che rappresenta questo job; lo utilizzerai 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 il formato "pronto con download_url" che "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 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.

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

Automatizza un processo

Scraper per post di Instagram (tutorial Python)

Passaggio 1: Configurazione e impostazione

In questo esempio, utilizzeremo l'API del dataset Instagram più 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 il parsing degli URL, richieste HTTP, gestione di 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 la finestra temporale (DATE_START → DATE_END).

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

Costruisce 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 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 Instagram in un'unica richiesta batch.
L'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 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')

Scraper per commenti di 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 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 finestra temporale.

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

Utilizzi Google Search con la query site:instagram.com/p/ e i tuoi filtri per parola chiave e data per trovare post pertinenti.
Estrai e normalizzi gli URL dei post di Instagram con regex, rimuovi i duplicati e ti fermi una volta ottenuti NUM_POSTS post.
Memorizzi 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 Instagram al dataset dei commenti di Instagram in un unico batch.
Ogni URL è 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 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 interroga l'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 likes, 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)

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

Nessuna esecuzione 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 frequenza: Gli utenti umani non effettuano 50 richieste al secondo. Gli scraper di base riprovano con tempistiche prevedibili e Instagram li blocca immediatamente.
Reputazione dell'IP: Instagram mantiene punteggi di affidabilità IP in tempo reale, IP di datacenter e duplicazione IP. Non utilizzare proxy gratuito; questi vengono bloccati dopo poche richieste.

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

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

Instagram banna qualsiasi script che riutilizzi ripetutamente lo stesso IP. Per fare scraping di Instagram su larga scala, devi utilizzare proxy residenziali rotanti, rispettare i limiti di frequenza, introdurre ritardi ed evitare richieste dirette a Instagram. Ecco come abbiamo utilizzato 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 velocemente) e controlli di concorrenza (troppe richieste contemporaneamente). Il nostro tutorial evita questo problema:

attraverso pause tra le pagine di Google Search (time.sleep(2))
interrogando le API ogni 10 secondi,
senza mai contattare Instagram direttamente.

Scraper di Instagram utilizzati nel benchmark

Il nostro benchmark ha testato le soluzioni API scraper dedicate per Instagram 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 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 di Instagram:

Fornitore	Post di 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 automatizzati, 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 una persona 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 dei dati pubblicamente disponibili di Instagram è consentito purché si rispettino i termini della piattaforma e le leggi applicabili per analisi della concorrenza, monitoraggio del brand e analisi del sentiment. Tuttavia, è necessario sempre:

* Seguire i Termini di utilizzo di Instagram
* Evitare di raccogliere dati personali che non sono destinati a essere pubblici
* Utilizzare uno strumento di scraping di Instagram conforme alle normative regionali

Puoi estrarre post, profili pubblici e dati dei commenti. Questo include nomi utente Instagram, conteggio dei 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 utilizza un'API di scraping che gestisce blocchi, limiti di frequenza e fingerprinting per noi.

Gli endpoint API di Instagram, come l'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 23 Luglio 2026, da: https://aimultiple.com/instagram-scraping [Risorsa online]

Karatas, G. (2026, 23 Luglio). 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  = jul,
  howpublished    = {\url{https://aimultiple.com/instagram-scraping}},
  note   = {AIMultiple. Consultato il 23 Luglio 2026}
}

Gulbahar Karatas

Analista di settore

Segui

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

Visualizza il profilo completo