Benchmark

I migliori scraper LinkedIn

con

aggiornato il 2 set. 2026

Abbiamo confrontato i migliori strumenti di scraping LinkedIn usando 9.000 richieste su post, profili e offerte di lavoro. Questa guida copre due aree principali:

Confronto dei migliori scraper di dati LinkedIn
Tutorial Python per estrarre post, profili, aziende e offerte di lavoro da LinkedIn.

Fornitore

Focus

Bright Data

Soluzione API dedicata su larga scala e a basso costo

Apify

Gamma leader di mercato di API di scraping (approccio guidato dalla community)

Linked Helper

App desktop per utenti individuali

Confronto delle API degli scraper LinkedIn

Scraper LinkedIn	Tipo	Scopo	Prezzo iniziale/mese	Prova gratuita
Bright Data	Basato su proxy	Piattaforma di raccolta dati	$1,5 / 1K richieste	Gratuiti 5k record al mese
Apify	Basato su cookie Basato su proxy	Piattaforma di raccolta dati	$30	3 giorni
Nimbleway	Basato su proxy	Piattaforma di raccolta dati	$150	7 giorni
Dripify	Basato su proxy	Piattaforma di automazione LinkedIn	$39	7 giorni
Linked Helper	Basato su proxy	Piattaforma di automazione LinkedIn	$15	14 giorni
PhantomBuster	Basato su cookie	Piattaforma di automazione LinkedIn	69€	14 giorni
Snov.io	Estensione browser	Piattaforma di automazione LinkedIn	$39	50 crediti, 100 destinatari email
FindThatLead	Estensione browser	Piattaforma di automazione LinkedIn	49€	50 crediti

Risultati del benchmark di scraping LinkedIn

Questo grafico confronta i tassi di successo giornalieri delle API degli scraper LinkedIn sulla base di test dal vivo condotti ogni 15 minuti:

Scraper LinkedIn basati su API e proxy

Gli scraper LinkedIn basati su proxy utilizzano la propria infrastruttura proxy, inclusi indirizzi IP e server, per estrarre dati da LinkedIn su larga scala. Queste API inviano richieste attraverso una rete proxy gestita.

Questo è l'approccio giusto per lo scraping LinkedIn ad alto volume e affidabile perché:

Veloce: Poiché lo scraper si basa su più profili durante l'estrazione dei dati, può effettuare lo scraping più rapidamente
Affidabile: Se il sito web di destinazione blocca un profilo o un indirizzo IP, il fornitore passa a un altro per continuare le operazioni.
Sicuro: La persona che commissiona lo scraping non deve usare il proprio account, quindi non c'è il rischio che il tuo profilo venga bloccato.

Bright Data

Bright Data fornisce un'API dedicata per LinkedIn Web Scraper progettata per l'estrazione strutturata di dati da pagine LinkedIn pubbliche. La suite di API include le API per profili, le API per i post e le API per le aziende, ognuna ottimizzata per accuratezza e conformità. La piattaforma offre anche dataset LinkedIn personalizzati per specifici casi d'uso di LinkedIn.

Funzionalità:

Ricerca: Puoi ottenere dati da LinkedIn utilizzando una parola chiave specifica, come nome e cognome, filtri per data o sede di lavoro.
Scraping in tempo reale: Consente agli utenti di ottenere le informazioni più aggiornate disponibili su LinkedIn.
Supporto proxy integrato: Le API di LinkedIn includono il supporto proxy integrato.

Apify

Apify fornisce una gamma di Actor preconfigurati pensati per il web scraping su LinkedIn. I più popolari strumenti di scraping LinkedIn includono Job Scraper, Sales Navigator Scraper, Company Scraper, Profile Scraper, Post Scraper e Ads Scraper.

Funzionalità:

Actors personalizzabili (web scraper preconfigurati): Un marketplace di scraper LinkedIn creati da sviluppatori della community, ognuno adattabile a specifiche esigenze di scraping.
Automazione: Collega più Actors oppure integrali con strumenti esterni tramite APIs. Ogni Actor supporta connessioni al server MCP, consentendo agli utenti di gestire e comunicare con vari Actors di scraping.

Nimble

ScraperAPI è un'infrastruttura gestita di proxy e web scraping che include supporto dedicato per l'estrazione di dati da LinkedIn. Piuttosto che fornire un dataset LinkedIn predefinito, gestisce il processo di scraping, inclusi rotazione IP, risoluzione di CAPTCHA e gestione degli header.

Funzionalità

Supporto per richieste concorrenti: scala migliaia di richieste al minuto.
Modelli specifici per LinkedIn per profili, aziende e pagine di lavoro.

Gli strumenti basati su cookie utilizzano il cookie del tuo browser per estrarre dati. Sono utilizzati per la raccolta dati a basso volume e non critica, soprattutto se gli utenti sono clienti di questi strumenti di automazione e non devono sostenere costi aggiuntivi.

Questi strumenti di automazione devono “agire” per tuo conto per eseguire attività sui social network:

LinkedIn imposta un cookie di sessione quando accedi.
Passi quel cookie allo strumento.
Lo strumento utilizza il cookie per raccogliere dati ed eseguire azioni come richieste di collegamento.

Questo approccio è:

