playwright-proxy-authentication 0.1.0__tar.gz

playwright_proxy_authentication-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 JiBao Proxy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

playwright_proxy_authentication-0.1.0/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: playwright-proxy-authentication
+Version: 0.1.0
+Summary: Authenticated and rotating proxies for Playwright — turn user:pass proxy URLs into Playwright's proxy dict and rotate per context.
+Author-email: JiBao Proxy <support@jibaoproxy.com>
+License: MIT
+Project-URL: Homepage, https://jibaoproxy.com
+Project-URL: Source, https://github.com/jibaoproxyofficial-pixel/playwright-proxy-authentication
+Keywords: playwright,proxy,proxy-authentication,rotating-proxy,web-scraping,browser-automation,residential-proxy
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# playwright-proxy-authentication
+
+[![PyPI version](https://img.shields.io/pypi/v/playwright-proxy-authentication.svg)](https://pypi.org/project/playwright-proxy-authentication/)
+[![Python versions](https://img.shields.io/pypi/pyversions/playwright-proxy-authentication.svg)](https://pypi.org/project/playwright-proxy-authentication/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Use **authenticated and rotating proxies with [Playwright](https://playwright.dev)** without fighting its proxy API. Turn an ordinary `scheme://user:pass@host:port` URL into the dict Playwright expects, and hand out a fresh exit IP per browser context.
+
+```bash
+pip install playwright-proxy-authentication
+```
+
+## The problem
+
+Unlike `requests` or Scrapy, Playwright **ignores credentials in a proxy URL**. This silently fails to authenticate:
+
+```python
+# ❌ username/password are dropped — you get 407 Proxy Authentication Required
+browser.new_context(proxy={"server": "http://user:pass@gw.example.com:913"})
+```
+
+Playwright wants the parts split out:
+
+```python
+# ✅ correct
+browser.new_context(proxy={
+    "server": "http://gw.example.com:913",
+    "username": "user",
+    "password": "pass",
+})
+```
+
+This package does that conversion for you, and adds per-context rotation.
+
+## Usage
+
+```python
+from playwright.sync_api import sync_playwright
+from playwright_proxy_auth import ProxyPool
+
+# A rotating residential gateway gives a new exit IP on every connection.
+pool = ProxyPool(gateway="http://USERNAME:PASSWORD@us.jibaoproxy.com:913")
+
+with sync_playwright() as p:
+    browser = p.chromium.launch(headless=True)
+    for _ in range(3):
+        context = browser.new_context(proxy=pool.get())   # fresh IP per context
+        page = context.new_page()
+        page.goto("https://httpbin.org/ip")
+        print(page.inner_text("body"))
+        context.close()
+    browser.close()
+```
+
+Static list instead of a gateway:
+
+```python
+pool = ProxyPool(proxies=[
+    "http://USERNAME:PASSWORD@proxy-a.example.com:8000",
+    "http://USERNAME:PASSWORD@proxy-b.example.com:8000",
+])
+```
+
+One-off conversion without the pool:
+
+```python
+from playwright_proxy_auth import to_playwright_proxy
+proxy = to_playwright_proxy("http://user:pass@gw.example.com:913")
+browser.new_context(proxy=proxy)
+```
+
+See [`examples/`](examples/) for the async version.
+
+## Gotchas this saves you from
+
+- **Credentials in the URL are ignored** — they must be a separate `username`/`password`. (Main reason for it.)
+- **Authenticated SOCKS5 is not supported by Playwright.** A `socks5://user:pass@…` URL raises a clear error instead of failing silently — use an HTTP/HTTPS gateway for authenticated rotation.
+- **Proxy is per *context*, not per page.** Rotate by creating a new `browser.new_context(proxy=...)`; pages inside a context share its exit IP.
+
+## A note on getting blocked anyway
+
+A correctly authenticated proxy still gets blocked if the **exit IP is a datacenter range** — anti-bot systems score the ASN and [TLS/JA3 fingerprint](https://jibaoproxy.com/blog/ja3-tls-fingerprint-detection-explained.html) before your page loads. Residential exits with clean ASN reputation are what pass. We build [JiBao Proxy](https://jibaoproxy.com) for this: 72M+ residential IPs across 200+ countries with sticky sessions. This package works with any HTTP proxy provider, though.
+
+## Related
+
+- [Selenium & Playwright proxy authentication, explained](https://jibaoproxy.com/blog/selenium-playwright-proxy-authentication.html)
+- [Why your JA3/TLS fingerprint gets you blocked](https://jibaoproxy.com/blog/ja3-tls-fingerprint-detection-explained.html)
+- [browser-use & AI agent proxies](https://jibaoproxy.com/blog/browser-use-ai-agent-proxies.html)
+
+## License
+
+MIT

playwright_proxy_authentication-0.1.0/README.md

@@ -0,0 +1,92 @@
+# playwright-proxy-authentication
+
+[![PyPI version](https://img.shields.io/pypi/v/playwright-proxy-authentication.svg)](https://pypi.org/project/playwright-proxy-authentication/)
+[![Python versions](https://img.shields.io/pypi/pyversions/playwright-proxy-authentication.svg)](https://pypi.org/project/playwright-proxy-authentication/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Use **authenticated and rotating proxies with [Playwright](https://playwright.dev)** without fighting its proxy API. Turn an ordinary `scheme://user:pass@host:port` URL into the dict Playwright expects, and hand out a fresh exit IP per browser context.
+
+```bash
+pip install playwright-proxy-authentication
+```
+
+## The problem
+
+Unlike `requests` or Scrapy, Playwright **ignores credentials in a proxy URL**. This silently fails to authenticate:
+
+```python
+# ❌ username/password are dropped — you get 407 Proxy Authentication Required
+browser.new_context(proxy={"server": "http://user:pass@gw.example.com:913"})
+```
+
+Playwright wants the parts split out:
+
+```python
+# ✅ correct
+browser.new_context(proxy={
+    "server": "http://gw.example.com:913",
+    "username": "user",
+    "password": "pass",
+})
+```
+
+This package does that conversion for you, and adds per-context rotation.
+
+## Usage
+
+```python
+from playwright.sync_api import sync_playwright
+from playwright_proxy_auth import ProxyPool
+
+# A rotating residential gateway gives a new exit IP on every connection.
+pool = ProxyPool(gateway="http://USERNAME:PASSWORD@us.jibaoproxy.com:913")
+
+with sync_playwright() as p:
+    browser = p.chromium.launch(headless=True)
+    for _ in range(3):
+        context = browser.new_context(proxy=pool.get())   # fresh IP per context
+        page = context.new_page()
+        page.goto("https://httpbin.org/ip")
+        print(page.inner_text("body"))
+        context.close()
+    browser.close()
+```
+
+Static list instead of a gateway:
+
+```python
+pool = ProxyPool(proxies=[
+    "http://USERNAME:PASSWORD@proxy-a.example.com:8000",
+    "http://USERNAME:PASSWORD@proxy-b.example.com:8000",
+])
+```
+
+One-off conversion without the pool:
+
+```python
+from playwright_proxy_auth import to_playwright_proxy
+proxy = to_playwright_proxy("http://user:pass@gw.example.com:913")
+browser.new_context(proxy=proxy)
+```
+
+See [`examples/`](examples/) for the async version.
+
+## Gotchas this saves you from
+
+- **Credentials in the URL are ignored** — they must be a separate `username`/`password`. (Main reason for it.)
+- **Authenticated SOCKS5 is not supported by Playwright.** A `socks5://user:pass@…` URL raises a clear error instead of failing silently — use an HTTP/HTTPS gateway for authenticated rotation.
+- **Proxy is per *context*, not per page.** Rotate by creating a new `browser.new_context(proxy=...)`; pages inside a context share its exit IP.
+
+## A note on getting blocked anyway
+
+A correctly authenticated proxy still gets blocked if the **exit IP is a datacenter range** — anti-bot systems score the ASN and [TLS/JA3 fingerprint](https://jibaoproxy.com/blog/ja3-tls-fingerprint-detection-explained.html) before your page loads. Residential exits with clean ASN reputation are what pass. We build [JiBao Proxy](https://jibaoproxy.com) for this: 72M+ residential IPs across 200+ countries with sticky sessions. This package works with any HTTP proxy provider, though.
+
+## Related
+
+- [Selenium & Playwright proxy authentication, explained](https://jibaoproxy.com/blog/selenium-playwright-proxy-authentication.html)
+- [Why your JA3/TLS fingerprint gets you blocked](https://jibaoproxy.com/blog/ja3-tls-fingerprint-detection-explained.html)
+- [browser-use & AI agent proxies](https://jibaoproxy.com/blog/browser-use-ai-agent-proxies.html)
+
+## License
+
+MIT

playwright_proxy_authentication-0.1.0/playwright_proxy_auth/__init__.py

@@ -0,0 +1,4 @@
+from .proxy import ProxyPool, to_playwright_proxy
+
+__all__ = ["ProxyPool", "to_playwright_proxy"]
+__version__ = "0.1.0"

playwright_proxy_authentication-0.1.0/playwright_proxy_auth/proxy.py

@@ -0,0 +1,68 @@
+"""Helpers for using authenticated and rotating proxies with Playwright.
+
+Playwright won't accept credentials embedded in a proxy URL the way requests or
+Scrapy do — it needs a dict: ``{"server": ..., "username": ..., "password": ...}``.
+These helpers turn an ordinary ``scheme://user:pass@host:port`` URL into that dict
+and let you hand out a fresh proxy per browser context for rotation.
+"""
+from urllib.parse import unquote, urlparse
+
+__all__ = ["to_playwright_proxy", "ProxyPool"]
+
+
+def to_playwright_proxy(url):
+    """Convert a ``scheme://user:pass@host:port`` URL to a Playwright proxy dict.
+
+    >>> to_playwright_proxy("http://user:pass@gw.example.com:913")
+    {'server': 'http://gw.example.com:913', 'username': 'user', 'password': 'pass'}
+
+    Note: Playwright supports authentication for HTTP/HTTPS proxies only.
+    SOCKS5 proxies that require a username/password are **not** supported by
+    Playwright itself — use an HTTP gateway for authenticated rotation.
+    """
+    p = urlparse(url)
+    if not p.hostname:
+        raise ValueError(f"Not a valid proxy URL: {url!r}")
+    if p.scheme.startswith("socks") and p.username:
+        raise ValueError(
+            "Playwright does not support authenticated SOCKS proxies. "
+            "Use an HTTP/HTTPS proxy URL instead."
+        )
+    server = f"{p.scheme}://{p.hostname}"
+    if p.port:
+        server += f":{p.port}"
+    proxy = {"server": server}
+    if p.username:
+        proxy["username"] = unquote(p.username)
+        proxy["password"] = unquote(p.password or "")
+    return proxy
+
+
+class ProxyPool:
+    """Hand out Playwright proxy dicts, one per call, for per-context rotation.
+
+    A rotating residential gateway already returns a new exit IP on every
+    connection, so a single gateway URL is enough::
+
+        pool = ProxyPool(gateway="http://USER:PASS@us.jibaoproxy.com:913")
+        context = browser.new_context(proxy=pool.get())
+
+    Or rotate over a static list::
+
+        pool = ProxyPool(proxies=["http://u:p@a:8000", "http://u:p@b:8000"])
+    """
+
+    def __init__(self, proxies=None, gateway=None):
+        if not proxies and not gateway:
+            raise ValueError("Provide either proxies=[...] or gateway=<url>.")
+        self._dicts = [to_playwright_proxy(u) for u in (proxies or [])]
+        self._gateway = to_playwright_proxy(gateway) if gateway else None
+        self._i = 0
+
+    def get(self):
+        """Return the next proxy dict (round-robins a list, or the gateway)."""
+        if self._gateway is not None:
+            return dict(self._gateway)
+        proxy = self._dicts[self._i % len(self._dicts)]
+        self._i += 1
+        return dict(proxy)

playwright_proxy_authentication-0.1.0/playwright_proxy_authentication.egg-info/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: playwright-proxy-authentication
+Version: 0.1.0
+Summary: Authenticated and rotating proxies for Playwright — turn user:pass proxy URLs into Playwright's proxy dict and rotate per context.
+Author-email: JiBao Proxy <support@jibaoproxy.com>
+License: MIT
+Project-URL: Homepage, https://jibaoproxy.com
+Project-URL: Source, https://github.com/jibaoproxyofficial-pixel/playwright-proxy-authentication
+Keywords: playwright,proxy,proxy-authentication,rotating-proxy,web-scraping,browser-automation,residential-proxy
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# playwright-proxy-authentication
+
+[![PyPI version](https://img.shields.io/pypi/v/playwright-proxy-authentication.svg)](https://pypi.org/project/playwright-proxy-authentication/)
+[![Python versions](https://img.shields.io/pypi/pyversions/playwright-proxy-authentication.svg)](https://pypi.org/project/playwright-proxy-authentication/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Use **authenticated and rotating proxies with [Playwright](https://playwright.dev)** without fighting its proxy API. Turn an ordinary `scheme://user:pass@host:port` URL into the dict Playwright expects, and hand out a fresh exit IP per browser context.
+
+```bash
+pip install playwright-proxy-authentication
+```
+
+## The problem
+
+Unlike `requests` or Scrapy, Playwright **ignores credentials in a proxy URL**. This silently fails to authenticate:
+
+```python
+# ❌ username/password are dropped — you get 407 Proxy Authentication Required
+browser.new_context(proxy={"server": "http://user:pass@gw.example.com:913"})
+```
+
+Playwright wants the parts split out:
+
+```python
+# ✅ correct
+browser.new_context(proxy={
+    "server": "http://gw.example.com:913",
+    "username": "user",
+    "password": "pass",
+})
+```
+
+This package does that conversion for you, and adds per-context rotation.
+
+## Usage
+
+```python
+from playwright.sync_api import sync_playwright
+from playwright_proxy_auth import ProxyPool
+
+# A rotating residential gateway gives a new exit IP on every connection.
+pool = ProxyPool(gateway="http://USERNAME:PASSWORD@us.jibaoproxy.com:913")
+
+with sync_playwright() as p:
+    browser = p.chromium.launch(headless=True)
+    for _ in range(3):
+        context = browser.new_context(proxy=pool.get())   # fresh IP per context
+        page = context.new_page()
+        page.goto("https://httpbin.org/ip")
+        print(page.inner_text("body"))
+        context.close()
+    browser.close()
+```
+
+Static list instead of a gateway:
+
+```python
+pool = ProxyPool(proxies=[
+    "http://USERNAME:PASSWORD@proxy-a.example.com:8000",
+    "http://USERNAME:PASSWORD@proxy-b.example.com:8000",
+])
+```
+
+One-off conversion without the pool:
+
+```python
+from playwright_proxy_auth import to_playwright_proxy
+proxy = to_playwright_proxy("http://user:pass@gw.example.com:913")
+browser.new_context(proxy=proxy)
+```
+
+See [`examples/`](examples/) for the async version.
+
+## Gotchas this saves you from
+
+- **Credentials in the URL are ignored** — they must be a separate `username`/`password`. (Main reason for it.)
+- **Authenticated SOCKS5 is not supported by Playwright.** A `socks5://user:pass@…` URL raises a clear error instead of failing silently — use an HTTP/HTTPS gateway for authenticated rotation.
+- **Proxy is per *context*, not per page.** Rotate by creating a new `browser.new_context(proxy=...)`; pages inside a context share its exit IP.
+
+## A note on getting blocked anyway
+
+A correctly authenticated proxy still gets blocked if the **exit IP is a datacenter range** — anti-bot systems score the ASN and [TLS/JA3 fingerprint](https://jibaoproxy.com/blog/ja3-tls-fingerprint-detection-explained.html) before your page loads. Residential exits with clean ASN reputation are what pass. We build [JiBao Proxy](https://jibaoproxy.com) for this: 72M+ residential IPs across 200+ countries with sticky sessions. This package works with any HTTP proxy provider, though.
+
+## Related
+
+- [Selenium & Playwright proxy authentication, explained](https://jibaoproxy.com/blog/selenium-playwright-proxy-authentication.html)
+- [Why your JA3/TLS fingerprint gets you blocked](https://jibaoproxy.com/blog/ja3-tls-fingerprint-detection-explained.html)
+- [browser-use & AI agent proxies](https://jibaoproxy.com/blog/browser-use-ai-agent-proxies.html)
+
+## License
+
+MIT

playwright_proxy_authentication-0.1.0/playwright_proxy_authentication.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+pyproject.toml
+playwright_proxy_auth/__init__.py
+playwright_proxy_auth/proxy.py
+playwright_proxy_authentication.egg-info/PKG-INFO
+playwright_proxy_authentication.egg-info/SOURCES.txt
+playwright_proxy_authentication.egg-info/dependency_links.txt
+playwright_proxy_authentication.egg-info/top_level.txt
+tests/test_proxy.py

playwright_proxy_authentication-0.1.0/playwright_proxy_authentication.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

playwright_proxy_authentication-0.1.0/playwright_proxy_authentication.egg-info/top_level.txt

@@ -0,0 +1 @@
+playwright_proxy_auth

playwright_proxy_authentication-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "playwright-proxy-authentication"
+version = "0.1.0"
+description = "Authenticated and rotating proxies for Playwright — turn user:pass proxy URLs into Playwright's proxy dict and rotate per context."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+authors = [{ name = "JiBao Proxy", email = "support@jibaoproxy.com" }]
+keywords = ["playwright", "proxy", "proxy-authentication", "rotating-proxy", "web-scraping", "browser-automation", "residential-proxy"]
+classifiers = [
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Internet :: WWW/HTTP",
+]
+
+[project.urls]
+Homepage = "https://jibaoproxy.com"
+Source = "https://github.com/jibaoproxyofficial-pixel/playwright-proxy-authentication"
+
+[tool.setuptools]
+packages = ["playwright_proxy_auth"]

playwright_proxy_authentication-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

playwright_proxy_authentication-0.1.0/tests/test_proxy.py

@@ -0,0 +1,33 @@
+import pytest
+from playwright_proxy_auth import ProxyPool, to_playwright_proxy
+
+
+def test_auth_url_to_dict():
+    assert to_playwright_proxy("http://user:pass@gw.example.com:913") == {
+        "server": "http://gw.example.com:913",
+        "username": "user",
+        "password": "pass",
+    }
+
+
+def test_no_auth_url():
+    assert to_playwright_proxy("http://gw.example.com:8000") == {
+        "server": "http://gw.example.com:8000"
+    }
+
+
+def test_socks_with_auth_rejected():
+    with pytest.raises(ValueError):
+        to_playwright_proxy("socks5://user:pass@gw.example.com:1080")
+
+
+def test_pool_list_round_robins():
+    pool = ProxyPool(proxies=["http://u:p@a:8000", "http://u:p@b:8000"])
+    assert pool.get()["server"] == "http://a:8000"
+    assert pool.get()["server"] == "http://b:8000"
+    assert pool.get()["server"] == "http://a:8000"
+
+
+def test_pool_gateway_constant():
+    pool = ProxyPool(gateway="http://u:p@gw:913")
+    assert pool.get() == pool.get() == {"server": "http://gw:913", "username": "u", "password": "p"}