Hướng dẫn toàn diện: Sử dụng Proxy với Python requests và Selenium để thu thập dữ liệu hiệu quả

29 tháng 4, 2026

Trong thế giới kỹ thuật số ngày nay, việc truy cập, thu thập và phân tích dữ liệu từ web là một phần không thể thiếu đối với nhiều doanh nghiệp, nhà phát triển và cá nhân. Tuy nhiên, các trang web ngày càng áp dụng nhiều biện pháp để ngăn chặn các hoạt động thu thập dữ liệu tự động (web scraping), từ việc giới hạn tốc độ truy cập đến chặn địa chỉ IP. Đây là lúc proxy trở thành một công cụ không thể thiếu.

Tại NetProxy.io, chúng tôi hiểu rõ tầm quan trọng của việc có một giải pháp proxy đáng tin cậy. Bài viết này sẽ cung cấp một hướng dẫn toàn diện về cách tích hợp và sử dụng proxy một cách hiệu quả với hai thư viện Python phổ biến nhất cho tác vụ web: `requests` và `Selenium`.

Tại sao bạn cần sử dụng Proxy trong các tác vụ web?

Trước khi đi sâu vào kỹ thuật, hãy cùng điểm lại những lý do chính khiến proxy trở thành công cụ đắc lực:

Ẩn danh và Bảo mật: Proxy che giấu địa chỉ IP thực của bạn, giúp bạn duyệt web và thu thập dữ liệu một cách ẩn danh, bảo vệ quyền riêng tư và giảm thiểu rủi ro bị theo dõi.
Bỏ chặn giới hạn địa lý: Truy cập nội dung hoặc dịch vụ bị giới hạn tại một khu vực địa lý nhất định bằng cách sử dụng proxy có IP từ quốc gia đó.
Web Scraping và Thu thập dữ liệu: Đây là ứng dụng phổ biến nhất. Các trang web thường chặn IP khi phát hiện các yêu cầu quá nhanh hoặc lặp đi lặp lại từ cùng một địa chỉ IP. Proxy, đặc biệt là proxy xoay vòng, giúp phân tán các yêu cầu qua nhiều IP khác nhau, tránh bị chặn và cho phép thu thập dữ liệu quy mô lớn.
Kiểm thử ứng dụng: Kiểm tra cách ứng dụng hoặc trang web của bạn hoạt động từ các vị trí địa lý khác nhau.
Cải thiện hiệu suất (Cache): Một số proxy có thể lưu trữ bộ nhớ đệm (cache) của các trang web đã truy cập, giúp tăng tốc độ tải trang cho các lần truy cập sau. (Tuy nhiên, đối với scraping, chúng ta thường cần dữ liệu mới nhất).

Sử dụng Proxy với thư viện `requests` trong Python

Thư viện `requests` là một thư viện HTTP mạnh mẽ và thân thiện với người dùng trong Python, lý tưởng cho việc gửi các yêu cầu HTTP/HTTPS đơn giản.

Cài đặt thư viện `requests`

Nếu bạn chưa có, hãy cài đặt `requests` bằng pip:

```bash pip install requests ```

Cấu hình Proxy cơ bản với `requests`

Để sử dụng proxy với `requests`, bạn chỉ cần truyền một từ điển (dictionary) chứa thông tin proxy vào tham số `proxies` của hàm `requests.get()` hoặc `requests.post()`.

```python import requests

# Cấu hình proxy HTTP và HTTPS proxies = { "http": "http://IP_CUA_PROXY:PORT", "https": "http://IP_CUA_PROXY:PORT", # Nếu bạn có proxy SOCKS, cấu hình như sau: # "http": "socks5://IP_CUA_PROXY:PORT", # "https": "socks5://IP_CUA_PROXY:PORT", }

url = "http://httpbin.org/ip" # Trang web để kiểm tra địa chỉ IP hiện tại

try: response = requests.get(url, proxies=proxies, timeout=10) response.raise_for_status() # Kiểm tra lỗi HTTP print("Địa chỉ IP thực tế theo trang web:", response.json()['origin']) except requests.exceptions.RequestException as e: print(f"Lỗi khi sử dụng proxy: {e}") ```