Lento: Poiché emula il comportamento umano, lo scraping è più lento rispetto agli strumenti che utilizzano la propria infrastruttura. Non sono adatti a compiti di estrazione dati su larga scala.
Rischioso: Se LinkedIn rileva attività sospette, potresti andare incontro a restrizioni temporanee o a un ban permanente da LinkedIn.

Phantombuster

PhantomBuster offre uno scraper di profili LinkedIn e uno scraper di aziende per estrarre dati pubblici dalla piattaforma.

Funzionalità:

Dati LinkedIn aggiornati: Puoi configurare lo strumento di scraping LinkedIn per avviarsi ripetutamente ed estrarre dati ogni giorno.
Estensione per Firefox e Chrome: L'estrattore di dati LinkedIn è disponibile come estensione.
Basato su cloud: Viene eseguito sui server remoti, consentendo agli utenti di estrarre dati da LinkedIn senza utilizzare risorse locali.

Linked Helper

Linked Helper è una piattaforma di automazione LinkedIn basata su desktop che include anche funzionalità di scraping di LinkedIn. Lo strumento non richiede proxy per impostazione predefinita, ma consente agli utenti di configurare manualmente i proxy per ogni account LinkedIn.

Funzionalità:

Collegamento automatico dei profili: Visita i profili LinkedIn e invia messaggi personalizzati.
Estrazione dati: Offre un estrattore di dati per raccogliere dati dai profili LinkedIn e da Sales Navigator. Puoi ottenere i dati raccolti in formato CSV.
CRM integrato: Tutti i contatti sono archiviati in un CRM integrato all'interno di Linked Helper. Se utilizzi un CRM esterno, puoi inviare i dati a questi CRM.

Dripify

Dripify è uno strumento di automazione LinkedIn che aiuta i professionisti delle vendite ad automatizzare le attività sulla piattaforma. Forniscono uno scraper LinkedIn che consente agli utenti di accedere ai dati dei lead LinkedIn e di esportarli in un file CSV.

Funzionalità:

Indirizzo IP locale: Fornisce un indirizzo IP univoco dalla regione locale dell'utente, consentendo di accedere ai siti web come se ci si trovasse in aree geografiche diverse.
Simulazione del comportamento umano: Imita le azioni di un utente reale quando interagisce con LinkedIn. Aggiunge ritardi casuali tra le richieste e simula i clic dell'utente su link o pulsanti per farti apparire più simile a un utente autentico.

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

Automatizza un processo

Strumenti per trovare email ed estensioni

Questi vengono eseguiti all'interno del browser e mirano alla cattura di email e lead piuttosto che allo scraping su larga scala. Sono adatti a compiti piccoli e si rompono se il browser o il layout della pagina cambiano.

Snov.io

Snov.io è una piattaforma di sales engagement basata su estensione Chrome che fornisce soluzioni lungo l'intero ciclo di outreach. Il LinkedIn Email Finder di Snov.io estrae meccanicamente gli indirizzi email da un profilo LinkedIn o da una pagina di risultati di ricerca.

È fondamentale notare che Snov.io non è uno strumento di scraping LinkedIn dedicato; può estrarre indirizzi email. Puoi raccogliere email in blocco dalle pagine di ricerca persone di LinkedIn e dai risultati di ricerca di LinkedIn Sales Navigator.

I fornitori di automazione LinkedIn come PhantomBuster, Linked Helper e Dripify forniscono script predefiniti. Se la tua organizzazione richiede l'automazione di LinkedIn ma non dispone di una soluzione email, Snov.io potrebbe essere sufficiente. Il piano gratuito (50 crediti) è generoso.

Funzionalità:

Email Finder: Scopre indirizzi email in base a nome, azienda e dominio. Snov.io offre anche estensioni Chrome per generare lead (“click-and-collect”). Puoi estrarre email da LinkedIn e dai motori di ricerca Google.
Email Verifier: offre uno strumento di verifica email a 7 livelli, che verifica gli indirizzi con un'accuratezza del 98%. Tieni presente che la verifica consuma crediti, un credito per ogni verifica.

findthatlead

FindThatLead è una piattaforma cloud B2B per la generazione di lead e la verifica delle email. La piattaforma offre un'estensione Chrome che consente agli utenti di estrarre indirizzi email da profili LinkedIn e siti web. Non è una soluzione gratuito e richiede crediti dal tuo account FindThatLead.

Funzionalità:

Email Finder & Verifier: Puoi ricevere email da LinkedIn e da altri siti web che includono informazioni aggiuntive, come nome, indirizzo email e titolo professionale.
Email Sender & Drip Campaigns: Email Sender è uno strumento gratuito che ti consente di personalizzare i messaggi per ogni destinatario.

Prezzi:

Prezzo iniziale (mese): $49 (2000 crediti email)
Prova: 50 crediti email, inclusa l'estensione Chrome.

Evaboot

Evaboot è uno strumento di automazione basato su Chrome che esporta i dati dei lead direttamente da LinkedIn Sales Navigator. Invece di effettuare lo scraping tramite proxy, sfrutta la tua sessione di Sales Navigator per raccogliere e pulire i dati visibili dei lead. Tuttavia non è adatto allo scraping su larga scala o alla pianificazione automatica.

Funzionalità

