如何在不被封锁的情况下抓取 LinkedIn 数据

LinkedIn 每天都會攔截成千上萬次爬取請求。進入 2024–2025 年後，平台的反爬體系再次升級，防護強度已躋身業界最難突破的目標站點之一。此時的風險不僅僅是觸發簡單的訪問頻率限制——LinkedIn 已全面引入基於 AI 的行為分析、TLS 指紋校驗、瀏覽器特徵識別等多層檢測機制，即使你自認為規避得面面俱到，也很容易被判定為自動化行為。

本指南將深入解析 LinkedIn 的核心防護架構，提供三種可自行實現的抓取方案並附上可運行程式碼，結合實測結果進行性能對比，並介紹一種可取代手動配置的專業級解決方案，協助你完全繞過這些複雜的檢測流程。無論你正在構建線索挖掘工具、進行市場調研，還是為 CRM 擴充資料，都能在這裡精準了解：在 2025 年成功抓取 LinkedIn，需要哪些條件、採用哪些技術、如何穩定執行。

理解 LinkedIn 的多層反爬防禦體系

在嘗試抓取 LinkedIn 之前，必須先了解其複雜的防禦體系。LinkedIn 並非依靠單一機制，而是採用多層級聯的檢測結構，每一層都會補充前一層未識別的風險。進入 2024–2025 年後，這套架構進一步迭代，並結合基於數百萬真實使用者會話訓練的機器學習模型，使整體識別能力大幅提升。

訪問頻率與請求模式

最基礎的一層，是對不同身分使用者的訪問頻率進行監控。登入使用者一般每小時允許訪問約 80–100 個個人主頁；未登入使用者的限制約為 40 個頁面／小時；搜尋請求則更嚴格，只有約 20–30 次／小時。這些閾值並非隨意設定，而是基於真實使用者的自然瀏覽節奏建模而來。

關鍵在於 LinkedIn 如何識別這些模式。系統並不只是統計數量，而是分析行為的「節奏」與「時間分布」。真實使用者的操作間隔往往不規律：可能 3 秒點下一項，15 秒後再操作一次，中間偶爾會停留 1 分鐘閱讀內容。而爬蟲即便加入隨機延時，也會在統計學上呈現可被識別的規律性特徵。

實測結果：只要超過閾值，通常在 2–5 分鐘內就會收到 429（訪問過多）錯誤。持續觸發會導致 IP 被暫時封禁 6–24 小時，多次違規甚至可能導致帳號永久限制。

帳號行為與信任評分

LinkedIn 的 AI 會持續監控帳號行為，為每個帳號與會話建立「信任評分」。新帳號的審查力度遠高於使用超過六個月的成熟帳號。系統監測的不只是「你做了什麼」，更包括「你是如何做的」：頁面停留時長、滾動軌跡是否自然、互動深度是否符合常態，甚至包括滑鼠移動的微觀特徵。

一個真實案例非常典型：某開發者在一小時內訪問了 150 個主頁，即便使用的是標準 Chrome 瀏覽器、完全沒有自動化工具，帳號依然被限制。原因在於其訪問行為過於「機械化」：每次停留時間接近一致、滾動模式相同、且沒有任何自然互動（如發訊息、按讚）。AI 會將這類「缺乏人類特徵」的行為判定為異常，即便技術上來自真實瀏覽器。

IP 指紋與信譽體系

LinkedIn 維護著遠超黑名單級別的 IP 信譽資料庫。系統會根據 ASN 辨識數據中心 IP 段，並將其自動標記為高風險。更高級的是其能透過網路行為與路由模式區分住宅 IP、數據中心 IP 和行動網路 IP。

地理一致性在這裡非常關鍵。如果一個會話一分鐘前顯示在舊金山，下一分鐘卻跳到倫敦，系統會立即觸發警報。平台還會比對 IP 的地理位置是否與瀏覽器區域設定、HTTP 請求中的時區以及語言偏好相匹配。

實測結果：在受控測試中，來自 AWS、GCP、DigitalOcean 的 IP 在 LinkedIn 上的存活時間通常不足 5 分鐘。數據中心代理在首次訪問時即被攔截的機率高達 30–50%，與爬蟲的配置程度無關。

TLS 指紋：隱藏但致命的檢測層

這一層是抓取最難突破的技術點。在你的 HTTP 請求到達 LinkedIn 伺服器之前，TLS 握手階段已經暴露了你是否屬於真實瀏覽器。每種 HTTP 客戶端（如 Chrome、Firefox、Python requests、curl）在建立加密連線時都有固定的 TLS「指紋」。

