如何在不被封锁的情况下抓取 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 保护体系。只有在正确模拟登录流程、处理动态令牌、还原真实客户端请求签名的情况下，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 仍然能够通过极其细微的时间节奏、操作路径和交互序列来识别自动化行为，而这些行为特征几乎无法完全模拟得像真人一样自然。

专业替代方案：Bright Data LinkedIn Scraper API

在深入体验了各种自建方案的技术复杂性和持续维护成本之后，需要回到一个最核心的问题：你是否真的应该自己构建 LinkedIn 的采集系统？如果你的核心业务是数据驱动的销售、市场情报或人才情报，而不是维护庞大而脆弱的爬虫基础设施，那么采用专业 API 反而是更具性价比的选择。

Bright Data 的 LinkedIn Scraper API 提供了完全不同的解决路径。你不需要亲自与 LinkedIn 的反爬系统对抗，而是直接使用为此目的专门搭建的基础设施。该服务通过全球 7200 万真实设备住宅 IP 网络运行，每一次请求都会匹配与该 IP 完全一致的浏览器指纹，包括地理位置、设备类型和网络环境。系统会自动生成自然行为模拟，包括滚动速度、鼠标轨迹、停留时间等。我们前面提到的所有技术难题——TLS 指纹、JavaScript 挑战、行为生物识别——都在后台被自动处理，对使用者完全透明。

支撑这一切的技术架构非常复杂。当你发起 API 请求时，系统会将请求分配到 Bright Data 的住宅 IP 网络中，并根据目标资料页的地理位置进行智能选择。每一次请求都会使用与该 IP 特征完全匹配、经过验证的真实浏览器指纹。系统会自动模拟人类浏览行为、处理所有出现的 CAPTCHA，并对失败的请求使用不同的 IP 和配置进行自动重试。所有失败请求都会被系统自动识别并在不产生额外费用的情况下重新提交。

数据提取本身由持续维护和实时更新的解析器负责。当 LinkedIn 修改其 HTML 结构或 API 返回格式时，Bright Data 团队会在数小时内更新对应的解析组件，你的代码无需做任何调整便能继续正常运行。API 返回的内容是干净、结构化的 JSON 数据，包括个人资料、工作经历、教育背景、技能、推荐、最新动态以及社交网络相关指标等完整数据点。

Bright Data 快速入门指南

与自建爬虫相比，使用 Bright Data 的 API 入门极为简单。从注册到完成第一个成功抓取，通常不超过 10 分钟。

初始化设置

首先访问 LinkedIn Scraper 产品页面并开启免费试用。你会获得 100 条免费的数据额度，无需绑定信用卡，这足以用于测试 API 并验证其数据质量。注册完成后，进入仪表盘复制你的 API Key，这就是在 Bright Data 端所需的全部准备工作。

基础资料抓取

下面是一个完整的示例，用于抓取 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家)

Bright Data  

评分: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 在反爬技术上的投入巨大，因为他们有强烈动机控制数据访问。应对这些系统需要持续的工程投入、深厚的技术专长以及长期的维护。当你的核心业务是数据驱动的销售、市场调研或人才情报，而非爬虫基础设施时，这种工程投入从经济角度来看往往不划算。

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

• LinkedIn
• LinkedIn爬虫
• 无头浏览器
• captcha绕过

如何在不被封锁的情况下抓取 LinkedIn 数据测评常见问答