Python视频链接爬虫实战：从页面抓取到m3u8解析与批量管理

这次我们来看一个用 Python 实现的视频链接爬虫项目。它不是破解工具，也不是“一键白嫖”脚本，而是一套面向公开视频页面的链接提取与批量管理方案。你给它一个页面地址，它能自动抓取页面里的视频播放地址、解析 m3u8 资源、清洗无效链接，最后把结果整理成 JSON 或 Markdown 清单。整个流程可以用命令行跑，也可以挂成 API 服务，还能放进批量任务队列里，非常适合做视频素材归档、公开资源整理和个人学习研究。

先说明一下底线：本文章只讨论技术实现和合法使用边界，不提供任何绕过付费、破解版权、盗取会员内容的方法。如果你想把爬虫用在视频站点上，请务必确认目标内容有公开访问权限或已获得授权。下面直接进入正文。

1. 核心能力速览

这个项目的重点不是“复杂到没法跑”，而是把爬虫流程拆成四个可复用的模块：抓取、解析、清洗、输出。每一步都能单独测试，也能组合成流水线。下面从环境准备开始，逐步搭建并验证。

2. 适用场景与使用边界

2.1 适合谁用

• 需要批量整理公开视频链接的运营或编辑同学。
• 想学习 Python 爬虫、解析、反爬处理的开发者。
• 需要把网页内视频内容结构化保存的技术爱好者。
• 做内容合规监测，需要定期检查链接是否有效的运维人员。

2.2 能解决什么问题

• 人工复制几十个页面链接，效率低，容易漏。
• 页面里视频地址可能是相对路径或加密参数，需要统一解析。
• 需要把结果输出成结构化数据，方便后续入库或展示。
• 大量 URL 需要按固定频率轮询，人工盯不过来。

2.3 不适用什么场景

• 有防盗链、需要付费解锁才能播放的视频。
• 明确禁止爬取，或者 robots.txt 不允许访问的站点。
• 需要模拟登录、绕过验证码才能获取的内容。
• 对实时性要求极高、需要流媒体协议直连播放的场景。

2.4 必须遵守的合规边界

• 只抓取公开可访问、无版权限制的内容。
• 不破解鉴权参数、不绕过播放限制。
• 遵守目标网站的 robots.txt 和“服务条款”。
• 不对目标服务器造成压力，控制请求频率。
• 涉及人脸、声音、用户生成内容时，必须确认合法授权。
• 爬取结果仅用于个人学习或内部测试，不得公开传播侵权内容。

3. 环境准备与前置条件

3.1 操作系统

Windows 10/11、Ubuntu 20.04+、macOS 均可。下面命令以 Windows 和 Linux 为例，macOS 类似。

3.2 Python 环境

建议使用 Python 3.8 及以上版本。检查方式：

python --version

如果还没装 Python，到官网下载安装包，安装时勾选“Add Python to PATH”。

3.3 创建虚拟环境

推荐每个项目单独建虚拟环境，避免依赖冲突。

mkdir video-link-crawler cd video-link-crawler python -m venv venv

激活虚拟环境：

Windows：

.\venv\Scripts\activate

Linux/macOS：

source venv/bin/activate

3.4 安装依赖

本项目核心依赖如下：

pip install requests beautifulsoup4 lxml flask

如果你只需要命令行批量任务，可以不装 flask。lxml 用于快速解析 HTML，比默认解析器更快。

3.5 项目目录结构

建议按下面方式组织：

video-link-crawler/ ├── crawler/ │ ├── __init__.py │ ├── fetcher.py # 页面下载 │ ├── parser.py # 视频地址提取 │ ├── cleaner.py # 链接清洗与去重 │ └── runner.py # 批量执行逻辑 ├── api/ │ └── server.py # API 服务 ├── inputs/ # 待处理的 URL 列表 │ └── urls.txt ├── outputs/ # 抓取结果 ├── main.py # 命令行入口 └── requirements.txt

4. 安装部署与启动方式

4.1 编写页面抓取模块

先实现crawler/fetcher.py，负责下载页面并处理超时、重试：