JA3 指紋技術會分析 ClientHello 封包中的關鍵參數：TLS 版本、加密套件順序、擴充欄位、橢圓曲線及其格式。這些參數組合會形成穩定的指紋雜湊，用於區分不同客戶端。例如，Python requests 始終生成特定的指紋，而真實 Chrome 瀏覽器的指紋則完全不同。LinkedIn 能透過這些特徵在握手階段直接識別自動化工具。

# Python requests library TLS fingerprint (easily detected)
import requests
response = requests.get('https://www.linkedin.com')
# JA3 Hash: 579ccef312d18482fc42e2b822ca2430

# Real Chrome browser TLS fingerprint
# JA3 Hash: 773906b0efdefa24a7f2b8eb6985bf37
# LinkedIn can detect this difference instantly

真正的難點在於：即便你使用品質極高的住宅代理、不斷輪換瀏覽器指紋、甚至模擬完美的滑鼠軌跡，只要 TLS 指紋無法與真實瀏覽器匹配，依然會被識別。進入 2025 年後，LinkedIn 甚至開始部署更先進的 JA4 指紋，對 TLS 1.3 與 QUIC/HTTP/3 等新協議的握手特徵進行更精細的識別，進一步提升了檢測難度。

JavaScript 挑戰與瀏覽器環境校驗

現代反爬檢測早已不再停留於「是否啟用 JavaScript」這種淺層判斷。LinkedIn 會透過多種基於 JavaScript 的指紋技術，為你的瀏覽器環境生成唯一的特徵簽名。以 Canvas 指紋為例：系統會在 HTML5 canvas 上渲染文字與圖形，並分析最終像素級輸出。瀏覽器、作業系統、顯示卡、字體組合的差異都會導致結果略微不同，從而形成極其穩定且難以偽造的環境指紋。

WebGL 指紋更進一步，透過測試瀏覽器渲染 3D 圖形的方式來識別環境。系統還會驗證瀏覽器內各項 API 是否自洽。例如：如果你的 UA 聲稱自己是 Windows 上的 Chrome，但環境中缺少 window.chrome 物件，或者螢幕解析度與常見 Windows 裝置不符，這類不一致會被直接標記為異常。

// LinkedIn's JavaScript detection can catch common automation indicators
if (navigator.webdriver) {
    // Selenium and Puppeteer set this to true by default
}

if (!window.chrome || !window.chrome.runtime) {
    // Chrome browsers should have this object
    // Many automation tools don't implement it correctly
}

// Canvas fingerprinting
const canvas = document.createElement('canvas');
const ctx = canvas.getContext('2d');
ctx.textBaseline = 'top';
ctx.font = '14px Arial';
ctx.fillText('Browser fingerprint', 2, 2);
// Analyze pixel data - each browser/OS combination is unique

行為生物特徵：最難偽造的人類因素

真正最難突破的檢測機制，是行為生物特徵。LinkedIn 會捕捉各種區分真人與機器的微觀行為，而這些細節極難被模擬得足夠逼真。例如，人類的滑鼠軌跡具有自然曲線和微小誤差——會輕微滑過目標後再修正，移動加速度也不會完全穩定。捲動行為亦然：真實使用者會因閱讀停頓而出現不規則間隔，捲動速度也會因內容而變化。

連鍵盤輸入節奏都能反映是否為自動化。人類敲擊鍵盤時按鍵間隔天然會波動，而自動填表通常會呈現「過於穩定」的時間模式。行動端的觸控行為更是一層額外檢測：點擊壓感、滑動的速度曲線、慣性捲動等數據，都是爬蟲極難真實重現的。

Voyager API 防護體系

LinkedIn 的核心 Voyager API（網頁端與行動端共用）近年強化了大量安全機制。其 CSRF Token 會動態生成且每 5–10 分鐘過期，需要持續刷新身分。API 的請求簽名機制類似 AWS SigV4，用於驗證呼叫是否來自合法客戶端。更具挑戰性的是，API 端點每隔 4–8 週就會輪換一次，所有基於逆向的方案都必須不斷維護才能持續有效。

自建方案：技術實現與真實可行性分析

在了解整個防護體系後，接下來將介紹三種可自行搭建的 LinkedIn 抓取方案。每種方案都包含可運行的程式碼示例，並會如實評估其優缺點，以及長期維護成本。

方案一：基於 Selenium 的人類行為模擬