Giải thích:

`proxies`: Một từ điển ánh xạ giao thức (`http`, `https`) tới địa chỉ proxy.
`http://IP_CUA_PROXY:PORT`: Thay thế bằng địa chỉ IP và cổng của proxy bạn đang sử dụng. NetProxy.io cung cấp các địa chỉ này trong bảng điều khiển của bạn.
`timeout`: Rất quan trọng khi sử dụng proxy để tránh treo chương trình nếu proxy không phản hồi.
`httpbin.org/ip`: Một dịch vụ tuyệt vời để kiểm tra xem proxy của bạn có hoạt động và địa chỉ IP nào đang được hiển thị.

Proxy có xác thực (Authentication)

Nhiều proxy chất lượng cao yêu cầu xác thực bằng tên người dùng và mật khẩu. Với `requests`, bạn có thể tích hợp thông tin xác thực trực tiếp vào URL proxy:

```python import requests

# Cấu hình proxy với xác thực (username:password) username = "YOUR_USERNAME" password = "YOUR_PASSWORD" proxy_ip = "IP_CUA_PROXY" proxy_port = "PORT"

proxies_auth = { "http": f"http://{username}:{password}@{proxy_ip}:{proxy_port}", "https": f"http://{username}:{password}@{proxy_ip}:{proxy_port}", }

url = "http://httpbin.org/ip"

try: response = requests.get(url, proxies=proxies_auth, timeout=10) response.raise_for_status() print("Địa chỉ IP thực tế (có xác thực):", response.json()['origin']) except requests.exceptions.RequestException as e: print(f"Lỗi khi sử dụng proxy có xác thực: {e}") ```

Lưu ý an toàn: Không nên mã hóa cứng tên người dùng và mật khẩu trong mã nguồn của bạn. Thay vào đó, hãy sử dụng biến môi trường hoặc các công cụ quản lý bí mật.

Xoay vòng Proxy (Proxy Rotation) với `requests`

Để tránh bị chặn khi thu thập dữ liệu quy mô lớn, việc xoay vòng proxy là cực kỳ quan trọng. Bạn có thể tạo một danh sách các proxy và chọn ngẫu nhiên một proxy cho mỗi yêu cầu hoặc sau một số lượng yêu cầu nhất định.

```python import requests import random import time

# Danh sách các proxy của bạn (có thể lấy từ NetProxy.io) # Cấu trúc: "http://[username:password@]ip:port" list_of_proxies = [ "http://user1:pass1@proxy1.netproxy.io:8000", "http://user2:pass2@proxy2.netproxy.io:8000", "http://user3:pass3@proxy3.netproxy.io:8000", # ... thêm nhiều proxy khác ]

url = "http://httpbin.org/ip"

def get_random_proxy(): return random.choice(list_of_proxies)

num_requests = 5 for i in range(num_requests): current_proxy = get_random_proxy() proxies_config = { "http": current_proxy, "https": current_proxy, }

try: print(f"Thử truy cập lần {i+1} với proxy: {current_proxy}") response = requests.get(url, proxies=proxies_config, timeout=15) response.raise_for_status() print(" Địa chỉ IP:", response.json()['origin']) except requests.exceptions.RequestException as e: print(f" Lỗi với proxy {current_proxy}: {e}")

time.sleep(random.uniform(1, 3)) # Đợi ngẫu nhiên giữa các yêu cầu ```

Mẹo: Để có hiệu quả tối ưu, bạn nên sử dụng một pool proxy lớn và chất lượng cao từ NetProxy.io. Chúng tôi cung cấp các proxy dân cư (residential proxies) với khả năng xoay vòng IP tự động, giúp bạn dễ dàng quản lý mà không cần phải tự mình triển khai logic phức tạp.

Sử dụng Proxy với `Selenium` trong Python

`Selenium` là một công cụ mạnh mẽ để tự động hóa trình duyệt, rất cần thiết khi bạn cần tương tác với các trang web sử dụng JavaScript để tải nội dung động.

Cài đặt `Selenium` và WebDriver

Đầu tiên, bạn cần cài đặt `Selenium` và tải xuống WebDriver cho trình duyệt bạn muốn sử dụng (ví dụ: Chrome, Firefox).