Integrazione nativa con Sales Navigator: Estrae nomi, titoli di lavoro, nomi di aziende, settori e località dai risultati di ricerca di Sales Navigator.
Pulizia dei dati: Rimuove automaticamente duplicati, link non funzionanti e profili incompleti.

Prezzi:

Parte da $49/mese con una prova gratuito di 7 giorni.
Offre opzioni pay-per-export per piccoli team.

Tutorial Python: fare scraping su LinkedIn con una API scraper

Ogni esempio segue lo stesso schema: invii l'URL LinkedIn di destinazione all'API LinkedIn Scraper di Bright Data e ricevi in cambio dati strutturati (JSON o CSV).

Prerequisiti

Per iniziare sono necessari alcuni passaggi di configurazione:

Python 3.x è installato sul tuo sistema
libreria requests (pip install requests)
Bright Data account con il dataset LinkedIn abilitato

Come fare scraping dei post di LinkedIn

Passaggio 1: Avvia il lavoro di scraping

Invia l'URL di un post LinkedIn all'endpoint API di Bright Data per avviare il processo di scraping. Lo stesso schema si applica più avanti in questa guida allo scraping di profili, offerte di lavoro e aziende.

1import requests
2import json
3import os
4
5# Hidden secrets read from environment variables
6url = os.environ.get("BRIGHTDATA_TRIGGER_ENDPOINT", "BRIGHT_DATA_TRIGGER_ENDPOINT")
7API_KEY = os.environ.get("BRIGHTDATA_API_KEY", "YOUR_API_KEY_HERE")
8DATASET_ID = os.environ.get("BRIGHTDATA_DATASET_ID", "YOUR_DATASET_ID")
9
10headers = {
11    "Authorization": "Bearer " + API_KEY,
12    "Content-Type": "application/json",
13}
14
15params = {
16    "dataset_id": DATASET_ID,
17    "include_errors": "true",
18}
19
20linkedin_urls = [
21    "https://www.linkedin.com/posts/example-post-1",
22    "https://www.linkedin.com_posts/example-post-2",
23    "https://www.linkedin.com/posts/example-post-3",
24]
25
26data = [{"url": url} for url in linkedin_urls]
27
28response = requests.post(url, headers=headers, params=params, json=data)
29
30try:
31    result = response.json()
32    print(json.dumps(result, indent=4))
33except json.JSONDecodeError:
34    print("Could not get valid JSON response:", response.text)

Questo script Python invia una richiesta POST all'API LinkedIn Scraper di Bright Data per avviare il lavoro di scraping. Ci autentichiamo utilizzando la nostra chiave API e specifichiamo l'ID del dataset. “

Ogni URL di post LinkedIn viene passato come oggetto JSON e inviato all'API, che gestisce in background la rotazione dei proxy, la risoluzione dei CAPTCHA e la convalida delle richieste. L'API restituisce un ID snapshot univoco, che userai in seguito per recuperare i dati LinkedIn estratti.

Passaggio 2: Recupera i dati estratti

Usa l'ID snapshot restituito dal lavoro di avvio. I segreti e gli endpoint vengono letti dalle variabili d'ambiente.

1# retrieve_snapshot.py
2import requests
3import time
4import json
5import os
6
7snapshot_id = os.environ.get("BRIGHTDATA_SNAPSHOT_ID", "YOUR_SNAPSHOT_ID")
8url = f"{os.environ.get('BRIGHTDATA_SNAPSHOT_ENDPOINT', 'BRIGHT_DATA_SNAPSHOT_ENDPOINT')}/{snapshot_id}"
9headers = {
10    "Authorization": "Bearer " + os.environ.get("BRIGHTDATA_API_KEY", "YOUR_API_KEY_HERE")
11}
12
13while True:
14    response = requests.get(url, headers=headers)
15    raw_text = response.text.strip()
16
17    try:
18        data = json.loads(raw_text)
19    except json.JSONDecodeError:
20        print("Multiple JSON objects detected. Processing line by line...")
21        for line in raw_text.splitlines():
22            try:
23                item = json.loads(line)
24                post_text = item.get("post_text", "[Not available]")
25                num_likes = item.get("num_likes", "[Not available]")
26                num_comments = item.get("num_comments", "[Not available]")
27
28                print("Post Text:", post_text)
29                print("Likes:", num_likes)
30                print("Comments:", num_comments)
31                print("-" * 40)
32            except Exception as e:
33                print("Skipped invalid line:", e)
34        break
35
36    status = data.get("status")
37
38    if status == "building":
39        print("Data is being processed... Waiting.")
40        time.sleep(5)
41        continue
42    elif status == "done":
43        print("Data is ready!")
44        for item in data.get("items", []):
45            print("Post Text:", item.get("post_text", "[Not available]"))
46            print("Likes:", item.get("num_likes", "[Not available]"))
47            print("Comments:", item.get("num_comments", "[Not available]"))
48            print("-" * 40)
49        break
50    else:
51        print("Unexpected status:", status)
52        break

Questo script recupera i dati LinkedIn estratti utilizzando l'ID snapshot restituito dal lavoro di avvio. Interroga l'API di Bright Data per verificare lo stato del lavoro fino al completamento del processo di scraping.