第一種方案是透過 Selenium WebDriver 搭配反檢測配置與人類行為模擬。核心思路是操控一份「盡可能接近真實使用者」的 Chrome 瀏覽器實例，讓自動化過程在外觀上完全符合正常使用者行為。這不僅僅是開啟頁面，而是要模擬真實的滑鼠移動、自然捲動軌跡、合理的操作間隔，以最大限度降低被識別的風險。

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.action_chains import ActionChains
import time
import random
import numpy as np

class LinkedInScraper:
    def __init__(self, proxy=None):
        options = webdriver.ChromeOptions()

        if proxy:
            options.add_argument(f'--proxy-server={proxy}')

        # Anti-detection measures
        options.add_argument('--disable-blink-features=AutomationControlled')
        options.add_experimental_option("excludeSwitches", ["enable-automation"])
        options.add_experimental_option('useAutomationExtension', False)

        self.driver = webdriver.Chrome(options=options)

        # Override navigator.webdriver property
        self.driver.execute_script("Object.defineProperty(navigator, 'webdriver', {get: () => undefined})")

    def human_like_mouse_movement(self, element):
        """Simulate natural mouse movement using Bezier curves"""
        action = ActionChains(self.driver)
        element_location = element.location

        # Generate points along a cubic Bezier curve for natural movement
        points = self._generate_bezier_curve(
            (0, 0),
            (element_location['x'], element_location['y']),
            num_points=random.randint(10, 20)
        )

        for point in points:
            action.move_by_offset(point[0], point[1])
            action.pause(random.uniform(0.001, 0.01))

        action.perform()

    def _generate_bezier_curve(self, start, end, num_points=15):
        """Generate points along a cubic Bezier curve"""
        # Random control points create natural curve variation
        ctrl1 = (start[0] + random.randint(-50, 50), start[1] + random.randint(-50, 50))
        ctrl2 = (end[0] + random.randint(-50, 50), end[1] + random.randint(-50, 50))

        points = []
        for i in range(num_points):
            t = i / num_points
            x = (1-t)**3 * start[0] + 3*(1-t)**2*t * ctrl1[0] + \
                3*(1-t)*t**2 * ctrl2[0] + t**3 * end[0]
            y = (1-t)**3 * start[1] + 3*(1-t)**2*t * ctrl1[1] + \
                3*(1-t)*t**2 * ctrl2[1] + t**3 * end[1]
            points.append((int(x), int(y)))

        return points

    def human_like_scroll(self):
        """Simulate natural scrolling with easing and reading pauses"""
        total_height = self.driver.execute_script("return document.body.scrollHeight")
        current_position = 0

        while current_position < total_height:
            scroll_distance = random.randint(100, 400)

            # Apply easing function for natural acceleration/deceleration
            for step in range(10):
                ease_factor = self._ease_in_out_quad(step / 10)
                scroll_amount = scroll_distance * ease_factor / 10
                self.driver.execute_script(f"window.scrollBy(0, {scroll_amount});")
                time.sleep(random.uniform(0.01, 0.05))

            current_position += scroll_distance

            # Random pause simulating reading
            time.sleep(random.uniform(0.5, 2.0))

    def _ease_in_out_quad(self, t):
        """Quadratic easing function for smooth scrolling"""
        return 2*t*t if t < 0.5 else -1+(4-2*t)*t

    def scrape_profile(self, profile_url):
        """Scrape a LinkedIn profile with anti-detection measures"""
        self.driver.get(profile_url)
        time.sleep(random.uniform(2, 4))

        # Simulate human reading behavior
        self.human_like_scroll()

        try:
            name = WebDriverWait(self.driver, 10).until(
                EC.presence_of_element_located((By.CSS_SELECTOR, "h1.text-heading-xlarge"))
            ).text

            headline = self.driver.find_element(By.CSS_SELECTOR, "div.text-body-medium").text

            return {'name': name, 'headline': headline}
        except Exception as e:
            print(f"Error scraping profile: {e}")
            return None

    def close(self):
        self.driver.quit()

# Usage
scraper = LinkedInScraper(proxy="http://your-residential-proxy:port")
data = scraper.scrape_profile("https://www.linkedin.com/in/example/")
scraper.close()

這種方案意味著巨大的工程投入。滑鼠移動需採用貝塞爾曲線實作，使路徑比直線更自然；捲動則使用緩動函式，模擬人類逐漸加速與減速的行為。動作之間加入隨機時間變化，有助於避免單純延遲產生的過於規律、容易被識別的可疑模式。