```bash pip install selenium ```

Tải WebDriver:

Chrome: Tải `chromedriver` từ https://chromedriver.chromium.org/ (chọn phiên bản phù hợp với trình duyệt Chrome của bạn).
Firefox: Tải `geckodriver` từ https://github.com/mozilla/geckodriver/releases.

Đặt tệp WebDriver đã tải xuống vào một thư mục trong biến môi trường PATH của bạn, hoặc chỉ định đường dẫn đầy đủ đến nó trong mã.

Cấu hình Proxy với Chrome

Để sử dụng proxy với Chrome trong Selenium, bạn cần cấu hình `ChromeOptions`.

```python from selenium import webdriver from selenium.webdriver.chrome.options import Options from selenium.webdriver.chrome.service import Service import time

# Đường dẫn đến chromedriver của bạn (hoặc đảm bảo nó nằm trong PATH) # service = Service(executable_path='/path/to/chromedriver') # Bỏ comment nếu cần

proxy_ip_port = "IP_CUA_PROXY:PORT" # Thay thế bằng IP và Port của proxy bạn

chrome_options = Options() # Thêm đối số proxy vào ChromeOptions chrome_options.add_argument(f"--proxy-server={proxy_ip_port}")

# Để chạy Chrome ở chế độ headless (không hiển thị giao diện) # chrome_options.add_argument("--headless")

driver = webdriver.Chrome(options=chrome_options) # , service=service)

try: driver.get("http://httpbin.org/ip") time.sleep(3) # Đợi trang tải xong print("Địa chỉ IP hiển thị bởi Selenium (Chrome):") print(driver.find_element("css selector", "pre").text) # Lấy nội dung pre tag chứa IP except Exception as e: print(f"Lỗi khi sử dụng Selenium với Chrome và proxy: {e}") finally: driver.quit() ```

Cấu hình Proxy với Firefox

Tương tự như Chrome, bạn sử dụng `FirefoxOptions` để thiết lập proxy.

```python from selenium import webdriver from selenium.webdriver.firefox.options import Options as FirefoxOptions from selenium.webdriver.firefox.service import Service as FirefoxService import time

# Đường dẫn đến geckodriver của bạn (hoặc đảm bảo nó nằm trong PATH) # service = FirefoxService(executable_path='/path/to/geckodriver') # Bỏ comment nếu cần

proxy_ip = "IP_CUA_PROXY" proxy_port = PORT # Là số nguyên, không phải chuỗi

firefox_options = FirefoxOptions() firefox_options.set_preference("network.proxy.type", 1) # 1 = manual proxy settings firefox_options.set_preference("network.proxy.http", proxy_ip) firefox_options.set_preference("network.proxy.http_port", proxy_port) firefox_options.set_preference("network.proxy.ssl", proxy_ip) firefox_options.set_preference("network.proxy.ssl_port", proxy_port) firefox_options.set_preference("network.proxy.socks", proxy_ip) firefox_options.set_preference("network.proxy.socks_port", proxy_port) firefox_options.set_preference("network.proxy.socks_version", 5) # Hoặc 4, tùy loại proxy firefox_options.set_preference("network.proxy.ftp", proxy_ip) firefox_options.set_preference("network.proxy.ftp_port", proxy_port) firefox_options.set_preference("network.proxy.no_proxies_on", "") # Không bỏ qua proxy cho bất kỳ địa chỉ nào

# Để chạy Firefox ở chế độ headless # firefox_options.add_argument("--headless")

driver = webdriver.Firefox(options=firefox_options) # , service=service)

try: driver.get("http://httpbin.org/ip") time.sleep(3) print("Địa chỉ IP hiển thị bởi Selenium (Firefox):") print(driver.find_element("css selector", "pre").text) except Exception as e: print(f"Lỗi khi sử dụng Selenium với Firefox và proxy: {e}") finally: driver.quit() ```

Proxy có xác thực (Authentication) với Selenium

Việc xử lý proxy có xác thực trong Selenium phức tạp hơn so với `requests` vì trình duyệt cần hiển thị hộp thoại xác thực. Có một số cách tiếp cận:

#### 1. Sử dụng tiện ích mở rộng (Extension) của trình duyệt (Chrome)

Bạn có thể tạo một tiện ích mở rộng Chrome nhỏ để xử lý xác thực proxy. Đây là một phương pháp hiệu quả nhưng đòi hỏi một chút kiến thức về JavaScript và Chrome Extensions.

Bước 1: Tạo tệp `manifest.json`

```json { "version": "1.0.0", "manifest_version": 2, "name": "Proxy Auth", "permissions": [ "proxy", "tabs", "unlimitedStorage", "storage", "<all_urls>", "webRequest", "webRequestBlocking" ], "background": { "scripts": ["background.js"] }, "minimum_chrome_version":"22.0.0" } ```

Bước 2: Tạo tệp `background.js`

```javascript var config = { mode: "fixed_servers", rules: { singleProxy: { scheme: "http", // hoặc "https" hoặc "socks5" host: "IP_CUA_PROXY", port: parseInt(PORT) }, bypassList: ["<local-urls>"] } };

chrome.proxy.settings.set({value: config, scope: "regular"}, function() {});

function callbackFn(details) { return { authCredentials: { username: "YOUR_USERNAME", password: "YOUR_PASSWORD" } }; }

chrome.webRequest.onAuthRequired.addListener( callbackFn, {urls: ["<all_urls>"]}, ['blocking'] ); ```

Bước 3: Tải tiện ích mở rộng vào Selenium

```python from selenium import webdriver from selenium.webdriver.chrome.options import Options import os import zipfile

# Thông tin proxy PROXY_HOST = "IP_CUA_PROXY" PROXY_PORT = PORT PROXY_USER = "YOUR_USERNAME" PROXY_PASS = "YOUR_PASSWORD"

# Tạo thư mục tạm thời cho extension plugin_dir = 'proxy_auth_plugin' if not os.path.exists(plugin_dir): os.makedirs(plugin_dir)

# Tạo tệp manifest.json with open(os.path.join(plugin_dir, 'manifest.json'), 'w') as f: f.write(f''' {{ "version": "1.0.0", "manifest_version": 2, "name": "Proxy Auth", "permissions": [ "proxy", "tabs", "unlimitedStorage", "storage", "<all_urls>", "webRequest", "webRequestBlocking" ], "background": {{ "scripts": ["background.js"] }}, "minimum_chrome_version":"22.0.0" }} ''')

# Tạo tệp background.js with open(os.path.join(plugin_dir, 'background.js'), 'w') as f: f.write(f''' var config = {{ mode: "fixed_servers", rules: {{ singleProxy: {{ scheme: "http", host: "{PROXY_HOST}", port: parseInt({PROXY_PORT}) }}, bypassList: ["<local-urls>"] }} }};

chrome.proxy.settings.set({{value: config, scope: "regular"}}, function() {{}});

function callbackFn(details) {{ return {{ authCredentials: {{ username: "{PROXY_USER}", password: "{PROXY_PASS}" }} }}; }}

chrome.webRequest.onAuthRequired.addListener( callbackFn, {{urls: ["<all_urls>"]}}, ['blocking'] ); ''')

# Nén thư mục plugin thành .zip (hoặc bạn có thể load trực tiếp thư mục) # Hàm này dùng để nén folder def make_zipfile(output_filename, source_dir): relroot = os.path.abspath(os.path.join(source_dir, os.pardir)) with zipfile.ZipFile(output_filename, "w", zipfile.ZIP_DEFLATED) as zipf: for root, dirs, files in os.walk(source_dir): zipf.write(root, os.path.relpath(root, relroot)) for file in files: filename = os.path.join(root, file) if os.path.isfile(filename): zipf.write(filename, os.path.relpath(filename, relroot))

zip_path = os.path.join(plugin_dir, 'proxy_auth_plugin.zip') make_zipfile(zip_path, plugin_dir)

chrome_options = Options() chrome_options.add_extension(zip_path) # Thêm tiện ích mở rộng đã nén

driver = webdriver.Chrome(options=chrome_options)

try: driver.get("http://httpbin.org/ip") time.sleep(5) print("Địa chỉ IP hiển thị bởi Selenium (Chrome với Auth Extension):") print(driver.find_element("css selector", "pre").text) except Exception as e: print(f"Lỗi khi sử dụng Selenium với Chrome và proxy có xác thực: {e}") finally: driver.quit() # Dọn dẹp tệp tạm thời # import shutil # shutil.rmtree(plugin_dir) ```