La risposta dell'API può essere un singolo oggetto JSON (con stato) oppure più oggetti JSON in formato NDJSON. Per le risposte NDJSON, analizza ogni riga ed estrai i record dei post; per le risposte JSON singole, controlla il campo stato: se è "building", attendi qualche secondo e riprova finché non diventa "done". Una volta completato, puoi estrarre e visualizzare i dati strutturati dei post LinkedIn.

Come fare scraping delle offerte di lavoro LinkedIn con Python

Scopri come estrarre le offerte di lavoro LinkedIn utilizzando Python e l'API LinkedIn Scraper. Puoi estrarre dati strutturati sulle offerte di lavoro, inclusi titoli, aziende, sedi, date di pubblicazione e descrizioni delle posizioni, direttamente dagli URL delle offerte LinkedIn.

Questo approccio è ideale per creare bacheche di lavoro, analisi di recruiting o strumenti di ricerca sugli stipendi.

Passaggio 1: Avvia il lavoro di scraping

Lo script seguente invia una richiesta POST all'API di Bright Data per avviare un'attività di scraping di offerte di lavoro LinkedIn. Ogni URL di offerta viene passato al dataset LinkedIn_jobs, che gestisce automaticamente la rotazione dei proxy e la protezione anti-bot di LinkedIn.

1# trigger_jobs.py
2import requests
3import json
4import os
5
6# Hidden secrets read from environment variables
7url = os.environ.get("BRIGHTDATA_TRIGGER_ENDPOINT", "BRIGHT_DATA_TRIGGER_ENDPOINT")
8API_KEY = os.environ.get("BRIGHTDATA_API_KEY", "YOUR_API_KEY_HERE")
9DATASET_ID = os.environ.get("BRIGHTDATA_DATASET_ID", "YOUR_DATASET_ID")
10
11headers = {
12    "Authorization": "Bearer " + API_KEY,
13    "Content-Type": "application/json",
14}
15
16params = {
17    "dataset_id": DATASET_ID,
18    "include_errors": "true",
19    "type": "discover_new",
20    "discover_by": "keyword",
21}
22
23data = [
24    {
25        "location": "New York",
26        "keyword": "software engineer",
27        "country": "US",
28        "job_type": "Full-time",
29        "remote": "Hybrid",
30        "company": "",
31        "location_radius": ""
32    },
33    {
34        "location": "New York",
35        "keyword": "data analyst",
36        "country": "US",
37        "job_type": "Full-time",
38        "remote": "Remote",
39        "company": "",
40        "location_radius": ""
41    },
42]
43
44response = requests.post(url, headers=headers, params=params, json=data)
45result = response.json()
46print(f"Snapshot ID: {result['snapshot_id']}")

Questo script avvia il processo di scraping delle offerte di lavoro LinkedIn inviando una richiesta POST all'API di Bright Data. Ci autentichiamo utilizzando la nostra chiave API e specifichiamo l'ID del dataset LinkedIn Jobs.

I criteri di ricerca definiscono quali ruoli estrarre. Ad esempio, ingegneri software in posizioni ibride o analisti di dati in ruoli da remoto nell'area di New York.

L'API restituisce un ID snapshot che può essere utilizzato per recuperare i risultati una volta completato lo scraping. Poiché tutte le attività di scraping vengono eseguite sull'infrastruttura cloud di Bright Data, il processo continua anche se chiudi lo script Python.

Passaggio 2: Attendi e recupera i risultati

Attendi 5-10 minuti per il completamento dello scraping, quindi usa questo script per recuperare i dati:

1# retrieve_jobs.py
2import requests
3import json
4import os
5
6snapshot_id = os.environ.get("BRIGHTDATA_SNAPSHOT_ID", "YOUR_SNAPSHOT_ID")
7
8url = f"{os.environ.get('BRIGHTDATA_SNAPSHOT_ENDPOINT', 'BRIGHT_DATA_SNAPSHOT_ENDPOINT')}/{snapshot_id}?format=json"
9headers = {
10    "Authorization": "Bearer " + os.environ.get("BRIGHTDATA_API_KEY", "YOUR_API_KEY_HERE")
11}
12
13response = requests.get(url, headers=headers)
14
15if response.status_code == 200:
16    lines = response.text.strip().splitlines()
17    first_line = json.loads(lines[0])
18
19    print(f"✓ Total jobs found: {len(first_line)}\n")
20    print("First 10 job listings:\n")
21    print("="*80)
22
23    for idx, job in enumerate(first_line[:10], 1):
24        if isinstance(job, dict):
25            print(f"\n[{idx}]")
26            print(f" Position: {job.get('job_title', 'N/A')}")
27            print(f" Company:  {job.get('company_name', 'N/A')}")
28            print(f" Location: {job.get('job_location', 'N/A')}")
29            print(f" Job Type: {job.get('job_employment_type', 'N/A')}")
30            print(f" Seniority: {job.get('job_seniority_level', 'N/A')}")
31            print(f" Link:     {job.get('url', 'N/A')}")
32            print("-"*80)
33
34    print(f"\n✓ First 10 displayed (total {len(first_line)} records available)")
35else:
36    print(f"Error: {response.status_code}")