然而，現實情況並不樂觀。考慮到人類行為模擬，每個資料頁至少需要 5–10 秒才能抓取完成。同時執行多個實例需要大量伺服器資源——每個 Chrome 實例會占用 300–500MB 記憶體。LinkedIn 的使用者介面平均每 4–8 週更新一次，這意味著 CSS 選擇器會定期失效，需要持續維護。高品質住宅代理的費用約為每 GB 10–15 美元，而抓取 10,000 筆資料通常需要 20–30GB 的代理流量。即便採取了所有這些防護措施，帳號仍有 30–40% 的封禁風險，因為 Selenium 的 ChromeDriver 會留下可被高級指紋技術偵測到的痕跡。

方法二：逆向 Voyager API

第二種方法完全跳過瀏覽器，直接呼叫 LinkedIn 內部的 Voyager API。相較於瀏覽器自動化，這種方式速度更快、資源利用更高，但前提是你必須深入理解 LinkedIn 的驗證機制與 CSRF 保護體系。只有在正確模擬登入流程、處理動態 Token、還原真實客戶端的請求簽名情況下，Voyager API 才會回傳有效資料。

換句話說，這不是簡單的 HTTP 請求，而是對 LinkedIn 內部通訊邏輯的完整還原——任何細節不一致，都會立即觸發風控。

import requests
import re

class VoyagerAPIScraper:
    def __init__(self, li_at_cookie):
        """
        Initialize with your LinkedIn session cookie

        To get li_at cookie:
        1. Login to LinkedIn in your browser
        2. Open DevTools > Application > Cookies
        3. Copy the 'li_at' cookie value
        """
        self.session = requests.Session()

        self.session.headers.update({
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
            'Accept': 'application/vnd.linkedin.normalized+json+2.1',
            'Accept-Language': 'en-US,en;q=0.9',
            'x-li-lang': 'en_US',
            'x-restli-protocol-version': '2.0.0',
        })

        self.session.cookies.set('li_at', li_at_cookie, domain='.linkedin.com')
        self._get_csrf_token()

    def _get_csrf_token(self):
        """Extract CSRF token from session"""
        response = self.session.get('https://www.linkedin.com/feed/')

        jsessionid = self.session.cookies.get('JSESSIONID', domain='.linkedin.com')

        if jsessionid:
            csrf_token = jsessionid.strip('"')
            self.session.headers.update({'csrf-token': csrf_token})
        else:
            raise Exception("Failed to obtain CSRF token")

    def get_profile(self, profile_id):
        """Fetch profile data using Voyager API"""
        url = f'https://www.linkedin.com/voyager/api/identity/profiles/{profile_id}/profileView'

        try:
            response = self.session.get(url)

            if response.status_code == 200:
                data = response.json()
                return self._parse_profile_data(data)
            elif response.status_code == 429:
                print("Rate limited! Wait before retrying.")
                return None
            else:
                print(f"Error {response.status_code}")
                return None

        except Exception as e:
            print(f"Request failed: {e}")
            return None

    def _parse_profile_data(self, raw_data):
        """Parse the complex Voyager API response"""
        try:
            profile = raw_data.get('profile', {})

            first_name = profile.get('firstName', '')
            last_name = profile.get('lastName', '')
            headline = profile.get('headline', '')
            location = profile.get('locationName', '')

            experience = []
            positions = raw_data.get('positionView', {}).get('elements', [])

            for position in positions:
                exp = {
                    'title': position.get('title', ''),
                    'company': position.get('companyName', ''),
                    'duration': position.get('timePeriod', {}),
                }
                experience.append(exp)

            return {
                'name': f"{first_name} {last_name}",
                'headline': headline,
                'location': location,
                'experience': experience,
            }
        except Exception as e:
            print(f"Parsing error: {e}")
            return None

# Usage
scraper = VoyagerAPIScraper(li_at_cookie="YOUR_LI_AT_COOKIE_HERE")
profile = scraper.get_profile("williamhgates")
print(profile)

Voyager API 的方案在技術層面確實優雅，但在實際使用中極其脆弱。雖然可以從 JSESSIONID Cookie 中提取 CSRF Token，但該 Token 通常僅能維持 5–10 分鐘，需要不斷刷新才能保持有效。API 的回傳結構高度巢狀，且會在毫無預警的情況下發生變動。例如，一個欄位原本位於 profile.data.elements[0].value，更新後可能突然被移到 profile.included[2].attributes.value。更關鍵的是，LinkedIn 會監控異常的 API 使用模式。如果個人帳號每小時發起數百次 API 請求，這類行為會被視為高風險，非常容易觸發風控，最終導致帳號立即遭到封禁。

