# พร็อกซีพร็อกซีเรซิเดนเชียลสลับ IP ใน Python: requests, httpx และ aiohttp

> พร็อกซีพร็อกซีเรซิเดนเชียลสลับ IP ใน Python: requests พร้อม retries, httpx แบบ sync และ async, aiohttp, session ยึดติด และนับจำนวนไบต์ โค้ดที่ตรวจสอบไวยากรณ์แล้ว

- URL: https://crawlrelay.com/th/docs/python/
- อัปเดตล่าสุด: 2026-10-13
- Publisher: CrawlRelay (https://crawlrelay.com)

รูปแบบการใช้งานสายผลิต: retries ที่เคารพ Retry-After, IP ใหม่ต่อคำขอ หรือ IP เดียวต่อกระบวนการ, การทำงานพร้อมกันแบบ per-host ใน asyncio, และจำนวนไบต์ที่แต่ละหน้าใช้จริง

**คำตอบด่วน — ฉันจะใช้พร็อกซีเรซิเดนเชียลสลับ IP ใน Python อย่างไร?**

ส่ง `http://USERNAME:PASSWORD@gw.crawlrelay.com:7777` เป็นพร็อกซีสำหรับทั้ง `http` และ `https` ใน requests, เป็น `proxy=` ใน httpx 0.26+ หรือเป็น `proxy=` ต่อคำขอใน aiohttp **พร็อกซีเรซิเดนเชียลCrawlRelay** สลับบนการเชื่อมต่อใหม่ทุกครั้งและยังคงยึดติดกับ `-session-<id>` ในชื่อผู้ใช้ ค่าใช้จ่าย US$1.50 ต่อ 1 GB และ US$0.50/GB จาก 50 GB จ่ายด้วยคริปโต, ไม่ต้อง KYC

## การตั้งค่า Python แบบย่อ

| คุณลักษณะ | ค่า |
| --- | --- |
| requests | `proxies={"http": url, "https": url}`; retries ผ่าน urllib3 `Retry` |
| httpx | `httpx.Client(proxy=url)`; อาร์กิวเมนต์ `proxies=` แบบเก่าถูกลบใน httpx 0.28 |
| aiohttp | `session.get(url, proxy="http://USER:PASS@host:port")`, ใส่ข้อมูลรับรองใน URL ของพร็อกซี |
| SOCKS5 | `pip install "requests[socks]"` หรือ `httpx[socks]`, แล้ว `socks5h://` ที่พอร์ต 7778 |
| IP ใหม่ทุกคำขอ | ปิด keep-alive: `Connection: close`, `max_keepalive_connections=0` หรือ `force_close=True` |
| ใช้ IP เดียวต่อกระบวนการ | `-session-<id>-ttl-<minutes>` ในชื่อผู้ใช้, นานสูงสุด 30 นาที |
| โครงสร้าง URL ของพร็อกซี | ใช้ `http://` เสมอสำหรับพอร์ต HTTP แม้แต่เว็บ HTTPS |

## ฉันจะใช้พร็อกซีกับ requests ที่มี retries เคารพ Retry-After ได้อย่างไร?

ติดตั้ง `HTTPAdapter` ด้วย urllib3's `Retry` บน `Session` มันจะทำ retries กับข้อผิดพลาดการเชื่อมต่อและสถานะที่คุณระบุ, รอด้วยการหน่วงแบบ exponential และเคารพ header `Retry-After` ที่เว็บไซต์ส่งกับสถานะ 429 และ 503 ตั้ง `trust_env = False` เพื่อไม่ให้ตัวแปร `HTTPS_PROXY` ที่เหลือมาบันทึกพร็อกซีของคุณ

*requests + urllib3 Retry*

```python
import os

import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

USER = os.environ.get("CRAWLRELAY_USER", "USERNAME-country-us")
PASSWORD = os.environ.get("CRAWLRELAY_PASSWORD", "PASSWORD")
PROXY = "http://%s:%s@gw.crawlrelay.com:7777" % (USER, PASSWORD)

retry = Retry(
    total=4,
    connect=2,
    backoff_factor=1.0,  # waits of 0 s, 2 s, 4 s, 8 s (Retry-After wins on 429/503)
    status_forcelist=(429, 502, 503, 504),
    allowed_methods=frozenset({"GET", "HEAD"}),
    respect_retry_after_header=True,
)

session = requests.Session()
session.trust_env = False  # ignore HTTP(S)_PROXY from the environment
session.mount("http://", HTTPAdapter(max_retries=retry))
session.mount("https://", HTTPAdapter(max_retries=retry))
session.proxies = {"http": PROXY, "https": PROXY}
session.headers["User-Agent"] = "ExampleCrawler/1.0 (+https://example.com/crawler-info)"
session.headers["Connection"] = "close"  # new connection per request, so usually a new exit IP

r = session.get("https://api.ipify.org", timeout=(10, 30))
print(r.status_code, r.text)
```

## ฉันจะสร้าง URL พร็อกซีเฉพาะเป้าหมายได้อย่างปลอดภัยอย่างไร?

สร้างชื่อผู้ใช้ในฟังก์ชันเดียวและตรวจสอบความถูกต้อง งานพิมพ์ผิดในรหัสประเทศหรืออักขระที่ไม่ได้เข้ารหัสในรหัสผ่านจะสร้างข้อผิดพลาด [407](https://crawlrelay.com/th/docs/errors/407-proxy-authentication-required/) ที่ดูเหมือนปัญหาข้อมูลรับรอง ผู้ช่วยด้านล่างรักษาลำดับที่กำหนดไว้ (`USERNAME-country-{cc}-state-{state}-city-{city}-zip-{zip}-asn-{asn}-session-{id}-ttl-{minutes}`), ปฏิเสธคีย์ที่ไม่รู้จัก และเข้ารหัส URL ของข้อมูลรับรองทั้งสอง

*ส่วนสร้างชื่อผู้ใช้และ URL พร็อกซี*

```python
import re
from urllib.parse import quote

ORDER = ("country", "state", "city", "zip", "asn", "session", "ttl")
VALUE = re.compile(r"^[a-z0-9_]+$")


def build_username(base, **params):
    """build_username("USERNAME", country="us", city="new_york", session="job1", ttl=30)"""
    parts = [base]
    for key in ORDER:
        value = params.pop(key, None)
        if value is None:
            continue
        value = str(value).lower()
        if not VALUE.match(value):
            raise ValueError("bad value for %s: %r" % (key, value))
        if key == "ttl" and not 1 <= int(value) <= 30:
            raise ValueError("ttl must be 1 to 30 minutes")
        parts.append("%s-%s" % (key, value))
    if params:
        raise ValueError("unknown parameters: %s" % ", ".join(sorted(params)))
    return "-".join(parts)


def proxy_url(username, password, socks=False):
    scheme, port = ("socks5h", 7778) if socks else ("http", 7777)
    return "%s://%s:%s@gw.crawlrelay.com:%d" % (
        scheme, quote(username, safe=""), quote(password, safe=""), port)


print(proxy_url(build_username("USERNAME", country="us", state="ny", city="new_york", session="job1", ttl=20), "p@ss:word"))
```

## ฉันจะได้ IP ใหม่ในทุกคำขอด้วย httpx ได้อย่างไร?

ปิด keep-alive httpx จะรวบรวมการเชื่อมต่อโดยค่าเริ่มต้นและการเชื่อมต่อที่ใช้ซ้ำจะรักษา IP ไว้ ด้วย `max_keepalive_connections=0`, แต่ละคำขอจะเปิดการเชื่อมต่อใหม่ไปยังเกตเวย์และมักออกจากพร็อกซีเรซิเดนเชียล IP ต่างกัน `num_bytes_downloaded` ให้ข้อมูลไบต์ที่ได้รับในสาย ซึ่งใกล้เคียงกับการคิดค่าบริการทราฟฟิก

*httpx: ไลบรารีที่สลับพร็อกซี*

```python
import httpx

PROXY = "http://USERNAME-country-gb:PASSWORD@gw.crawlrelay.com:7777"

# No keep-alive: every request opens a new connection, so it usually gets a new exit IP
with httpx.Client(
    proxy=PROXY,
    timeout=httpx.Timeout(30.0, connect=10.0),
    limits=httpx.Limits(max_keepalive_connections=0),
    follow_redirects=True,
) as client:
    for _ in range(3):
        r = client.get("https://api.ipify.org")
        print(r.text, r.num_bytes_downloaded, "bytes on the wire")
```

## ฉันจะขูดเว็บพร้อมกันด้วย asyncio โดยไม่ทำร้ายเว็บเดียวได้อย่างไร?

จำกัดการทำงานพร้อมกัน **ต่อโฮสต์** ไม่ใช่แค่แบบทั่วโลก จำกัดแบบทั่วโลก 50 จะปล่อยคำขอ 50 คำขอไปยังเว็บเดียวหาก URL เรียงตามโดเมน semaphore ต่อชื่อโฮสต์จะรักษาแต่ละไซต์ในระดับที่เหมาะสมในขณะที่การขูดทั้งหมดยังเร็ว เริ่มต้นที่ 2 ถึง 4 ต่อโฮสต์และอ่าน [คู่มือ concurrency](https://crawlrelay.com/th/docs/concurrency/) ก่อนเพิ่มจำนวน

*httpx.AsyncClient กับ semaphore ต่อโฮสต์*

```python
import asyncio
from collections import defaultdict
from urllib.parse import urlsplit

import httpx

PROXY = "http://USERNAME-country-us:PASSWORD@gw.crawlrelay.com:7777"
PER_HOST = 4  # parallel requests per target host
host_slots = defaultdict(lambda: asyncio.Semaphore(PER_HOST))


async def fetch(client, url):
    async with host_slots[urlsplit(url).hostname]:
        try:
            r = await client.get(url)
            return url, r.status_code, r.num_bytes_downloaded
        except httpx.HTTPError as exc:
            return url, type(exc).__name__, 0


async def main(urls):
    limits = httpx.Limits(max_connections=50, max_keepalive_connections=0)
    timeout = httpx.Timeout(30.0, connect=10.0)
    async with httpx.AsyncClient(proxy=PROXY, limits=limits, timeout=timeout) as client:
        for result in await asyncio.gather(*(fetch(client, u) for u in urls)):
            print(*result)


asyncio.run(main(["https://example.com/", "https://example.org/", "https://example.net/"]))
```

## ฉันจะใช้พร็อกซีด้วย aiohttp ได้อย่างไร?

ส่งเกตเวย์เป็น `proxy=` ในแต่ละคำขอ โดยมีข้อมูลรับรองใน URL ของพร็อกซี แบบนี้ใช้ได้กับ aiohttp 3.x ทุกเวอร์ชันโดยไม่มีคำเตือน; `BasicAuth` และอาร์กิวเมนต์ `proxy_auth=` เลิกใช้ตั้งแต่ aiohttp 3.14 และจะถูกลบใน 4.0 `TCPConnector(force_close=True)` ปิดการเชื่อมต่อหลังตอบกลับทุกครั้ง ดังนั้นคำขอแต่ละคำขอจึงมักได้รับ IP ใหม่ หากไม่ใส่ aiohttp จะใช้การเชื่อมต่อซ้ำและคุณจะใช้ IP เดิมสักพัก

*aiohttp พร้อมข้อมูลรับรองใน URL ของพร็อกซี*

```python
import asyncio

import aiohttp

# Credentials go in the proxy URL; percent-encode a password that contains @ or :
PROXY = "http://USERNAME-country-fr:PASSWORD@gw.crawlrelay.com:7777"


async def main():
    # force_close=True: one connection per request, so each request usually gets a new exit IP
    connector = aiohttp.TCPConnector(limit=20, force_close=True)
    timeout = aiohttp.ClientTimeout(total=60, sock_connect=10)
    async with aiohttp.ClientSession(connector=connector, timeout=timeout) as session:
        for _ in range(3):
            async with session.get("https://api.ipify.org", proxy=PROXY) as resp:
                print(resp.status, await resp.text())


asyncio.run(main())
```

## ฉันจะเก็บ IP เดียวสำหรับขั้นตอนหลายขั้นตอนได้อย่างไร?

สร้าง session ID หนึ่งอันต่อกระบวนการ และใส่มันในชื่อผู้ใช้พร้อม TTL ยาวกว่ากระบวนการ Keep-alive ใช้ได้ที่นี่เพราะคุณต้องการ IP เดิม หากอุปกรณ์พร็อกซีเรซิเดนเชียลที่อยู่เบื้องหลัง session ออฟไลน์ IP อาจเปลี่ยนก่อน TTL สิ้นสุด ดังนั้นให้ตั้งให้กระบวนการเริ่มใหม่ได้จากจุดตรวจสอบล่าสุด

*session ยึดติดกับ requests*

```python
import uuid

import requests

session_id = uuid.uuid4().hex[:10]  # one ID per flow, lowercase letters and digits
user = "USERNAME-country-us-state-ca-session-%s-ttl-20" % session_id
proxy = "http://%s:PASSWORD@gw.crawlrelay.com:7777" % user

with requests.Session() as s:
    s.proxies = {"http": proxy, "https": proxy}
    first = s.get("https://api.ipify.org", timeout=(10, 30)).text
    second = s.get("https://api.ipify.org", timeout=(10, 30)).text
    print(first, second, "same exit" if first == second else "exit changed")
```

## ขูด Python ใช้ทราฟฟิกเท่าไหร่ต่อหน้า?

วัดจาก 100 หน้าเว็บจริงก่อนซื้อปริมาณ บันทึก `num_bytes_downloaded` ใน httpx หรือความยาวของเนื้อหาบีบอัดใน middleware ของคุณเองและคูณด้วยจำนวนหน้า การร้องขอ HTML เพียงอย่างเดียวมักใช้ทราฟฟิกเป็นสิบกิโลไบต์ต่อหน้า [คู่มือแบนด์วิดท์](https://crawlrelay.com/th/guides/bandwidth-calculator/) ให้ตัวเลขและราคาใน 1,000 หน้า ณ ราคา CrawlRelay

สามนิสัยลดทราฟฟิกโดยไม่เปลี่ยนผลลัพธ์ของคุณ:

- ส่ง `Accept-Encoding: gzip, br` (httpx และ requests ส่ง gzip โดยค่าเริ่มต้น) ให้หน้าถูกบีบอัด
- ดึงข้อมูล JSON ที่โหลดจากหน้าเมื่อเว็บไซต์มีเอกสารหรืออนุญาต แทนการดึง HTML ทั้งหน้า
- ข้ามหน้าที่ไม่เปลี่ยนด้วย `If-None-Match` หรือ `If-Modified-Since`: `304 Not Modified` จ่ายแค่หลักร้อยไบต์เท่านั้น

## Python และพร็อกซี: คำถาม

### requests, httpx หรือ aiohttp: ควรใช้ตัวไหนสำหรับการสแครป?

ใช้ requests สำหรับสคริปต์ง่ายๆ และการครอว์ลขนาดเล็ก ใช้ httpx เมื่อต้องการ API เดียวกันสำหรับโค้ด synchronous และ asynchronous และรองรับ HTTP/2 ผ่าน `httpx[http2]` ใช้ aiohttp สำหรับงานที่มี concurrent สูงมากใน pure asyncio สำหรับการครอว์ลที่มีการตั้งเวลางาน, กรองข้อมูลซ้ำ และ pipeline ให้ใช้ [Scrapy](https://crawlrelay.com/th/docs/scrapy/) แทนการเขียนส่วนเหล่านั้นเอง

### ทำไมฉันถึงเจอข้อผิดพลาด SSL: WRONG_VERSION_NUMBER กับพร็อกซีใน Python?

คุณอาจเขียน `https://` นำหน้าที่อยู่พร็อกซี พอร์ตเกตเวย์ 7777 ใช้ HTTP ธรรมดาและเปิดช่องเชื่อมต่อ CONNECT สำหรับไซต์ HTTPS ดังนั้น URL ของพร็อกซีจะต้องเริ่มด้วย `http://` ในทั้งคีย์ `http` และ `https` ดูรายละเอียดได้ที่ [หน้าข้อผิดพลาด](https://crawlrelay.com/th/docs/errors/ssl-wrong-version-number/)

### ฉันจะใช้พร็อกซี SOCKS5 ใน Python ได้อย่างไร?

ติดตั้งแพ็คเกจเสริม (`pip install "requests[socks]"` หรือ `pip install "httpx[socks]"`) แล้วใช้ `socks5h://USERNAME:PASSWORD@gw.crawlrelay.com:7778` คำสั่ง `h` จะส่งชื่อโฮสต์ไปยังพร็อกซี ทำให้ DNS แก้ไขที่ exit และคุณเห็นผลลัพธ์ตามภูมิภาคเหมือนกับผู้เยี่ยมชมในพื้นที่

### ทำไมพร็อกซีหมุนเวียนของฉันถึงคืนค่า IP เดิมซ้ำกันสองครั้ง?

ไคลเอนต์ของคุณใช้การเชื่อมต่อแบบรักษาสถานะเดิมอยู่ และการหมุนเวียนเกิดขึ้นต่อการเชื่อมต่อใหม่ ให้ส่ง `Connection: close` ใน requests ตั้งค่า `max_keepalive_connections=0` ใน httpx หรือใช้ `force_close=True` กับ aiohttp นอกจากนี้ตรวจสอบให้แน่ใจว่าชื่อผู้ใช้ไม่มีส่วน `session-` ซึ่งจะล็อก IP เดียวไว้โดยตั้งใจ

### ฉันจะตั้งค่า timeout สำหรับคำขอผ่านพร็อกซีอย่างไร?

ตั้งค่าไว้อย่างชัดเจน: requests ไม่มี timeout โดยค่าเริ่มต้น เวลาเชื่อมต่อประมาณ 10 วินาทีและเวลารออ่าน 30 วินาทีเหมาะสำหรับหน้า HTML; exit มือถือและเป้าหมายที่ช้าต้องการ 45 ถึง 60 วินาที ทำการลองใหม่เมื่อตรวจจับ timeout ด้วยการเชื่อมต่อใหม่แทนรอเวลายาวขึ้น ดูรายละเอียด [read timeouts](https://crawlrelay.com/th/docs/errors/read-timeout/)

### ฉันใช้พร็อกซีเหล่านี้ใน Jupyter หรือกับ pandas ได้ไหม?

ได้ ทุกสิ่งที่ใช้ requests หรือ httpx เบื้องหลังจะใช้การตั้งค่าพร็อกซีเหมือนกัน สำหรับ `pandas.read_html` หรือ `read_csv` บน URL ให้ดาวน์โหลดเนื้อหาด้วยคำขอ requests ผ่านพร็อกซีก่อน แล้วส่งข้อความหรือไบต์ให้ pandas

**รันสแครป Python ของคุณผ่าน IP แบบพร็อกซีเรซิเดนเชียล** US$1.50 สำหรับ 1 GB, US$0.50/GB ตั้งแต่ 50 GB [ดูราคา](https://crawlrelay.com/th/pricing/) · [คู่มือ Scrapy](https://crawlrelay.com/th/docs/scrapy/)

---

CrawlRelay: CrawlRelay คือพร็อกซีเรซิเดนเชียลหมุนเวียนพร้อมพร็อกซีมือถือ 4G/5G สำหรับนักพัฒนา เหมาะกับสแครปเปอร์และระบบจัดการข้อมูล AI: เติมเงินจ่ายตามการใช้งานจาก US$0.50/GB จ่ายด้วยคริปโต ไม่ต้องอัปโหลดบัตรประชาชน ไม่ต้อง KYC — ไม่ต้องใช้บัตรประชาชน ไม่ต้องถ่ายเซลฟี่ ไม่ต้องใช้เอกสาร จ่ายด้วยคริปโต