Una volta completato il processo di scraping delle offerte di lavoro LinkedIn, recuperiamo i dati strutturati utilizzando l'ID snapshot restituito dal lavoro di avvio. La risposta è in genere in formato NDJSON, dove ogni riga rappresenta un'offerta di lavoro separata.

Analizziamo ogni voce ed estraiamo le informazioni chiave, tra cui titolo di lavoro, nome dell'azienda, sede, tipo di impiego e data di pubblicazione. Per le risposte JSON singole, lo script controlla il campo stato e attende finché non diventa "done", assicurando che tutti i dati delle offerte di lavoro LinkedIn siano completamente elaborati. Lo script utilizza inoltre .get() con valori predefiniti per gestire in modo elegante eventuali campi mancanti.

Come fare scraping delle pagine profilo LinkedIn

Potresti voler estrarre profili LinkedIn per diversi casi d'uso legittimi. Ad esempio, analizzare i dipendenti di una specifica azienda, arricchire un database di recruiting o elaborare un elenco di URL di profili LinkedIn raccolti durante un evento di networking.

Passaggio 1: Avvia il lavoro di scraping

1# trigger_profiles.py
2import requests
3import json
4import os
5
6# Hidden secrets read from environment variables
7api_url = os.environ.get("BRIGHTDATA_TRIGGER_ENDPOINT", "BRIGHT_DATA_TRIGGER_ENDPOINT")
8API_KEY = os.environ.get("BRIGHTDATA_API_KEY", "YOUR_API_KEY_HERE")
9DATASET_ID = os.environ.get("BRIGHTDATA_DATASET_ID", "YOUR_DATASET_ID")
10
11headers = {
12    "Authorization": "Bearer " + API_KEY,
13    "Content-Type": "application/json",
14}
15
16params = {
17    "dataset_id": DATASET_ID,  # Get this from your Bright Data dashboard
18    "include_errors": "true",
19}
20
21profile_urls = [
22    "https://www.linkedin.com/in/example-profile-1/",
23    "https://www.linkedin.com/in/example-profile-2/",
24    "https://www.linkedin.com/in/example-profile-3/"
25]
26
27data = [{"url": profile_url} for profile_url in profile_urls]
28
29response = requests.post(api_url, headers=headers, params=params, json=data)
30
31try:
32    result = response.json()
33    print(json.dumps(result, indent=4))
34except json.JSONDecodeError:
35    print("Could not get valid JSON response:")
36    print(response.text)

Questo script invia una richiesta POST all'API di Bright Data per avviare lo scraping dei profili LinkedIn specificati. Ci autentichiamo con il nostro token API e forniamo l'ID del dataset (disponibile nella dashboard di Bright Data sotto il dataset LinkedIn People).

Gli URL dei profili vengono formattati come oggetti dizionario e inviati all'API, che li elabora e restituisce un ID snapshot per recuperare i dati in seguito. Il blocco try-except gestisce la risposta e mostra l'ID snapshot o eventuali errori.

Passaggio 2: Recupera i dati estratti del profilo LinkedIn

Usa l'ID snapshot restituito nel Passaggio 1 per interrogare l'API LinkedIn Scraper finché il lavoro non termina, quindi analizza la risposta.

1import requests
2import time
3import json
4
5snapshot_id = "YOUR_SNAPSHOT_ID"
6url = f"BRIGHT_DATA_SNAPSHOT_ENDPOINT/{snapshot_id}"
7
8headers = {
9    "Authorization": "Bearer YOUR_API_KEY_HERE"
10}
11
12while True:
13    response = requests.get(url, headers=headers)
14    raw_text = response.text.strip()
15
16    print(f"Status Code: {response.status_code}\n")
17
18    if response.status_code != 200:
19        print("Error:", raw_text)
20        break
21
22    try:
23        data = json.loads(raw_text)
24    except json.JSONDecodeError:
25        print("Processing JSONL format (multiple JSON objects)...\n")
26
27        for line in raw_text.splitlines():
28            line = line.strip()
29            if not line:
30                continue
31
32            try:
33                item = json.loads(line)
34
35                profile_id = item.get("id", "[Not available]")
36                name = item.get("name", "[Not available]")
37                country_code = item.get("country_code", "[Not available]")
38                about = item.get("about", "[Not available]")
39                experience = item.get("experience", []) or []
40                current_company = item.get("current_company", {}) or {}
41
42                print("=" * 60)
43                print(f"ID: {profile_id}")
44                print(f"Name: {name}")
45                print(f"Country Code: {country_code}")
46
47                if about and about != "[Not available]":
48                    print(f"About: {about[:150]}..." if len(about) > 150 else f"About: {about}")
49                else:
50                    print("About: [Not available]")
51
52                if current_company:
53                    company_name = current_company.get("name", "[Not available]")
54                    company_title = current_company.get("title", "[Not available]")
55                    print(f"Current Company: {company_name}")
56                    if company_title != "[Not available]":
57                        print(f" Title: {company_title}")
58
59                print(f"Total Experience: {len(experience)} positions")
60
61                if experience and len(experience) > 0:
62                    print("\nExperience:")
63                    for idx, exp in enumerate(experience[:3], 1):
64                        exp_title = exp.get("title", "N/A")
65                        exp_company = exp.get("company_name", "N/A")
66                        print(f" {idx}. {exp_title} at {exp_company}")
67
68            except json.JSONDecodeError as e:
69                print(f"JSON parse error: {e}")
70            except Exception as e:
71                print(f"Error processing line: {e}")
72
73        print("\n" + "=" * 60)
74        print("All profiles processed successfully!")
75        break
76
77    status = data.get("status")
78
79    if status in ["building", "running"]:
80        print(f"Status: {status} - Waiting 5 seconds...")
81        time.sleep(5)
82        continue
83
84    elif status in ["ready", "done"]:
85        print("Data is ready! Processing items...\n")
86
87        for item in data.get("items", []):
88            profile_id = item.get("id", "[Not available]")
89            name = item.get("name", "[Not available]")
90            country_code = item.get("country_code", "[Not available]")
91            about = item.get("about", "[Not available]")
92            experience = item.get("experience", []) or []
93            current_company = item.get("current_company", {}) or {}
94
95            print("=" * 60)
96            print(f"ID: {profile_id}")
97            print(f"Name: {name}")
98            print(f"Country Code: {country_code}")
99            print(f"About: {about[:100]}..." if about != "[Not available]" else "About: [Not available]")
100            print(f"Current Company: {current_company.get('name', '[Not available]')}")
101            print(f"Total Experience: {len(experience)} positions")
102
103        break
104
105    else:
106        print(f"Unexpected status: {status}")
107        break