更進一步，Voyager 的端點結構本身就是一個不斷變動的「移動靶」。通常每隔 4–8 週端點就會發生調整。有時只是 URL 的版本號改動，有時則是整個端點結構被重新組織。這意味著你的爬蟲腳本會定期失效，每次都必須重新逆向分析端點結構才能維持正常運作。此外，其存取頻率限制與瀏覽器環境一致：每個帳號每小時仍然只能維持約 80–100 次請求。因此，API 的速度優勢僅體現在執行時間上，並不會提升整體吞吐量。

方法三：高級匿名的 Playwright

第三種方案使用 Playwright 這個更現代的瀏覽器自動化框架，並結合隱匿技術來降低自動化特徵。Playwright 在架構設計與預設行為上相較 Selenium 更具優勢，表現更穩定、可被識別的自動化痕跡也更少。但無論技術棧如何優化，仍無法繞開瀏覽器指紋識別這一根本難題。平台依舊能透過指紋參數、圖形渲染特徵、硬體特徵、執行節奏等多維度進行檢測，因此隱匿能力始終是此方案的瓶頸所在。

from playwright.sync_api import sync_playwright
import random

class StealthLinkedInScraper:
    def __init__(self, proxy_config=None):
        self.playwright = sync_playwright().start()

        self.browser = self.playwright.chromium.launch(
            headless=True,
            args=[
                '--disable-blink-features=AutomationControlled',
                '--disable-dev-shm-usage',
                '--no-sandbox',
            ]
        )

        context_options = {
            'viewport': {'width': 1920, 'height': 1080},
            'user_agent': self._get_random_user_agent(),
            'locale': 'en-US',
            'timezone_id': 'America/New_York',
            'permissions': ['geolocation'],
            'geolocation': {'latitude': 40.7128, 'longitude': -74.0060},
        }

        if proxy_config:
            context_options['proxy'] = proxy_config

        self.context = self.browser.new_context(**context_options)

        # Inject stealth scripts to hide automation
        self.context.add_init_script("""
            // Override navigator.webdriver
            Object.defineProperty(navigator, 'webdriver', {
                get: () => undefined,
            });

            // Mock plugins array
            Object.defineProperty(navigator, 'plugins', {
                get: () => [1, 2, 3, 4, 5],
            });

            // Override languages
            Object.defineProperty(navigator, 'languages', {
                get: () => ['en-US', 'en'],
            });

            // Add Chrome runtime object
            window.chrome = {
                runtime: {},
            };

            // Fix permissions API
            const originalQuery = window.navigator.permissions.query;
            window.navigator.permissions.query = (parameters) => (
                parameters.name === 'notifications' ?
                    Promise.resolve({ state: Notification.permission }) :
                    originalQuery(parameters)
            );
        """)

        self.page = self.context.new_page()

    def _get_random_user_agent(self):
        """Return a random realistic User-Agent"""
        user_agents = [
            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
            'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0',
        ]
        return random.choice(user_agents)

    def scrape_profile(self, profile_url):
        """Scrape profile with stealth mode"""
        self.page.goto(profile_url, wait_until='networkidle')
        self.page.wait_for_timeout(random.randint(2000, 4000))

        # Natural scrolling simulation
        for _ in range(random.randint(3, 6)):
            self.page.evaluate(f'window.scrollBy(0, {random.randint(200, 500)})')
            self.page.wait_for_timeout(random.randint(500, 1500))

        try:
            name = self.page.query_selector('h1.text-heading-xlarge').inner_text()
            headline = self.page.query_selector('div.text-body-medium').inner_text()

            return {'name': name, 'headline': headline}
        except Exception as e:
            print(f"Error: {e}")
            return None

    def close(self):
        self.browser.close()
        self.playwright.stop()

# Usage
proxy = {
    'server': 'http://proxy.example.com:8080',
    'username': 'user',
    'password': 'pass'
}

scraper = StealthLinkedInScraper(proxy_config=proxy)
data = scraper.scrape_profile("https://www.linkedin.com/in/example/")
scraper.close()