#### 2. Sử dụng thư viện `selenium-wire` (Khuyên dùng)

`selenium-wire` là một wrapper cho Selenium WebDriver, cho phép bạn kiểm soát các yêu cầu mạng được thực hiện bởi trình duyệt. Nó đặc biệt hữu ích cho các proxy có xác thực và giám sát yêu cầu.

```bash pip install selenium-wire ```

```python from seleniumwire import webdriver import time

# Cấu hình proxy có xác thực proxy_options = { 'proxy': { 'http': 'http://YOUR_USERNAME:YOUR_PASSWORD@IP_CUA_PROXY:PORT', 'https': 'https://YOUR_USERNAME:YOUR_PASSWORD@IP_CUA_PROXY:PORT', 'no_proxy': 'localhost,127.0.0.1' # Bỏ qua proxy cho các địa chỉ cục bộ } }

# Khởi tạo WebDriver với proxy_options # Đối với Chrome: driver = webdriver.Chrome(seleniumwire_options=proxy_options)

# Đối với Firefox: # driver = webdriver.Firefox(seleniumwire_options=proxy_options)

try: driver.get("http://httpbin.org/ip") time.sleep(5) print("Địa chỉ IP hiển thị bởi Selenium-Wire:") print(driver.find_element("css selector", "pre").text) except Exception as e: print(f"Lỗi khi sử dụng Selenium-Wire với proxy có xác thực: {e}") finally: driver.quit() ```

`selenium-wire` là giải pháp sạch sẽ và dễ dàng nhất để xử lý proxy có xác thực với Selenium, và nó hoạt động tốt cho cả Chrome và Firefox.

Xoay vòng Proxy với Selenium

Xoay vòng proxy với Selenium phức tạp hơn so với `requests` vì mỗi lần bạn thay đổi proxy, bạn thường phải khởi động lại trình duyệt hoặc cấu hình lại nó, điều này có thể tốn thời gian.

Cách đơn giản: Đóng trình duyệt hiện tại và mở một phiên bản mới với proxy khác.

```python from selenium import webdriver from selenium.webdriver.chrome.options import Options import random import time

list_of_proxies = [ "IP1:PORT1", "IP2:PORT2", "user3:pass3@IP3:PORT3", # Dùng string "user:pass@ip:port" cho selenium-wire # Thêm proxy từ NetProxy.io của bạn ]

def get_webdriver_with_proxy(proxy_str): chrome_options = Options()

# Đối với proxy không xác thực (dạng IP:PORT) if "@" not in proxy_str: chrome_options.add_argument(f"--proxy-server={proxy_str}") return webdriver.Chrome(options=chrome_options) else: # Đối với proxy có xác thực, nên dùng selenium-wire # Đảm bảo bạn đã cài đặt selenium-wire from seleniumwire import webdriver as sw_webdriver proxy_options = { 'proxy': { 'http': f'http://{proxy_str}', 'https': f'https://{proxy_str}' } } return sw_webdriver.Chrome(seleniumwire_options=proxy_options)

url = "http://httpbin.org/ip" num_iterations = 3

for i in range(num_iterations): current_proxy = random.choice(list_of_proxies) print(f"Lần {i+1}: Sử dụng proxy {current_proxy}")

driver = None try: driver = get_webdriver_with_proxy(current_proxy) driver.get(url) time.sleep(5) # Đợi trang tải print(" IP hiển thị:", driver.find_element("css selector", "pre").text.strip()) except Exception as e: print(f" Lỗi với proxy {current_proxy}: {e}") finally: if driver: driver.quit() # Đóng trình duyệt để chuẩn bị cho lần tiếp theo

time.sleep(random.uniform(5, 10)) # Đợi giữa các lần thử ```

Các Mẹo và Thực tiễn tốt nhất