import requests import time from urllib.parse import urlparse class PageFetcher: def __init__(self, timeout=10, retries=3, delay=0.5): self.timeout = timeout self.retries = retries self.delay = delay self.session = requests.Session() def set_headers(self, headers: dict = None): default_headers = { "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) " "AppleWebKit/537.36 (KHTML, like Gecko) " "Chrome/120.0.0.0 Safari/537.36", "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8", "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8", } if headers: default_headers.update(headers) self.session.headers.update(default_headers) def fetch_page(self, url: str) -> tuple[str, bool]: for attempt in range(1, self.retries + 1): try: resp = self.session.get(url, timeout=self.timeout) resp.raise_for_status() return resp.text, True except Exception as e: print(f"[{attempt}] 请求 {url} 失败: {e}") time.sleep(self.delay * attempt) return "", False def close(self): self.session.close()

注意：这里的 User-Agent 只是一般标识，不要伪装成其他服务，也不要伪造真实浏览器，避免误导目标站点。

4.2 编写地址解析模块

crawler/parser.py负责从 HTML 中提取视频地址。视频地址常见形式有三种：

• <video src="...">标签。
• m3u8链接出现在script或iframe中。
• mp4 链接以变量赋值形式存在。

import re from urllib.parse import urljoin from bs4 import BeautifulSoup class VideoLinkParser: VIDEO_EXT = (".mp4", ".webm", ".ogg") HLS_PATTERN = re.compile(r"['\"]([^'\"]+\.m3u8[^'\"]*?)['\"]", re.I) MP4_PATTERN = re.compile(r"['\"]([^'\"]+\.mp4[^'\"]*?)['\"]", re.I) def __init__(self, page_url: str): self.page_url = page_url def parse(self, html: str) -> list: links = [] links.extend(self._parse_video_tag(html)) links.extend(self._parse_hls(html)) links.extend(self._parse_mp4(html)) links = [urljoin(self.page_url, link) for link in links] # 去重，保持顺序 seen = set() unique_links = [] for link in links: if link not in seen: seen.add(link) unique_links.append(link) return unique_links def _parse_video_tag(self, html: str) -> list: soup = BeautifulSoup(html, "lxml") results = [] for video in soup.find_all("video"): src = video.get("src") if src: results.append(src) for source in video.find_all("source"): source_src = source.get("src") if source_src: results.append(source_src) return results def _parse_hls(self, html: str) -> list: return self.HLS_PATTERN.findall(html) def _parse_mp4(self, html: str) -> list: return self.MP4_PATTERN.findall(html)

解析逻辑并不复杂，但已经能覆盖大多数静态嵌入的视频链接。如果目标页面是动态渲染出来的，后面会单独处理。

4.3 编写清洗模块

crawler/cleaner.py负责过滤无效链接、排除明显不是视频文件的地址：

from urllib.parse import urlparse class LinkCleaner: VIDEO_SUFFIXES = ( ".m3u8", ".mp4", ".webm", ".ogg", "/playlist.m3u8", "/index.m3u8" ) @classmethod def clean(cls, links: list) -> list: cleaned = [] for link in links: if not link: continue if not cls._looks_like_video_url(link): continue cleaned.append(link) return list(dict.fromkeys(cleaned)) @staticmethod def _looks_like_video_url(url: str) -> bool: path = urlparse(url).path.lower() return path.endswith(LinkCleaner.VIDEO_SUFFIXES)

注意，dict.fromkeys虽然可以保留顺序去重，但如果有大量数据，可读性较差。这里仅用于少量链接，问题不大。更稳妥的做法是用set再排序。

4.4 命令行入口

main.py提供最简单的一键式体验：

import argparse import json from crawler.fetcher import PageFetcher from crawler.parser import VideoLinkParser from crawler.cleaner import LinkCleaner def process_url(url: str) -> dict: fetcher = PageFetcher() html, ok = fetcher.fetch_page(url) if not ok: return {"url": url, "status": "fail", "links": []} parser = VideoLinkParser(url) raw_links = parser.parse(html) clean_links = LinkCleaner.clean(raw_links) fetcher.close() return { "url": url, "status": "success", "links": clean_links, } def main(): parser = argparse.ArgumentParser(description="视频链接提取工具") parser.add_argument("--url", help="单个页面 URL") parser.add_argument("--input", help="包含 URL 列表的文件，每行一个") parser.add_argument("--output", default="outputs/result.json", help="结果输出路径") args = parser.parse_args() urls = [] if args.url: urls.append(args.url) elif args.input: with open(args.input, "r", encoding="utf-8") as f: urls = [line.strip() for line in f if line.strip()] if not urls: print("请提供 --url 或 --input 参数") return results = [] for url in urls: print(f"处理: {url}") result = process_url(url) results.append(result) with open(args.output, "w", encoding="utf-8") as f: json.dump(results, f, ensure_ascii=False, indent=2) print(f"完成，结果写入 {args.output}") if __name__ == "__main__": main()