雖然隱匿腳本可以成功隱藏像 navigator.webdriver 這類基礎自動化訊號，但它們無法解決更深層的指紋問題。LinkedIn 的 2025 年檢測系統會在你的 JavaScript 程式碼尚未執行之前，就透過 TLS 握手階段完成分析，因此這些基於客戶端的補丁根本不足以對抗偵測。此方案依舊需要依賴高品質的住宅代理池來避開 IP 等級的風控，而若要達到可用規模，此類代理的月成本通常落在 500 至 1000 美元之間。此外，每個瀏覽器實例會占用 200–400MB 記憶體，若需要並行執行數十個實例，就必須投入昂貴的伺服器資源。更重要的是，透過行為分析系統，LinkedIn 仍能根據極為細微的時間節奏、操作路徑與互動序列來辨識自動化行為，而這些行為特徵幾乎無法完全模擬得如真人般自然。

專業替代方案：521Proxy LinkedIn Scraper API

在深入體驗各種自建方案的技術複雜度與持續維護成本後，需要回到一個最核心的問題：

你是否真的應該自行打造 LinkedIn 的資料採集系統？如果你的核心業務是銷售、商業情報或人才情報，而不是維護龐大且脆弱的爬蟲基礎架構，那麼採用專業 API 反而是更具成本效益的選擇。

521Proxy 的 LinkedIn Scraper API 提供了完全不同的解決路徑。你不需要親自對抗 LinkedIn 的反爬機制，而是直接利用專為此目的構建的基礎設施。該服務透過全球 7200 萬台真實裝置的住宅 IP 網路運行，每次請求都會自動匹配與該 IP 完全一致的瀏覽器指紋，包括地理位置、裝置類型與網路環境。

系統會自動生成自然行為模擬，例如捲動速度、滑鼠軌跡、停留時間等。我們前面提到的所有技術難題——TLS 指紋、JavaScript 挑戰、行為生物特徵——都在後端自動處理，對使用者完全透明。

支撐這一切的技術架構非常複雜。當你發起 API 請求時，系統會將請求分配到 521Proxy 的住宅 IP 網路中，並根據目標資料頁的地理位置進行智慧選擇。每一次請求都會使用與該 IP 特徵完全匹配、經過驗證的真實瀏覽器指紋。系統會自動模擬人類瀏覽行為、處理所有出現的 CAPTCHA，並對失敗的請求使用不同的 IP 和配置進行自動重試。所有失敗請求都會被系統自動識別並在不產生額外費用的情況下重新提交。

資料提取本身由持續維護與即時更新的解析器負責。當 LinkedIn 修改其 HTML 結構或 API 回傳格式時，521Proxy 團隊會在數小時內更新對應的解析元件，你的程式碼無需做任何調整便能繼續正常運行。API 回傳的內容是乾淨、結構化的 JSON 資料，包括個人資料、工作經歷、教育背景、技能、推薦、最新動態以及社交網路相關指標等完整資料點。

521Proxy 快速入門指南

與自建爬蟲相比，使用 521Proxy 的 API 入門極為簡單。從註冊到完成第一個成功抓取，通常不超過 10 分鐘。

初始化設定

首先造訪 LinkedIn Scraper 產品頁面並開啟免費試用。你會獲得 100 條免費的資料額度，無需綁定信用卡，這足以用來測試 API 並驗證其資料品質。註冊完成後，進入儀表板複製你的 API Key，這就是在 521Proxy 端所需的全部準備工作。

基礎資料抓取

下面是一個完整的示例，用於抓取 LinkedIn 個人資料並回傳結構化資料：

import requests
import json
import time

class BrightDataLinkedIn:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = "https://api.brightdata.com/datasets/v3"
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }

    def scrape_profile(self, profile_url):
        """Scrape a single LinkedIn profile"""
        endpoint = f"{self.base_url}/trigger"

        payload = [{
            "url": profile_url,
            "dataset_id": "gd_l7q7dkf244hwjntr0",
            "format": "json"
        }]

        # Trigger the scraping job
        response = requests.post(endpoint, headers=self.headers, json=payload)

        if response.status_code != 200:
            raise Exception(f"API Error: {response.status_code}")

        result = response.json()
        snapshot_id = result.get('snapshot_id')

        # Wait for results
        return self._wait_for_results(snapshot_id)

    def _wait_for_results(self, snapshot_id, max_wait=60):
        """Poll for scraping job completion"""
        endpoint = f"{self.base_url}/snapshot/{snapshot_id}"

        for _ in range(max_wait):
            response = requests.get(endpoint, headers=self.headers)

            if response.status_code == 200:
                data = response.json()
                if data.get('status') == 'ready':
                    return data.get('data', [])

            time.sleep(2)

        raise Exception("Timeout waiting for results")

