Évaluation en Monde Ouvert

Meilleurs scrapers Instagram pour extraire les données d'Instagram

mis à jour le 23 juil. 2026

Instagram reste l'une des plateformes les plus agressives pour bloquer le scraping automatisé en raison de mesures anti-bots avancées comme le fingerprinting TLS et la vérification de la réputation des IP.

Que vous ayez besoin d'un scraper haute performance API ou d'un script Python personnalisé, ce guide évalue les meilleurs outils, y compris Apify Instagram Scraper et Bright Data Instagram Scraper.

Fournisseur

Pour

Bright Data

Temps de réponse le plus rapide et meilleur rapport coût-efficacité à grande échelle

Decodo

90%+ de taux de succès sur les métadonnées de profil et de post

Apify

Configuration sans code avec des « Acteurs » pré-construits pour les réseaux sociaux, déploiement rapide

Les meilleurs outils de scraping Instagram de 2026

Scrapers	Pages supportées	Options de scraping	Formats	Type de scraper
Bright Data	Commentaires Posts Profils Reels	Requête URL	CSV JSON NDJSON JSON lines	API spécialisée
Apify	Commentaires Posts Profils Hashtags Reels	Requête URL	Table JSON	API spécialisée
Decodo	Posts Profils Hashtags Reels	Requête	Table JSON	API spécialisée
Nimble	Pas de modèles préconfigurés pour IG	Requête	JHTML JSON	Usage général

Les fournisseurs avec des liens sont les sponsors d'AIMultiple.

API spécialisée : API de scraping spécifique à Instagram, conçue pour collecter exclusivement les données d'Instagram. Par exemple, Bright Data propose des modèles adaptés à des points de données Instagram particuliers, comme « instagram-comments-collect by URL ».
Usage général : Propose un scraper polyvalent non spécialisé pour Instagram, mais pouvant être modifié pour gérer des tâches de scraping web d'Instagram.
Types de pages supportées : Pages pour lesquelles l'outil de scraping Instagram fournit les données dans un format structuré.

Résultats du benchmark des scrapers Instagram

Comparez le temps de réponse médian des fournisseurs et le nombre moyen de champs renvoyés dans notre benchmark :

Stabilité des taux de succès des scrapers Instagram dans le temps

Rapport coût-efficacité des scrapers Instagram par volume mensuel

Les tarifs mensuels de ces fournisseurs sont listés ci-dessous.

Fonctionnalités des meilleurs scrapers Instagram

Bright Data

Bright Data propose deux solutions Instagram : une API Scraper en temps réel pour les profils, posts, commentaires et reels, et des jeux de données pré-collectés pour l'analyse historique à grande échelle. Les tutoriels Python de cette page utilisent l'API Dataset.

Notre API Scraper offre les temps de réponse les plus rapides et le meilleur rapport coût-efficacité à grande échelle, avec un taux de succès supérieur à 90% pour les métadonnées de profil et de post dans nos benchmarks. Vous n'êtes facturé que pour les résultats réussis ; les requêtes échouées ne sont pas facturées. L'API inclut cinq endpoints spécifiques à Instagram : profils, posts, reels, commentaires et jeux de données.

Decodo

Decodo’s cibles Instagram (instagram_graphql_profile, instagram_graphql_user_posts, instagram_graphql_post) renvoient du JSON parsé via REST, disponible sur les plans avancés ; les plans de base renvoient les données brutes de la page sans le parsing spécifique à la cible.

L'outil a atteint un taux de succès élevé dans notre benchmark, similaire à Bright Data, avec une précision supérieure à 90% sur les métadonnées de profil et de post. Cependant, sa couverture de endpoints est plus étroite que celle de Bright Data ou Apify, et il ne propose actuellement pas de support dédié pour les cibles reels ou hashtags.

Apify

L'Acteur apify/instagram-scraper d'Apify est l'un des huit outils dédiés à Instagram disponibles dans le store. Il supporte le scraping de posts, reels, commentaires, mentions, profils et hashtags, ainsi que les lieux, et permet la découverte par mots-clés en plus de la saisie d'URL.