4.5 测试启动

先创建一个测试 URL 文件inputs/urls.txt：

https://www.example.com/video/1 https://www.example.com/video/2

运行：

mkdir -p outputs python main.py --input inputs/urls.txt

看到输出结果后，检查outputs/result.json。

需要说明的是，示例 URL 不会返回真实视频，仅用于演示流程。实际使用中要替换成你已获授权访问的页面。

5. 功能测试与效果验证

5.1 测试静态视频标签页面

准备一个包含<video>标签的测试 HTML 文件（或直接在本地起一个简单服务器）：

<!DOCTYPE html> <html> <head><title>测试页面</title></head> <body> <video controls src="https://example.com/media/demo.mp4"></video> <video controls> <source src="https://example.com/media/demo2.webm" type="video/webm"> </video> <script> var playerUrl = "https://example.com/hls/demo.m3u8"; </script> </body> </html>

然后用--url指向它，预期结果中应包含：

• https://example.com/media/demo.mp4
• https://example.com/media/demo2.webm
• https://example.com/hls/demo.m3u8

判断标准：三个地址都出现在输出里，且相对路径已拼接为完整 URL。

5.2 测试相对路径解析

如果 HTML 里写的是/media/demo.mp4，而页面地址是https://example.com/watch/111，解析后应为https://example.com/media/demo.mp4。这一步验证urljoin是否生效。

5.3 测试无效链接过滤

链接中混入：

• 图片地址https://example.com/poster.jpg
• JS 文件https://example.com/app.js
• 带参数的https://example.com/media/demo.mp4?token=abc

清洗模块应只保留最后一条demo.mp4，过滤掉.jpg和.js。

5.4 测试动态页面

有些视频链接是 JS 渲染后才出现的，requests 直接抓不到。这时需要 Selenium 或 Playwright。

这里给出 Selenium 的替代思路，不额外安装浏览器驱动的情况下，可以先分析接口。如果页面真的有 AJAX 接口，可以抓包后直接用 requests 请求那个接口。比如：

import requests api_url = "https://example.com/api/video?id=123" resp = requests.get(api_url, timeout=10) data = resp.json() print(data.get("video_url"))

如果确实需要 Selenium，安装：

pip install selenium

然后用 Chrome 无头模式：

from selenium import webdriver from selenium.webdriver.chrome.options import Options options = Options() options.add_argument("--headless") driver = webdriver.Chrome(options=options) driver.get("https://example.com/video/123") html = driver.page_source driver.quit()

再把html传给VideoLinkParser。不过这不是本项目默认模块，需要根据实际情况扩展。

5.5 测试批量任务

在inputs/urls.txt里放 5 个 URL，运行后检查：

• 所有 URL 都被处理。
• 输出 JSON 中，每个 URL 都有status字段。
• 失败 URL 不会中断整个流程。
• 输出文件可读，能直接导入 Excel 或数据库。

5.6 判断成功标准

• 返回的链接都是可下载或可播放的公开链接。
• 没有漏掉视频标签里的src。
• 清洗后没有图片或 JS 地址。
• 批量任务中途遇到网络错误不会崩。
• 输出 JSON 格式合法，包含 URL 和 links 字段。

5.7 常见测试失败原因

• 网页被 WAF 拦截：更换请求头、降低频率，或检查是否需要在请求里携带 Cookie。
• 视频链接是相对路径且没带协议：检查urljoin是否用了页面 URL。
• 链接藏在 JS 变量里，但正则没匹配到：检查转义，或改用更宽松的正则。
• 页面本身需要登录：项目不支持登录态，需要先解决授权问题。

6. 接口 API 与批量任务

6.1 提供 API 服务

为了方便集成到其他系统，可以加一个 Flask API。

api/server.py：

from flask import Flask, request, jsonify from crawler.fetcher import PageFetcher from crawler.parser import VideoLinkParser from crawler.cleaner import LinkCleaner app = Flask(__name__) @app.route("/extract", methods=["POST"]) def extract(): data = request.get_json() if not data or "url" not in data: return jsonify({"code": 400, "message": "缺少 url 参数"}), 400 url = data["url"] fetcher = PageFetcher() html, ok = fetcher.fetch_page(url) if not ok: return jsonify({"code": 500, "message": "页面抓取失败", "url": url}), 500 raw_links = VideoLinkParser(url).parse(html) clean_links = LinkCleaner.clean(raw_links) fetcher.close() return jsonify({ "code": 0, "url": url, "links": clean_links, }) @app.route("/health", methods=["GET"]) def health(): return jsonify({"status": "ok"}) if __name__ == "__main__": app.run(host="127.0.0.1", port=8000, debug=False)