# Usage
scraper = BrightDataLinkedIn(api_key="YOUR_API_KEY_HERE")
profile = scraper.scrape_profile("https://www.linkedin.com/in/satyanadella/")
print(json.dumps(profile, indent=2))

該 API 採用「觸發（trigger）+ 輪詢（poll）」的呼叫模式。你首先提交目標 URL 來觸發一個抓取任務，系統會回傳一個快照 ID。隨後你只需要輪詢這個快照 ID，直到結果準備完成即可。這種非同步機制允許系統自行最佳化請求調度，並在後台自動處理所有速率限制問題，從而避免人工干預。

批量抓取：面向規模的解決方案

該 API 最強大的能力之一，就是支援批量處理。相比逐條請求每個個人資料，你可以在單次批量請求中提交多達 1000 個 URL，實現高吞吐量的資料採集：

def scrape_multiple_profiles(self, profile_urls):
    """Scrape up to 1000 profiles in one batch"""
    endpoint = f"{self.base_url}/trigger"

    payload = [
        {"url": url, "dataset_id": "gd_l7q7dkf244hwjntr0"}
        for url in profile_urls
    ]

    response = requests.post(endpoint, headers=self.headers, json=payload)
    snapshot_id = response.json()['snapshot_id']

    return self._wait_for_results(snapshot_id, max_wait=300)

# Scrape 100 profiles at once
urls = [
    "https://www.linkedin.com/in/profile1/",
    "https://www.linkedin.com/in/profile2/",
    # ... up to 1000 URLs
]

results = scraper.scrape_multiple_profiles(urls)

for profile in results:
    print(f"{profile['name']} - {profile['headline']}")

批量处理相比逐条请求效率高出数倍。系统会并行处理多个资料页，同时自动管理速率限制、IP 轮换与失败重试。以 100 个资料为例，通常 2–3 分钟即可完成；而自建爬虫由于必须严格控制节奏、避免触发风控，往往需要数小时才能完成同样规模的任务。

基于搜索的发现能力

除了抓取已知的资料 URL 之外，API 还支持通过关键词搜索来发现新的目标。这对线索挖掘、销售拓展或市场调研尤其重要，尤其是在你需要寻找符合特定条件的用户时：

def search_profiles(self, keyword, location=None, limit=100):
    """Search for LinkedIn profiles by keyword and location"""
    endpoint = f"{self.base_url}/trigger"

    payload = [{
        "dataset_id": "gd_l7q7dkf244hwjntr0",
        "discover_by": "keyword",
        "keyword": keyword,
        "limit": limit
    }]

    if location:
        payload[0]["location"] = location

    response = requests.post(endpoint, headers=self.headers, json=payload)
    snapshot_id = response.json()['snapshot_id']

    return self._wait_for_results(snapshot_id, max_wait=180)

# Find AI Engineers in San Francisco
profiles = scraper.search_profiles(
    keyword="AI Engineer",
    location="San Francisco Bay Area",
    limit=50
)

for profile in profiles:
    print(f"{profile['name']} at {profile.get('current_company', 'N/A')}")

实际应用示例：CRM 数据增强

以下是一个将 LinkedIn 数据整合到 Salesforce 用于线索增强的实际示例。这种模式同样适用于其他 CRM 系统，如 HubSpot、Pipedrive 或自定义系统：

from simple_salesforce import Salesforce

class LinkedInCRMEnrichment:
    def __init__(self, linkedin_api_key, sf_username, sf_password, sf_token):
        self.linkedin = BrightDataLinkedIn(linkedin_api_key)
        self.sf = Salesforce(
            username=sf_username,
            password=sf_password,
            security_token=sf_token
        )

    def enrich_leads(self, linkedin_urls):
        """Enrich Salesforce leads with LinkedIn data"""
        print(f"Scraping {len(linkedin_urls)} LinkedIn profiles...")
        profiles = self.linkedin.scrape_multiple_profiles(linkedin_urls)

        updated_count = 0

        for profile in profiles:
            try:
                # Find existing lead by LinkedIn URL
                lead_query = f"SELECT Id FROM Lead WHERE LinkedIn_URL__c = '{profile['url']}'"
                result = self.sf.query(lead_query)

                if result['totalSize'] > 0:
                    lead_id = result['records'][0]['Id']

                    # Update with enriched data
                    update_data = {
                        'Title': profile.get('headline', ''),
                        'Company': profile.get('current_company', ''),
                        'Industry': profile.get('industry', ''),
                        'LinkedIn_Headline__c': profile.get('headline', ''),
                        'LinkedIn_Summary__c': profile.get('about', '')[:255],
                    }

                    self.sf.Lead.update(lead_id, update_data)
                    updated_count += 1
                    print(f"Updated: {profile['name']}")

            except Exception as e:
                print(f"Error updating {profile.get('name', 'Unknown')}: {e}")

        print(f"\nSuccessfully updated {updated_count} leads")
        return updated_count