La console sans code permet aux utilisateurs de coller une URL ou un mot-clé et d'exécuter le scraper sans intégration d'API. En plus du scraping direct par URL, il offre la découverte par mots-clés pour les hashtags, les lieux ou les utilisateurs. Les réponses aux commentaires et le tri des commentaires par ordre du plus récent sont disponibles sur les plans payants, tandis que le plan gratuit est limité à environ 15 commentaires par post.

Nimble

Tous les fournisseurs de cette comparaison ne fonctionnent pas comme des scrapers Instagram de la même manière que les trois mentionnés ci-dessus. Par exemple, Nimble ne propose pas de endpoint ou de schéma spécifique à Instagram. Il s'agit plutôt d'une API Web générale qui traite n'importe quelle URL via un parseur piloté par IA et renvoie du JSON structuré. La sortie dépend de ce que le modèle extrait de la page au moment de la requête, plutôt que d'un ensemble fixe de champs.

Nimble ne publie pas de tarification Instagram par enregistrement ; l'accès est basé sur un devis. C'est une option appropriée si vous avez besoin d'une seule API pour plusieurs sites et pouvez vous adapter aux changements de schéma.

API de scraper Instagram vs code Python

Le scraping Python basique ne fonctionne pas sur Instagram en raison des systèmes anti-bots puissants, donc nous appuyons sur les API de scraping qui gèrent les proxies, la simulation de navigateur et les limites de taux.
Nous avons construit trois scrapers en Python : profils, posts et commentaires, chacun utilisant des tâches d'API basées sur des snapshots et des sorties CSV propres.
Nous avons utilisé la recherche Google pour découvrir les URL de posts Instagram avec des filtres de mots-clés et de dates de manière fiable.
Notre système d'interrogation gère les états de snapshot, les téléchargements de secours, le parsing des lignes JSON et des délais de 15 minutes.

Créer un scraper de followers Instagram avec Python

Étape 1 : Configuration

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]

Cette étape :