L'API può restituire NDJSON (un oggetto JSON per riga) oppure un singolo oggetto JSON con un campo stato. Lo script gestisce entrambi i casi: controlla lo stato ("building", "running", "ready", "done"), attende quando necessario e stampa i dati strutturati del profilo LinkedIn una volta disponibili.

Come fare scraping dei dati aziendali di LinkedIn

Puoi usare uno scraper di aziende LinkedIn per estrarre dati aziendali pubblici, inclusi nomi, settori, dimensioni, sedi e numero di dipendenti. Se non disponi degli URL delle aziende, puoi generarli utilizzando una query dell'API di Google Search come site:linkedin.com/company/ [industry or keyword].

Passaggio 1: Avvia il lavoro di scraping

1# trigger_companies.py
2import requests
3import json
4import os
5
6# Hidden secrets read from environment variables
7url = os.environ.get("BRIGHTDATA_TRIGGER_ENDPOINT", "BRIGHT_DATA_TRIGGER_ENDPOINT")
8API_KEY = os.environ.get("BRIGHTDATA_API_KEY", "YOUR_API_KEY_HERE")
9DATASET_ID = os.environ.get("BRIGHTDATA_DATASET_ID", "YOUR_DATASET_ID")
10
11headers = {
12    "Authorization": "Bearer " + API_KEY,
13    "Content-Type": "application/json",
14}
15
16params = {
17    "dataset_id": DATASET_ID,  # Get this from your Bright Data dashboard
18    "include_errors": "true",
19}
20
21company_urls = [
22    "https://www.linkedin.com/company/example-company-1",
23    "https://www.linkedin.com/company/example-company-2",
24    "https://www.linkedin.com/company/example-company-3",
25]
26
27data = [{"url": company_url} for company_url in company_urls]
28
29response = requests.post(url, headers=headers, params=params, json=data)
30
31print("Status Code:", response.status_code)
32print("\nResponse:")
33
34try:
35    result = response.json()
36    print(json.dumps(result, indent=4))
37except json.JSONDecodeError:
38    print("Could not get valid JSON response:")
39    print(response.text)

Ci autentichiamo utilizzando il nostro token API e includiamo l'ID del dataset dalla dashboard di Bright Data. Gli URL delle aziende LinkedIn vengono convertiti nel formato JSON richiesto e inviati all'API per l'elaborazione.

Una volta accettata la richiesta, l'API restituisce un ID snapshot che useremo in seguito per recuperare i dati aziendali estratti. Una gestione degli errori di base garantisce che lo script mostri l'ID snapshot o registri eventuali problemi di richiesta per il debug.

Passaggio 2: Recupera i dati estratti

Una volta avviato il lavoro di scraping, usa l'ID snapshot per verificare lo stato e recuperare i dati.