Chọn loại Proxy phù hợp: NetProxy.io cung cấp cả proxy dân cư (Residential Proxy) và proxy trung tâm dữ liệu (Datacenter Proxy).

Proxy dân cư: Có nguồn gốc từ các địa chỉ IP thực của người dùng thông thường. Chúng cực kỳ khó bị phát hiện và chặn, lý tưởng cho các tác vụ nhạy cảm như scraping mạng xã hội, kiểm tra quảng cáo, so sánh giá. Proxy trung tâm dữ liệu: Tốc độ nhanh và chi phí thấp hơn, phù hợp cho các tác vụ ít nhạy cảm hơn hoặc khi bạn cần tốc độ cao cho một lượng lớn dữ liệu.

Xử lý lỗi mạnh mẽ: Luôn sử dụng `try-except` để bắt các ngoại lệ liên quan đến mạng hoặc proxy. Thực hiện logic thử lại (retry logic) khi một proxy thất bại hoặc yêu cầu timeout.
Thiết lập User-Agent: Để trông giống như một trình duyệt thực, luôn đặt header `User-Agent` hợp lý trong `requests` hoặc sử dụng Selenium (vì Selenium tự động đặt `User-Agent` của trình duyệt).
Thêm độ trễ (Delay): Tránh gửi quá nhiều yêu cầu quá nhanh. Sử dụng `time.sleep()` với các giá trị ngẫu nhiên để mô phỏng hành vi của con người.
Sử dụng Headless Browser (Selenium): Khi bạn không cần xem giao diện trình duyệt, chạy Selenium ở chế độ headless (`chrome_options.add_argument("--headless")`) sẽ tiết kiệm tài nguyên và tăng tốc độ.
Kiểm tra Proxy thường xuyên: Đảm bảo các proxy bạn đang sử dụng còn hoạt động và có tốc độ tốt.
Quản lý Proxy: Đối với các dự án lớn, hãy xem xét việc xây dựng một hệ thống quản lý proxy đơn giản để theo dõi trạng thái, thời gian hoạt động và hiệu suất của từng proxy.

Tại sao chọn NetProxy.io cho nhu cầu Proxy của bạn?

Việc có một hướng dẫn chi tiết là một chuyện, nhưng việc có các công cụ chất lượng cao để thực hiện nó là một chuyện khác. Tại NetProxy.io, chúng tôi tự hào cung cấp các giải pháp proxy hàng đầu tại Việt Nam, được thiết kế để đáp ứng mọi nhu cầu của bạn:

Proxy chất lượng cao: Chúng tôi cung cấp cả proxy dân cư và trung tâm dữ liệu với hiệu suất ổn định và độ tin cậy cao.
Tốc độ và bảo mật: Cơ sở hạ tầng của chúng tôi được tối ưu hóa để đảm bảo tốc độ nhanh chóng và bảo mật dữ liệu tuyệt đối.
Dễ dàng tích hợp: Proxy của chúng tôi tương thích hoàn toàn với Python `requests`, `Selenium` và hầu hết các công cụ, thư viện web khác.
Hỗ trợ khách hàng tận tâm: Đội ngũ hỗ trợ của chúng tôi luôn sẵn sàng giải đáp mọi thắc mắc và hỗ trợ bạn trong quá trình sử dụng.
Giá cả cạnh tranh: Các gói dịch vụ linh hoạt, phù hợp với mọi quy mô từ cá nhân đến doanh nghiệp lớn.

Kết luận

Việc nắm vững cách sử dụng proxy với Python `requests` và `Selenium` là một kỹ năng thiết yếu cho bất kỳ ai làm việc với dữ liệu web. Bằng cách tích hợp proxy một cách thông minh, bạn có thể vượt qua các rào cản, duy trì ẩn danh và thu thập dữ liệu hiệu quả hơn bao giờ hết.

NetProxy.io cam kết cung cấp cho bạn những proxy tốt nhất để bạn có thể thực hiện các dự án của mình một cách suôn sẻ và thành công. Hãy truy cập NetProxy.io ngay hôm nay để khám phá các gói proxy của chúng tôi và bắt đầu hành trình thu thập dữ liệu web của bạn!