Importe les bibliothèques Python pour les requêtes HTTP, le JSON et pandas.
Définissez votre token d'API et l'ID du jeu de données des profils Instagram.
Définit profile_urls, la liste des comptes Instagram que vous souhaitez scraper (ici c'est langchain.ai, mais vous pouvez en ajouter autant que vous voulez).

Étape 2 : Soumettre les URL de profil au 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()

Ici vous lancez la tâche de scraping de profil :

Chaque URL de profil est enveloppée comme un objet dans data et envoyée au jeu de données de profils.
L'API répond avec un snapshot_id proxy cette tâche ; vous l'utiliserez à l'étape suivante pour récupérer les données de profil scrapées.

Étape 3 : Interroger l'API jusqu'à ce que les données de profil soient prêtes

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

Cette boucle :

Vérifie le statut du snapshot toutes les 10 secondes, jusqu'à un délai d'attente de 15 minutes.
Gère à la fois les formats « prêt avec download_url » et « éléments intégrés dans la réponse », plus un point de téléchargement de secours.
Collecte tous les enregistrements de profil renvoyés dans la liste items avant de passer à la suite.

Étape 4 : Traitement et sauvegarde des données de profil 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')

Enfin, vous transformez les enregistrements bruts de l'API en un jeu de données propre :

Parse en toute sécurité les champs numériques comme followers, posts_count et avg_engagement.
Conserve les attributs de profil utiles : IDs de compte, indicateurs business/professionnel, statut de vérification, bio, nom complet et URL externe.
Stocke le tout dans un DataFrame pandas et l'écrit dans instagram_profiles_data.csv pour une analyse ou un reporting ultérieur.

Laissez notre équipe automatiser l'un de vos processus métier avec des agents IA, gratuitement.

Automatiser un processus

Scraper de posts Instagram (tutoriel Python)

Étape 1 : Configuration

Dans cet exemple, nous utiliserons l'API de jeux de données Instagram plus des proxies pour collecter des posts Instagram correspondant à un mot-clé dans une plage de dates.

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"

Ce bloc :

Importe les bibliothèques Python pour le parsing d'URL, les requêtes HTTP, la manipulation de JSON et l'analyse de données avec pandas.
Définissez votre token d'API et l'ID du jeu de données Instagram.
Configure le proxy pour le scraping Instagram.
Définit les paramètres de recherche : KEYWORD, le nombre de posts à récupérer (NUM_POSTS) et la fenêtre de date (DATE_START → DATE_END).

Étape 2 : Trouver des posts Instagram via la recherche Google

Nous utilisons la recherche Google pour trouver des posts Instagram pertinents qui correspondent à nos critères dans une plage de dates spécifique.

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

Cette étape utilise la recherche Google pour trouver des posts. Le script :

Construit une requête comme site:instagram.com/p/ “{KEYWORD}” after: DATE_START before: DATE_END et pagine à travers les résultats Google.
Utilise des patterns regex pour extraire les URL de posts Instagram du HTML, les normalise (www.instagram.com vs instagram.com) et supprime les doublons.
S'arrête lorsqu'il a collecté NUM_POSTS URL uniques ou lorsqu'il atteint le nombre maximum de pages de résultats Google.

Étape 3 : Envoyer les URL de posts Instagram à l'API pour le 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()

Cette étape lance la tâche de scraping réelle :

Elle envoie toutes les URL Instagram collectées au jeu de données Instagram en une seule requête batch.
L'API renvoie un snapshot_id qui identifie cette tâche de scraping et est utilisé à l'étape suivante pour récupérer les résultats une fois le traitement terminé.

Étape 3 : Interroger les résultats et sauvegarder les données

1snapshot_url = f"api_snapshot_endpoint_url/{snapshot_id}"
2headers = {"Authorization": f"Bearer {API_TOKEN}"}
3
4start_time = time.time()
5max_wait_seconds = 15 * 60
6
7items = []
8while True:
9    elapsed = time.time() - start_time
10    if elapsed > max_wait_seconds:
11        exit()
12
13    try:
14        response = requests.get(snapshot_url, headers=headers)
15
16        if response.status_code not in [200, 202]:
17            time.sleep(10)
18            continue
19
20        if response.status_code == 202:
21            time.sleep(10)
22            continue
23
24        try:
25            data = response.json()
26            status = data.get("status")
27
28            if status in ["ready", "done", "complete"]:
29                download_url = data.get("download_url")
30                if download_url:
31                    download_response = requests.get(download_url)
32
33                    for line in download_response.text.strip().split('\n'):
34                        if line.strip():
35                            try:
36                                items.append(json.loads(line))
37                            except json.JSONDecodeError:
38                                pass
39
40                if items:
41                    break
42
43            items = data.get("items", [])
44            if items:
45                break
46
47            download_response = requests.get(
48                f"api_download_endpoint/{snapshot_id}/download",
49                headers=headers
50            )
51
52            for line in download_response.text.strip().split('\n'):
53                if line.strip():
54                    try:
55                        items.append(json.loads(line))
56                    except:
57                        pass
58
59            if items:
60                break
61            else:
62                exit()
63
64            elif status == "failed":
65                exit()
66
67        except json.JSONDecodeError:
68            for line in response.text.strip().split('\n'):
69                if line.strip():
70                    try:
71                        items.append(json.loads(line))
72                    except:
73                        pass
74
75            if items:
76                break
77
78        time.sleep(10)
79
80    except Exception as e:
81        time.sleep(10)
82
83if not items:
84    exit()
85
86csv_data = []
87
88for item in items:
89    try:
90        likes = int(item.get('likes', 0))
91    except (ValueError, TypeError):
92        likes = 0
93
94    try:
95        num_comments = int(item.get('num_comments', 0))
96    except (ValueError, TypeError):
97        num_comments = 0
98
99    hashtags = item.get('hashtags', [])
100    hashtags_str = ', '.join(hashtags) if isinstance(hashtags, list) else str(hashtags)
101
102    photos = item.get('photos', [])
103    photos_str = ', '.join(photos) if isinstance(photos, list) else str(photos)
104
105    videos = item.get('videos', [])
106    videos_str = ', '.join(videos) if isinstance(videos, list) else str(videos)
107
108    csv_data.append({
109        'user_posted': item.get('user_posted', 'N/A'),
110        'description': item.get('description', 'N/A'),
111        'date_posted': item.get('date_posted', 'N/A'),
112        'likes': likes,
113        'num_comments': num_comments,
114        'hashtags': hashtags_str,
115        'location': item.get('location', 'N/A'),
116        'photos': photos_str,
117        'videos': videos_str
118    })
119
120df = pd.DataFrame(csv_data)
121output_filename = f'instagram_{KEYWORD.replace(" ", "_").lower()}_posts.csv'
122df.to_csv(output_filename, index=False, encoding='utf-8-sig')

Scraper de commentaires Instagram (Python)

Étape 1 : Configuration

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"

Cette étape :

Importe les bibliothèques pour la gestion des URL, les expressions régulières, les requêtes HTTP et pandas.
Définissez votre ID de jeu de données de commentaires et votre API_TOKEN.
Configure le proxy à utiliser et définit les paramètres de recherche : mot-clé, le nombre de posts dont extraire les commentaires, et la fenêtre de date.

Étape 2 : Trouver des posts Instagram via la recherche 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

Ici vous :

Utilisez la recherche Google avec la requête site:instagram.com/p/ et vos filtres de mot-clé et de date pour trouver des posts pertinents.
Extrayez et normalisez les URL des posts Instagram avec regex, dédupliquez-les, et arrêtez-vous une fois que vous avez NUM_POSTS posts.
Stockez la liste finale dans instagram_urls, qui alimentera le scraper de commentaires.

Étape 3 : Soumettre les URL de post à l'API du scraper de commentaires

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

Cette étape :

Envoie toutes les URL Instagram au jeu de données de commentaires Instagram en un seul batch.
Chaque URL est enveloppée comme {“url”: …} pour que l'API sache de quel post extraire les commentaires.
L'API renvoie un snapshot_id qui identifie cette tâche de scraping de commentaires.

Étape 4 : Interroger les résultats et sauvegarder les données de commentaires

Nous vérifions continuellement si le scraping est terminé, puis traitons et sauvegardons les données des commentaires.

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

Cette section interroge l'API toutes les 10 secondes jusqu'à ce que le scraping soit terminé. Une fois prête, elle récupère toutes les données de commentaires, en extrayant les informations clés comme le nom d'utilisateur du commentateur, le texte du commentaire, les likes, les réponses, les hashtags utilisés et les utilisateurs tagués. Les données sont structurées dans un DataFrame pandas et sauvegardées sous forme de fichier CSV.

Découvrez davantage de nos benchmarks et analyses basées sur les données dans la recherche Google.

Ajouter comme source préférée

Comment Instagram détecte les scrapers (pourquoi les scripts Python basiques échouent)

Les scripts Python simples utilisant requests échouent immédiatement car ils ne reproduisent pas le comportement d'un vrai navigateur et dépendent d'une seule IP qui est bloquée en quelques minutes. La plateforme peut détecter les scrapers web Instagram instantanément via plusieurs couches de défenses :

Pas d'exécution de JavaScript : Instagram charge la page de manière dynamique, et les scripts Python ne peuvent pas exécuter JavaScript, donc les pages apparaissent vides. Cela révèle instantanément un comportement non humain.
Limitation du taux : Les utilisateurs humains ne font pas 50 requêtes par seconde. Les scrapers basiques réessaient avec une synchronisation prévisible, et Instagram bloque cela immédiatement.
Réputation IP : Instagram maintient des scores de confiance IP en temps réel, les IP de datacenter et la duplication d'IP. N'utilisez pas de proxies gratuits ; ceux-ci sont bloqués après quelques requêtes.

Nous avons utilisé une API de web scraping qui gère la simulation de navigateur, la rotation d'IP, JavaScript, les limites de taux et la résolution de captchas.

Proxies, limites de taux & exécution de votre scraper Instagram à grande échelle

Instagram bannira tout script qui réutilise la même IP de manière répétée. Pour scraper Instagram à grande échelle, vous devez utiliser des proxies résidentiels rotatifs, respecter les limites de taux, introduire des délais et éviter les requêtes directes vers Instagram. Voici comment nous avons utilisé les proxies lors du scraping des données d'Instagram :

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

À grande échelle, Instagram effectue des vérifications de vitesse (trop de requêtes trop rapidement) et des vérifications de concurrence (trop de requêtes simultanées). Notre tutoriel évite cela en :

intercalant une pause entre les pages de recherche Google (time.sleep(2))
interrogeant les API toutes les 10 secondes,
ne frappant jamais Instagram directement.

Scrapers Instagram utilisés dans le benchmark

Notre benchmark a testé les solutions d'API de scraping Instagram dédiées listées ci-dessous. Pour en savoir plus, consultez la méthodologie du benchmark pour les API de web scraping.

Type de page	Apify	Bright Data	Oxylabs	Smartproxy	Zyte
Post Instagram	apify/instagram-scraper	Instagram – Posts-collect by URL	❌	Social Media Scraping API – instagram_grap hql_post	❌
Profil Instagram	apify/instagram-profile-scraper	Instagram – Profiles – collect by URL	❌	Social Media Scraping API – instagram_grap hql_post	❌

Voyez quelles grandes entreprises d'infrastructure web proposent des scrapers spécifiques pour les pages Instagram :

Fournisseur	Post Instagram	Profil Instagram
Bright Data	✅	✅
Apify	✅	✅
Decodo	✅	✅
NetNut	❌	❌
Oxylabs	❌	❌
Zyte	❌	❌

Qu'est-ce que le scraping Instagram ?

Le scraping Instagram désigne l'utilisation de logiciels automatisés, tels que des bots ou des scripts, pour collecter des données publiques à partir des pages Instagram, y compris les posts, les hashtags et les commentaires.

Plutôt que de demander à un humain de visiter manuellement un profil pour copier la bio et la coller dans Excel, un script automatise ce processus des milliers de fois, organisant les données dans un format structuré comme CSV ou JSON pour analyse.

FAQ

Le scraping des données publiquement disponibles sur Instagram est autorisé tant que vous respectez les conditions d'utilisation de la plateforme et les lois applicables pour l'analyse concurrentielle, la veille de marque et l'analyse des sentiments. Cependant, vous devez toujours :

* Suivre les conditions d'utilisation d'Instagram
* Éviter de collecter des données personnelles qui ne sont pas destinées à être publiques
* Utiliser un outil de scraping Instagram conforme aux réglementations régionales

Vous pouvez scraper les posts, les profils publics et les données de commentaires. Cela inclut les noms d'utilisateur Instagram, le nombre de followers, le nombre de posts, les métriques d'engagement, les détails des posts (likes, hashtags, médias) et le texte des commentaires avec les métadonnées de base.

Oui. Instagram bloque le scraping direct, c'est pourquoi notre tutoriel évite de contacter directement Instagram et utilise une API de scraping qui gère le blocage, les limites de taux et le fingerprinting à notre place.

Les endpoints de l'API d'Instagram, comme l'Instagram Graph API, ne fournissent pas les données publiques de profil, de post et de commentaires que nous scrapons dans ce tutoriel. Elle fonctionne pour votre propre compte professionnel et nécessite des autorisations et une revue d'application, donc nous appuyons sur des API de scraping à la place.

Citez ce benchmark

Choisissez le format qui correspond à votre lieu de publication. Coller la version avec lien dans votre CMS préserve le lien retour.

Gulbahar Karatas (2026) - "Meilleurs scrapers Instagram pour extraire les données d'Instagram". Publié en ligne sur AIMultiple.com. Consulté le 23 Juillet 2026, à : https://aimultiple.com/instagram-scraping [Ressource en ligne]

Karatas, G. (2026, 23 Juillet). Meilleurs scrapers Instagram pour extraire les données d'Instagram. AIMultiple. https://aimultiple.com/instagram-scraping

@misc{karatas2026,
  author = {Karatas, Gulbahar},
  title  = {{Meilleurs scrapers Instagram pour extraire les données d'Instagram}},
  year   = {2026},
  month  = jul,
  howpublished    = {\url{https://aimultiple.com/instagram-scraping}},
  note   = {AIMultiple. Consulté le 23 Juillet 2026}
}

Gulbahar Karatas

Analyste sectorielle

Suivre

Gülbahar est une analyste sectorielle chez AIMultiple, spécialisée dans la collecte de données web, les applications des données web et la sécurité des applications.

Voir le profil complet