启动服务：

python api/server.py

注意：如果端口 8000 被占用，可以修改为其他端口，比如 8090。

6.2 调用 API

用 curl 测试：

curl -X POST http://127.0.0.1:8000/extract \ -H "Content-Type: application/json" \ -d '{"url": "https://www.example.com/video/1"}'

用 Python requests 测试：

import requests url = "http://127.0.0.1:8000/extract" payload = {"url": "https://www.example.com/video/1"} resp = requests.post(url, json=payload, timeout=30) print(resp.json())

返回结果大致如下：

{ "code": 0, "url": "https://www.example.com/video/1", "links": [ "https://example.com/media/demo.mp4" ] }

6.3 批量任务设计

批量任务有两种实现思路：

方案一：多线程批量处理

使用ThreadPoolExecutor，控制并发数，避免打爆服务器。

import json from concurrent.futures import ThreadPoolExecutor, as_completed from crawler.fetcher import PageFetcher from crawler.parser import VideoLinkParser from crawler.cleaner import LinkCleaner def process_one(url): fetcher = PageFetcher() html, ok = fetcher.fetch_page(url) if not ok: return {"url": url, "status": "fail", "links": []} raw_links = VideoLinkParser(url).parse(html) clean_links = LinkCleaner.clean(raw_links) fetcher.close() return {"url": url, "status": "success", "links": clean_links} def batch_process(urls, max_workers=4): results = [] with ThreadPoolExecutor(max_workers=max_workers) as executor: future_map = {executor.submit(process_one, url): url for url in urls} for future in as_completed(future_map): url = future_map[future] try: result = future.result() results.append(result) print(f"完成: {url}") except Exception as e: print(f"失败: {url}, 错误: {e}") results.append({"url": url, "status": "error", "links": []}) return results if __name__ == "__main__": urls = [ "https://example.com/video/1", "https://example.com/video/2", "https://example.com/video/3", ] output_path = "outputs/batch_result.json" results = batch_process(urls, max_workers=3) with open(output_path, "w", encoding="utf-8") as f: json.dump(results, f, ensure_ascii=False, indent=2) print(f"批量结果已写入 {output_path}")

并发数建议从 3 开始，不要一开始就设 20。对目标服务器友好一点。

方案二：基于文件队列

如果你的任务是定时增量抓取，可以维护一个待处理队列文件。每次启动时读取，成功后将 URL 移到已完成列表，失败记录到错误日志。实现不复杂，但更实用。

批量任务必须加日志。至少打印每个 URL 的状态，方便定位失败原因。更完整的做法是把日志写入文件：

python batch_process.py > logs/batch.log 2>&1

6.4 失败重试建议

• 网络超时可重试 2~3 次，间隔递增。
• 页面返回 5xx，等待 5 秒再重试。
• 返回 404，不要重试，直接标记失败。
• 所有重试次数耗尽后，把 URL 写入failed.log，方便下次重新处理。

7. 资源占用与性能观察

7.1 如何观察资源占用

命令行运行时，可以用系统自带工具观察：Windows 的任务管理器，Linux 的htop或free -m。API 服务运行时，观察 Python 进程的 RSS 内存。

没有实际运行数据时不编造数字。你可以用下面脚本快速看内存：

import os import psutil process = psutil.Process(os.getpid()) print(process.memory_info().rss / 1024 / 1024, "MB")

需要安装psutil：

pip install psutil

7.2 影响内存和 CPU 的因素

• HTML 页面大小：大页面解析耗 CPU。
• BeautifulSoup 解析器：lxml 比 html.parser 快，但都要占用内存。
• 并发线程数：线程越多，内存占用越高。
• 正则匹配范围：正则写得不好可能出现灾难性回溯，CPU 飙高。
• 输出结果大小：如果 links 很多，构建 JSON 会占用内存。

7.3 如何降低资源占用

• 不要一次性加载超大 HTML，可以用流式方式读取前多少 KB（除非必须完整解析）。
• 控制并发数在 3~5。
• 每次抓完关闭 Session，减少连接占用。
• 结果及时写入文件，不要全部攒在列表里一次性 dump。
• 使用gzip请求头，减少传输体积。