1# retrieve_companies.py
2import requests
3import time
4import json
5import os
6
7snapshot_id = os.environ.get("BRIGHTDATA_SNAPSHOT_ID", "YOUR_SNAPSHOT_ID")
8url = f"{os.environ.get('BRIGHTDATA_SNAPSHOT_ENDPOINT', 'BRIGHT_DATA_SNAPSHOT_ENDPOINT')}/{snapshot_id}"
9headers = {
10    "Authorization": "Bearer " + os.environ.get("BRIGHTDATA_API_KEY", "YOUR_API_KEY_HERE")
11}
12
13while True:
14    response = requests.get(url, headers=headers)
15    raw_text = response.text.strip()
16
17    print(f"Status Code: {response.status_code}\n")
18
19    if response.status_code != 200:
20        print("Error:", raw_text)
21        break
22
23    try:
24        data = json.loads(raw_text)
25    except json.JSONDecodeError:
26        print("Processing JSONL format (multiple JSON objects)...\n")
27
28        for line in raw_text.splitlines():
29            line = line.strip()
30            if not line:
31                continue
32
33            try:
34                item = json.loads(line)
35
36                company_id = item.get("id", "[Not available]")
37                name = item.get("name", "[Not available]")
38                website = item.get("website", "[Not available]")
39                country_code = item.get("country_code", "[Not available]")
40                company_size = item.get("company_size", "[Not available]")
41                employees_in_linkedin = item.get("employees_in_linkedin", "[Not available]")
42                followers = item.get("followers", "[Not available]")
43                about = item.get("about", "[Not available]")
44                specialties = item.get("specialties", "[Not available]")
45                organization_type = item.get("organization_type", "[Not available]")
46
47                print("=" * 60)
48                print(f"ID: {company_id}")
49                print(f"Name: {name}")
50                print(f"Website: {website}")
51                print(f"Country: {country_code}")
52                print(f"Company Size: {company_size}")
53                print(f"Employees on LinkedIn: {employees_in_linkedin}")
54                print(f"Followers: {followers}")
55                print(f"Organization Type: {organization_type}")
56                if specialties and specialties != "[Not available]":
57                    print(f"Specialties: {specialties}")
58                if about and about != "[Not available]":
59                    print(f"About: {about[:150]}..." if len(about) > 150 else f"About: {about}")
60
61            except json.JSONDecodeError as e:
62                print(f"⚠ JSON parse error: {e}")
63            except Exception as e:
64                print(f"⚠ Error processing line: {e}")
65
66        print("\n" + "=" * 60)
67        print("✓ All companies processed successfully!")
68        break
69
70    status = data.get("status")
71
72    if status in ["building", "running"]:
73        print(f"Status: {status} - Waiting 5 seconds...")
74        time.sleep(5)
75        continue
76    elif status in ["ready", "done"]:
77        print("Data is ready! Processing items...\n")
78        for item in data.get("items", []):
79            company_id = item.get("id", "[Not available]")
80            name = item.get("name", "[Not available]")
81            website = item.get("website", "[Not available]")
82            country_code = item.get("country_code", "[Not available]")
83            company_size = item.get("company_size", "[Not available]")
84            employees_in_linkedin = item.get("employees_in_linkedin", "[Not available]")
85            followers = item.get("followers", "[Not available]")
86            about = item.get("about", "[Not available]")
87            specialties = item.get("specialties", "[Not available]")
88            organization_type = item.get("organization_type", "[Not available]")
89
90            print("=" * 60)
91            print(f"ID: {company_id}")
92            print(f"Name: {name}")
93            print(f"Website: {website}")
94            print(f"Country: {country_code}")
95            print(f"Company Size: {company_size}")
96            print(f"Employees on LinkedIn: {employees_in_linkedin}")
97            print(f"Followers: {followers}")
98            print(f"Organization Type: {organization_type}")
99            print(f"About: {about[:100]}..." if about != "[Not available]" else "About: [Not available]")
100
101        break
102    else:
103        print(f"Unexpected status: {status}")
104        break

Questo script recupera i dati aziendali estratti utilizzando l'ID snapshot del passaggio precedente. Interroga continuamente l'API e supporta più formati di risposta.

Innanzitutto, convalida il codice di stato HTTP per rilevare eventuali errori. Quindi prova ad analizzare la risposta, che può arrivare in due formati: JSONL (oggetti JSON separati da newline) oppure un oggetto JSON standard con informazioni di stato.

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

Lo scraping di LinkedIn è legale nel 2026?

La legge IAB IA Accountability for Publishers Act ha inasprito le normative. Ora piattaforme come LinkedIn possono intraprendere azioni legali contro chiunque ignori le regole no-crawling nei file robots.txt quando raccoglie dati per l'addestramento dell'IA o per un uso su larga scala.

Lo scraping pubblico non è considerato "hacking", ma ora comporta seri rischi legali se viola le regole di robots.txt o viene utilizzato per profiling invasivo.

I Termini di servizio di LinkedIn vietano l'accesso automatizzato alla piattaforma senza autorizzazione.¹
Tuttavia, la raccolta di informazioni pubblicamente disponibili da pagine LinkedIn (non dietro accesso) può essere consentita in determinate giurisdizioni.

Metodologia di benchmark degli scraper LinkedIn

Il benchmark invia periodicamente richieste a profili LinkedIn e pagine aziendali predefiniti per misurare la coerenza e la latenza del recupero dei dati. Un totale di 100 URL di profili e 100 URL di aziende viene richiesto a intervalli fissi e i risultati vengono aggregati quotidianamente.

Le richieste vengono eseguite ogni 15 minuti con un timeout di 60 secondi per garantire un campionamento regolare riducendo al minimo il rate limiting da parte di LinkedIn.

Una richiesta è considerata riuscita se la risposta include campi specifici di LinkedIn come "linkedin_id", "headline", "company_name" o "industry". Il successo viene convalidato in due passaggi:

Prima scansionando questi identificatori,
E poi ricontrollando il contenuto formattato parzialmente se non viene trovata una corrispondenza diretta. Questo doppio processo riduce i falsi negativi causati da piccole modifiche al layout o alla formattazione.

Nel nostro benchmark abbiamo utilizzato le seguenti API dedicate, progettate esplicitamente per estrarre dati da LinkedIn. Per saperne di più, consulta la metodologia di benchmark delle API di scraping.