# Usage
enricher = LinkedInCRMEnrichment(
    linkedin_api_key="YOUR_BRIGHT_DATA_KEY",
    sf_username="[email protected]",
    sf_password="yourpassword",
    sf_token="yourtoken"
)

linkedin_urls = [
    "https://www.linkedin.com/in/lead1/",
    "https://www.linkedin.com/in/lead2/",
]

enricher.enrich_leads(linkedin_urls)

理解返回数据结构

该 API 会为每个个人资料返回完整、结构化的数据。下面是一个完整响应示例：

{
  "name": "Satya Nadella",
  "url": "https://www.linkedin.com/in/satyanadella/",
  "headline": "Chairman and CEO at Microsoft",
  "location": "Redmond, Washington, United States",
  "country_code": "US",
  "followers": 12500000,
  "connections": "500+",
  "about": "I'm Chairman and CEO of Microsoft...",
  "current_company": "Microsoft",
  "current_position": "Chairman and CEO",
  "experience": [
    {
      "title": "Chairman and CEO",
      "company": "Microsoft",
      "company_url": "https://www.linkedin.com/company/microsoft/",
      "location": "Redmond, WA",
      "start_date": "Feb 2014",
      "end_date": "Present",
      "duration": "10 yrs 11 mos",
      "description": "Leading Microsoft's transformation..."
    }
  ],
  "education": [
    {
      "school": "University of Chicago Booth School of Business",
      "degree": "MBA",
      "field_of_study": "Business Administration",
      "start_year": 1996,
      "end_year": 1997
    }
  ],
  "skills": [
    {"name": "Cloud Computing", "endorsements": 99},
    {"name": "Enterprise Software", "endorsements": 87}
  ],
  "languages": [
    {"name": "English", "proficiency": "Native or bilingual"}
  ]
}

这些数据是实时的，也就是说你获取的是 LinkedIn 当前显示的最新信息，而非数据库中陈旧的数据。对于失败的请求——无论是因为资料不存在、被设置为私密，还是暂时无法访问——都不会产生费用，系统会对临时失败的请求自动重试，且无需额外支付任何费用。

如何在不被封锁的情况下抓取 LinkedIn 数据(1家)

521Proxy  

評分:4.87 / 5 分

RESIGB50|50% 優惠

已複製

$ 0.20/代理/月 數據中心代理（共享）

$ 1.84/代理/月 數據中心代理

$ 9.00/GB/月 ISP靜態代理

$ 14.40/GB/月 動態住宅住宅

$ 5.04/GB/月 移動代理

$ 0.20/代理/月

數據中心代理（共享）

官網  詳情

 

支付寶

 

信用卡

 

Paypal

结论

构建 LinkedIn 爬虫在技术上是可行的——我们已经展示了三种不同方法及其可运行代码。每种方法在正确实现后都能成功提取个人资料数据。然而，真正需要考虑的问题不是你是否能构建爬虫，而是你是否应该将工程资源投入到爬虫基础设施的建设与维护中。

自建方案在特定场景下是合理的：当你每月抓取的资料数量少于 1,000 条时，当你有额外的工程能力用于持续维护时，当构建爬虫技术是业务核心能力之一时，或当你有 API 无法满足的独特需求时。然而，对大多数企业而言，从经济角度来看，采用专业服务更加合理。

我们前面探讨的技术难题——从 TLS 指纹识别到行为生物特征分析——都非常复杂且不断演化。LinkedIn 在反爬技术上的投入巨大，因为他们有强烈动机控制数据访问。应对这些系统需要持续的工程投入、深厚的技术专长以及长期的维护。当你的核心业务是数据驱动的销售、市场调研或人才情报，而非爬虫基础设施时，这种工程投入从经济角度来看往往不划算。

像 521Proxy 这样的专业 API 提供了不同的选择权衡。你用可控性换取可靠性，用维护负担换取可预测的运行，用复杂的基础设施换取简单的 API 调用。对于需要高可用、可扩展的生产系统，以及希望工程团队专注于产品功能而非基础设施维护的场景，API 方案能够以更低的总体成本提供更优的结果。

如何在不被封锁的情况下抓取 LinkedIn 数据測評常見問答