7.4 如何避免端口冲突和进程残留

API 服务启动前检查端口：

# Linux netstat -tlnp | grep 8000 # Windows netstat -ano | findstr 8000

如果端口被占用，换一个端口，或者用--port参数动态指定。

进程残留会导致端口一直占用，可用：

# Linux pkill -f "python api/server.py" # Windows taskkill /F /IM python.exe

不过taskkill /F /IM python.exe会把所有 Python 进程杀掉，使用时要确认机器上没有其他重要任务。

8. 常见问题与排查方法

9. 最佳实践与使用建议

9.1 第一次先小参数测试

不要一上来跑 100 个 URL。先用 3~5 个 URL 验证解析规则是否准确，确认输出符合预期后，再扩大范围。这样可以避免大量无效请求浪费资源。

9.2 保留一套最小可运行配置

把项目里最核心的抓取、解析、清洗逻辑做成一个crawler包，不依赖 Flask。这样即使没有 API 服务，也能通过命令行跑批量任务。最小配置遵循“能跑不碎”的原则。

9.3 分目录管理文件

• inputs/只放待处理的 URL 列表。
• outputs/只放结果文件。
• logs/只放运行日志。
• models/或config/放自定义规则。

这样可以避免输入输出混在一起，后续做定时任务也方便。

9.4 批量任务要加日志和失败重试

日志里记录时间、URL、状态。失败重试的间隔要递增，第一次等 1 秒，第二次 3 秒，第三次 5 秒。不要无限重试，三次即可。

9.5 接口服务要限制访问范围

如果 API 服务需要对外开放，建议：

• 只监听127.0.0.1，不走公网。
• 加简单鉴权 Token。
• 限制请求频率。

下面给一个带请求频率限制的 Flask 示例思路：

from flask import Flask, request, jsonify from functools import wraps import time app = Flask(__name__) # 简单的请求计数 _requests = {} def rate_limit(max_requests=10, per_seconds=60): def decorator(func): @wraps(func) def wrapper(*args, **kwargs): client_ip = request.remote_addr now = time.time() if client_ip not in _requests: _requests[client_ip] = [] _requests[client_ip] = [t for t in _requests[client_ip] if now - t < per_seconds] if len(_requests[client_ip]) >= max_requests: return jsonify({"code": 429, "message": "请求过快"}), 429 _requests[client_ip].append(now) return func(*args, **kwargs) return wrapper return decorator @app.route("/extract", methods=["POST"]) @rate_limit(max_requests=5, per_seconds=10) def extract(): # ...省略 pass

这段代码只是演示思路，生产环境建议用 Redis 或更成熟的限流方案。

9.6 涉及人脸、声音、版权素材时必须确认授权

爬虫拿到的不只是 URL，还可能是包含肖像权、隐私或版权的内容。即使是技术验证，也不能随意把抓取的链接公开分享出去。做内容分析时，务必对用户生成内容保持敏感，必要时直接丢弃相关字段。

9.7 发布或商用前要做效果复核

自动化提取的链接可能包含失效地址、错误解析结果。正式使用前，随机抽 10 条链接人工验证有效性。如果发现大量无效结果，要回头调整解析规则，而不是一直扩大抓取范围。

10. 总结与下一步

这个 Python 视频链接爬虫项目最值得尝试的点在于：它把“页面抓取 - 链接解析 - 清洗 - 输出”这个流程拆成了低耦合模块，你可以很快扩展到其他类型的资源提取场景，比如图片链接、文档下载链接。

最先应该验证的功能是：找一个公开且允许抓取的页面，测试main.py --url能否正确输出视频地址。只要这一步跑通，整个项目的主干就通了。接下来再补批量任务和 API 服务，完全看你业务需要。

最容易踩的坑有两个：一是目标页面是动态渲染，只靠 requests 拿不到链接；二是清洗规则不严，导致输出结果混入大量非视频地址。遇到这两个问题，先打印原始 HTML，别急着改正则。

后续可以继续扩展的方向：结合 Playwright 处理动态渲染页面；加入 Redis 队列做分布式批量任务；把输出结果同步到数据库；做一个简单的可视化界面；或者配合定时任务，定期检查链接是否失效。

建议收藏备用。下次再遇到“提取网页里的视频地址”这种需求，直接拿这套模块改一改就能用。如果你已经跑通了基础流程，再上手 API 和批量任务就会非常快。