Tipo di pagina	Bright Data	Apify
Post LinkedIn	LinkedIn posts-collect by URL	supreme_coder/linkedin-post*
Profilo LinkedIn	LinkedIn people-collect by URL	dev_fusion/Linkedin-Profile-Scraper

* è elencato come riferimento, ma non è stato utilizzato nel nostro benchmark di scraping LinkedIn.

FAQ

Uno scraper LinkedIn è uno strumento o uno script che estrae automaticamente informazioni pubblicamente disponibili da profili LinkedIn, offerte di lavoro o pagine aziendali. Questi strumenti sono progettati per effettuare il crawling dei dati LinkedIn come nomi, titoli, nomi di aziende e sedi, in genere tramite API o script automatizzati.

Puoi estrarre dati pubblicamente visibili come nomi dei profili, nomi di aziende, titoli di lavoro, settori e testo dei post. Evita di raccogliere informazioni private o sensibili (ad es. email o numeri di telefono) e segui sempre i termini di servizio di LinkedIn e le linee guida etiche per il web scraping.

Cita questo benchmark

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

Sedat Dogan and Nazlı Şipi (2026) - "I migliori scraper LinkedIn". Pubblicato online su AIMultiple.com. Consultato il 2 Settembre 2026, da: https://aimultiple.com/linkedin-scrapers [Risorsa online]

Dogan, S., & Şipi, N. (2026, 2 Settembre). I migliori scraper LinkedIn. AIMultiple. https://aimultiple.com/linkedin-scrapers

@misc{dogan2026,
  author = {Dogan, Sedat and Şipi, Nazlı},
  title  = {{I migliori scraper LinkedIn}},
  year   = {2026},
  month  = sep,
  howpublished    = {\url{https://aimultiple.com/linkedin-scrapers}},
  note   = {AIMultiple. Consultato il 2 Settembre 2026}
}

Scarica tutti i dati

Risultati e timestamp di 4.0 mila punti dati. Scarica i dati di sintesi mostrati nei grafici e nelle tabelle di questo articolo come file ZIP contenente 3 file CSV e un README.

Ultimo aggiornamento: 17 Agosto 2026

Scarica

Vuoi i dati granulari che ci stanno dietro? Passa a Premium

Registro delle modifiche

18 aggiornamenti

20262 Set
Aggiunta una sezione "What data you can scrape from LinkedIn" con i campi per tipo di pagina.
2 Set
La metodologia del benchmark degli scraper LinkedIn è stata sostituita con un test su quattro provider su 1.000 URL di post.
10 Giu
Rimossa la voce Proxycurl dalla sezione degli scraper LinkedIn basati su proxy.
9 Feb
Aggiunta una sezione che confronta Apify e Bright Data all'introduzione.
202525 Nov
Aggiunto un grafico alla sezione "Risultati del benchmark delle API di scraping di LinkedIn".
24 Ott
Aggiunti esempi di codice Evaboot e Python all'articolo.
4 Ago
Aggiunto NetNut B2B Data Scraper API all'elenco degli scraper di LinkedIn.
24 Apr
Aggiornata la sezione 'I migliori strumenti di scraping di LinkedIn'.
2 Apr
Aggiunto Apify come prodotto nella sezione Prezzi dei migliori strumenti di scraping di LinkedIn.
27 Feb
Rimossa la sezione Metodologia di benchmarking.
17 Feb
Rimosso Zyte dall'elenco degli strumenti di scraping di LinkedIn.
9 Gen
Aggiunto Zyte all'elenco degli strumenti di scraping di LinkedIn.
2 Gen
Aggiunti tre casi d'uso aziendali dei dati LinkedIn all'articolo.
202412 Dic
Rimossa la sezione "I 6 migliori strumenti di scraping di LinkedIn".
10 Ott
Rimossa la sezione Metodologia di Benchmark.
10 Ott
Aggiunta una sezione Metodologia di Benchmark.
23 Set
Aggiornata la descrizione di Bright Data nella tabella riassuntiva.
23 Set
Ampliata la sezione metodologia con dettagli sugli scraper benchmark e i parametri di test.

Collegamenti di riferimento

User Agreement | LinkedIn

Sedat Dogan

CTO

Segui

Sedat è un leader tecnologico e della sicurezza informatica con 20 anni di esperienza nello sviluppo software, nelle infrastrutture di rete e nella cybersecurity. Sedat:
- Ha 20 anni di esperienza come hacker white-hat e guru dello sviluppo, con una vasta competenza nei linguaggi di programmazione e nelle architetture dei server.
- È consulente del consiglio di amministrazione presso una società di venture capital che investe in aziende tecnologiche in fase iniziale e presso Ödeal, una piattaforma di pagamento digitale regionale che serve 125.000 commercianti.
- Ha guidato l'infrastruttura tecnologica e la cybersecurity di sette elezioni nazionali ed è stato riconosciuto nella Hall of Fame della cybersecurity da leader tecnologici globali tra cui Twitter.

Visualizza il profilo completo

Ricercato da

Nazlı Şipi

Ricercatrice AI

Nazlı è un'analista di dati presso AIMultiple. Ha esperienza pregressa nell'analisi dei dati in diversi settori, dove ha lavorato alla trasformazione di dataset complessi in insight attuabili.

Visualizza il profilo completo