RAE de Hong Kong (China)

IPs de hogares reales

Proxies residenciales de RAE de Hong Kong (China)

Los proxies residenciales de Hong Kong son direcciones IP reales de hogares hongkoneses, asignadas por ISP de consumo como HKT, Hong Kong Broadband (HKBN), HGC y SmarTone. Te permiten navegar, hacer scraping y verificar tiendas, precios y contenido locales como un usuario auténtico dentro de la ciudad — en Central, Causeway Bay, Shatin y Tsuen Wan — en lugar de hacerlo desde una IP de datacenter que HKTVmall, Fortress y los geobloqueos locales detectan y bloquean al instante.

Pruébalo por $1.99/GB Inicia sesión con Google

HTTP / SOCKS5Segmentación por ciudad e ISPEl tráfico nunca caducaLimpieza verificada cada mes

36,029IPs en el pool

25+Ciudades cubiertas

22Redes de ISP

150 msLatencia mediana

99.3%Estrictamente limpias

Proxies residenciales de RAE de Hong Kong (China), de un vistazo

Los proxies residenciales de RAE de Hong Kong (China) son direcciones IP reales de hogares RAE de Hong Kong (China), asignadas por ISP de consumo. Te permiten navegar, hacer scraping y verificar sitios, precios y contenido RAE de Hong Kong (China) como un usuario genuino dentro del país, en lugar de hacerlo desde una IP de datacenter que los sitios locales marcan y bloquean.

Tipo de pool: Residencial, multi-ISP
Ciudades cubiertas: Central, Kwai Chung, Tsing Yi
Principales ISP: HKT · HKBN · HGC
Protocolos: HTTP, SOCKS5
Rotación: Por solicitud o fija
Precisión geográfica: 99.87%
Limpieza del pool: 99.3% clean
Precios: from $2.00/GB
Última medición: 2026-06-23
Soporte: 24/7

Por qué los equipos eligen nuestro pool RAE de Hong Kong (China)

IPs residenciales reales, segmentación precisa y una calidad que no tienes que creer a ciegas.

IPs residenciales reales

Conexiones residenciales genuinas de ISP de consumo RAE de Hong Kong (China), no rangos de datacenter que se bloquean apenas se detectan.

Segmentación por ciudad e ISP

Apunta a ciudades y operadores específicos donde la profundidad del pool lo permita, hasta el nivel del proveedor.

Rotativas o fijas

Rotación por solicitud para operar a escala, o sesiones fijas de hasta ~72 h para flujos de varios pasos.

HTTP y SOCKS5

Funciona con cualquier cliente, scraper o stack de automatización sin configuración adicional.

Obtenidas de forma ética

IPs de una red residencial con consentimiento explícito: usuarios reales que aceptaron compartir su ancho de banda.

Limpieza verificada, cada mes

Volvemos a medir el pool cada mes y publicamos las cifras, para que se mantengan al día.

Calidad que puedes verificar

Cada mes ejecutamos el mismo benchmark: una muestra aleatoria de IPs evaluada con Scamalytics, prueba de latencia desde un VPS neutral y verificación de precisión geográfica en bases de datos independientes. Las cifras de abajo reflejan producción, no una prueba de laboratorio en el mejor de los casos.

Limpieza Scamalytics · 100,000 IPs

Estrictamente limpias99.3%

Contaminación de datacenter0%

En alguna lista negra0.19%

Bajo riesgo de fraude (0–19)99.2%

Precisión geográfica99.87%

Latencia y velocidad VPS → Cloudflare

Latencia mediana150ms

Latencia p90 / p95194 / 245 ms

Conexiones exitosas98.8%

Rendimiento (mediana / p95)2.59 / 7.22 MB/s

Finalización de archivos grandes100%

Composición de la red

Tipo de conexión100% residencial

Redes de ISP (ASN)22

Modos de rotaciónpor solicitud · fija

Principales operadoresHKT · HKBN · HGC

Medido sobre 100,000 direcciones desde un VPS neutral contra el edge de Cloudflare, vigente a la fecha del último benchmark. Una nueva ejecución puede diferir por un margen pequeño, pero las cifras reflejan plenamente el orden de magnitud y son una base sólida para juzgar si el pool se ajusta a tu caso de uso. La tasa de éxito de scraping por objetivo no se publica: depende de tu fingerprint y configuración, no solo de la IP.

benchmark.py — benchmark abierto del pool

El benchmark abierto detrás de las cifras de arriba. Toma una muestra aleatoria de IPs del pool y mide cuatro cosas: limpieza (riesgo de fraude de Scamalytics, datacenter, lista negra y precisión geográfica), latencia (ida y vuelta al edge de Cloudflare y a ip-api), rotación (IPs únicas, ASN y subredes /24) y rendimiento (velocidad de descarga y tiempo hasta el primer byte), y luego reporta cada una. Se publica completo para que la metodología detrás de cada cifra quede abierta a inspección.

# -*- coding: utf-8 -*-

"""
JETPROXY — POOL BENCHMARK

End-to-end audit of a residential proxy pool. A single run measures cleanliness,
latency, rotation and throughput, then prints every metric as one list.

  Cleanliness   fraud-risk, datacenter, blacklist and geo-accuracy (Scamalytics)
  Latency       Cloudflare edge (responsiveness) and ip-api origin (round-trip)
  Rotation      unique IPs / ASNs / subnets, success rate, country match
  Throughput    median & p95 download speed, time-to-first-byte, drop rate

Every stage size is a parameter, so the same script runs a quick check or a deep
audit:

    python benchmark.py --country ID
    python benchmark.py --quality 200 --downloads 50 --latency 1000 --rotation 5000 --country ID
    python benchmark.py --proxies proxies.txt --country ID --json result.json

Proxies   paste at the prompt (one per line) or pass --proxies FILE.
          host:port:user:pass  ·  host:port  ·  user:pass@host:port
The Scamalytics key for the cleanliness stage is read from the environment or
../.env (SCAMALYTICS_USER + SCAMALYTICS_KEY); without it that stage is skipped.
"""
from __future__ import annotations

import argparse
import asyncio
import csv
import ipaddress
import json
import os
import re
import statistics
import sys
import time
from collections import Counter
from datetime import datetime

try:
    sys.stdout.reconfigure(encoding="utf-8")
    sys.stderr.reconfigure(encoding="utf-8")
except Exception:
    pass

try:
    import aiohttp
    from rich.console import Console
    from rich.table import Table
    from rich import box
except ImportError:
    print("\n[!] Need: pip install aiohttp rich\n")
    sys.exit(1)

console = Console()

# ── endpoints ────────────────────────────────────────────────────────────────

IP_ENDPOINT = ("http://ip-api.com/json/?fields="
               "status,message,country,countryCode,regionName,city,isp,as,org,query")
CF_TRACE = "https://speed.cloudflare.com/cdn-cgi/trace"   # tiny edge response (~350 B)

FILE_MB = 10
DOWN_URL = f"https://speed.cloudflare.com/__down?bytes={FILE_MB * 1_000_000}"
SCAM_HOST = "https://api11.scamalytics.com/v3"            # US node (api12 = EU)


SCORE_CONCURRENCY = 10
DOWN_CONCURRENCY = 3   # downloads share the local uplink — keep low so the exit node is the bottleneck



# ── proxy parsing ──────────────────────────────────────────────────────────────

def parse_proxy(raw: str):
    """host:port | host:port:user:pass | user:pass@host:port | scheme://..."""
    raw = raw.strip()
    if not raw or raw.startswith("#"):
        return None
    scheme = "http"
    if "://" in raw:
        scheme, raw = raw.split("://", 1)
    user = pwd = host = port = None
    if "," in raw:
        parts = [p.strip() for p in raw.split(",")]
        if len(parts) == 4:
            host, port, user, pwd = parts
        elif len(parts) == 2:
            host, port = parts
        else:
            return None
    elif "@" in raw:
        cred, hostport = raw.rsplit("@", 1)
        if ":" in cred:
            user, pwd = cred.split(":", 1)
        host, port = hostport.rsplit(":", 1)
    else:
        parts = raw.split(":")
        if len(parts) == 2:
            host, port = parts
        elif len(parts) == 4:
            host, port, user, pwd = parts
        else:
            return None
    try:
        port = int(port)
    except (ValueError, TypeError):
        return None
    return {"scheme": scheme, "host": host, "port": port, "user": user, "pwd": pwd,
            "url": f"{scheme}://{host}:{port}", "label": f"{host}:{port}"}


def subnet24(ip: str) -> str:
    try:
        return str(ipaddress.ip_network(ip + "/24", strict=False))
    except ValueError:
        return ""


def pct(values, p):
    if not values:
        return 0.0
    s = sorted(values)
    k = min(len(s) - 1, max(0, int(round(p / 100 * (len(s) - 1)))))
    return s[k]


# ── ip-api request (identity + geo + round-trip) ───────────────────────────────

def _fail(idx, proxy, err, latency):
    return {"idx": idx, "ok": False, "proxy": proxy["label"], "error": err, "latency": latency}


async def _one_attempt(session, proxy, idx, timeout):
    t0 = time.perf_counter()
    auth = aiohttp.BasicAuth(proxy["user"], proxy["pwd"]) if proxy["user"] else None
    try:
        async with session.get(IP_ENDPOINT, proxy=proxy["url"], proxy_auth=auth,
                               timeout=aiohttp.ClientTimeout(total=timeout)) as r:
            latency = (time.perf_counter() - t0) * 1000
            if r.status != 200:
                return _fail(idx, proxy, f"HTTP {r.status}", latency)
            data = await r.json(content_type=None)
            if data.get("status") != "success":
                return _fail(idx, proxy, data.get("message", "api error"), latency)
            ip = data.get("query", "")
            asn = data.get("as", "").split(" ")[0] if data.get("as") else ""
            return {"idx": idx, "ok": True, "proxy": proxy["label"], "ip": ip,
                    "country": data.get("country", ""), "cc": data.get("countryCode", ""),
                    "region": data.get("regionName", ""), "city": data.get("city", ""),
                    "isp": data.get("isp") or data.get("org", ""), "asn": asn,
                    "org": data.get("org") or data.get("as", ""),
                    "subnet": subnet24(ip), "latency": latency, "error": ""}
    except asyncio.TimeoutError:
        return _fail(idx, proxy, "timeout", (time.perf_counter() - t0) * 1000)
    except Exception as e:
        return _fail(idx, proxy, type(e).__name__, (time.perf_counter() - t0) * 1000)


async def fetch(session, proxy, sem, idx, timeout, max_retries=2):
    async with sem:
        res = None
        for attempt in range(1, max_retries + 2):
            res = await _one_attempt(session, proxy, idx, timeout)
            if res["ok"]:
                res["attempts"] = attempt
                res["first_try_ok"] = (attempt == 1)
                return res
        res["attempts"] = max_retries + 1
        res["first_try_ok"] = False
        return res


# ── Cloudflare edge probe (responsiveness + nearest datacenter) ────────────────

async def cf_probe(proxy, sem, timeout):
    """One warm-up request opens the tunnel + TLS, then the next request on the same
    kept-alive connection is timed — so the figure is the edge round-trip, not the
    one-off connection setup."""
    async with sem:
        auth = aiohttp.BasicAuth(proxy["user"], proxy["pwd"]) if proxy["user"] else None
        try:
            async with aiohttp.ClientSession(connector=aiohttp.TCPConnector(limit=2, ssl=False)) as sess:
                async with sess.get(CF_TRACE, proxy=proxy["url"], proxy_auth=auth,
                                    timeout=aiohttp.ClientTimeout(total=15)) as w:
                    await w.read()
                t0 = time.perf_counter()
                async with sess.get(CF_TRACE, proxy=proxy["url"], proxy_auth=auth,
                                    timeout=aiohttp.ClientTimeout(total=timeout)) as r:
                    txt = await r.text()
                    rtt = (time.perf_counter() - t0) * 1000
                    if r.status != 200:
                        return {"ok": False, "error": f"HTTP {r.status}"}
                    d = {}
                    for ln in txt.splitlines():
                        if "=" in ln:
                            k, v = ln.split("=", 1)
                            d[k] = v
                    return {"ok": True, "rtt": rtt, "ip": d.get("ip", ""),
                            "loc": d.get("loc", ""), "colo": d.get("colo", "")}
        except asyncio.TimeoutError:
            return {"ok": False, "error": "timeout"}
        except Exception as e:
            return {"ok": False, "error": type(e).__name__}


# ── download (throughput + TTFB + mid-transfer drops) ──────────────────────────

async def download(proxy, sem, idx, timeout, retries):
    async with sem:
        auth = aiohttp.BasicAuth(proxy["user"], proxy["pwd"]) if proxy["user"] else None
        last_err = ""
        dropped_at = []
        for attempt in range(1, retries + 2):
            try:
                async with aiohttp.ClientSession(connector=aiohttp.TCPConnector(limit=4, ssl=False)) as sess:
                    country = "?"
                    try:
                        async with sess.get(CF_TRACE, proxy=proxy["url"], proxy_auth=auth,
                                            timeout=aiohttp.ClientTimeout(total=15)) as tr:
                            for ln in (await tr.text()).splitlines():
                                if ln.startswith("loc="):
                                    country = ln[4:].strip() or "?"
                    except Exception:
                        pass
                    t0 = time.perf_counter()
                    async with sess.get(DOWN_URL, proxy=proxy["url"], proxy_auth=auth,
                                        timeout=aiohttp.ClientTimeout(total=timeout)) as r:
                        if r.status != 200:
                            last_err = f"HTTP {r.status}"
                            continue
                        first = None
                        nbytes = 0
                        try:
                            async for chunk in r.content.iter_chunked(65536):
                                if first is None:
                                    first = time.perf_counter()
                                nbytes += len(chunk)
                        except Exception as stream_err:
                            if nbytes > 0:
                                dropped_at.append(nbytes)
                                last_err = f"dropped@{nbytes // 1_000_000}MB"
                            else:
                                last_err = type(stream_err).__name__
                            continue
                        end = time.perf_counter()
                        if nbytes == 0:
                            last_err = "empty"
                            continue
                        ttfb = (first - t0) * 1000 if first else 0
                        dl_time = (end - first) if first and end > first else (end - t0)
                        mbps = (nbytes / 1_000_000) / dl_time if dl_time > 0 else 0
                        return {"idx": idx, "ok": True, "country": country, "bytes": nbytes,
                                "ttfb_ms": ttfb, "mbps": mbps, "dropped": bool(dropped_at), "error": ""}
            except asyncio.TimeoutError:
                last_err = "timeout"
            except Exception as e:
                last_err = type(e).__name__
        return {"idx": idx, "ok": False, "country": "?", "bytes": 0, "ttfb_ms": 0,
                "mbps": 0, "dropped": bool(dropped_at), "error": last_err}


# ── Scamalytics scoring ────────────────────────────────────────────────────────

def load_creds():
    user = os.environ.get("SCAMALYTICS_USER")
    key = os.environ.get("SCAMALYTICS_KEY")
    if user and key:
        return user.strip(), key.strip()
    found = {}
    for path in ("../.env", "../.env.local", ".env"):
        p = os.path.join(os.path.dirname(__file__), path)
        if os.path.exists(p):
            with open(p, encoding="utf-8") as f:
                for line in f:
                    m = re.match(r'\s*(SCAMALYTICS_USER|SCAMALYTICS_KEY)\s*=\s*"?([^"\s]+)"?', line)
                    if m:
                        found[m.group(1)] = m.group(2)
    return found.get("SCAMALYTICS_USER"), found.get("SCAMALYTICS_KEY")


def parse_scam(ip, data):
    s = data.get("scamalytics", {})
    if s.get("status") != "ok":
        return {"ip": ip, "ok": False, "error": s.get("status") or "bad_response"}
    ext = data.get("external_datasources", {})
    score = s.get("scamalytics_score")
    risk = s.get("scamalytics_risk", "?")
    px = s.get("scamalytics_proxy", {})
    is_dc = bool(px.get("is_datacenter"))
    is_vpn = bool(px.get("is_vpn"))
    fh = bool(ext.get("firehol", {}).get("is_proxy"))
    ips_bl = bool(ext.get("ipsum", {}).get("ip_blacklisted"))
    sh = bool(ext.get("spamhaus_drop", {}).get("ip_blacklisted"))
    x4 = bool(ext.get("x4bnet", {}).get("is_blacklisted_spambot"))
    on_bl = bool(s.get("is_blacklisted_external")) or fh or ips_bl or sh or x4
    cc = (ext.get("dbip", {}).get("ip_country_code")
          or ext.get("ipinfo", {}).get("ip_country_code")
          or ext.get("maxmind_geolite2", {}).get("ip_country_code")
          or ext.get("ip2proxy_lite", {}).get("ip_country_code") or "?")
    isp = (ext.get("dbip", {}).get("isp_name")
           or ext.get("ip2proxy_lite", {}).get("isp_name")
           or s.get("scamalytics_isp") or "?")
    asn = ext.get("ipinfo", {}).get("asn") or ext.get("ip2proxy_lite", {}).get("asn") or "?"
    return {"ip": ip, "ok": True, "error": "", "score": score if isinstance(score, int) else 0,
            "risk": risk, "is_dc": is_dc, "is_vpn": is_vpn, "on_bl": on_bl,
            "country": cc, "isp": isp, "asn": asn,
            "credits": s.get("credits", {}).get("remaining"),
            "strict_clean": (risk == "low" and not is_dc and not on_bl)}


async def score_one(session, user, key, ip, sem):
    async with sem:
        try:
            async with session.get(f"{SCAM_HOST}/{user}/", params={"key": key, "ip": ip},
                                   timeout=aiohttp.ClientTimeout(total=20)) as r:
                return parse_scam(ip, await r.json(content_type=None))
        except Exception as e:
            return {"ip": ip, "ok": False, "error": type(e).__name__}


# ── stage runners ──────────────────────────────────────────────────────────────

def progress(tag, done, total):
    step = max(1, total // 10)
    if done % step == 0 or done == total:
        console.print(f"   [{tag}] {done}/{total}", highlight=False)


async def run_ipapi(proxies, n, concurrency, timeout, retries, tag):
    sem = asyncio.Semaphore(concurrency)
    conn = aiohttp.TCPConnector(limit=concurrency * 3, ssl=False)
    out = []
    async with aiohttp.ClientSession(connector=conn) as http:
        tasks = [asyncio.create_task(fetch(http, proxies[i % len(proxies)], sem, i, timeout, retries))
                 for i in range(n)]
        for done, coro in enumerate(asyncio.as_completed(tasks), 1):
            out.append(await coro)
            progress(tag, done, n)
    return out


async def run_cf(proxies, n, concurrency, timeout, tag):
    sem = asyncio.Semaphore(concurrency)
    tasks = [asyncio.create_task(cf_probe(proxies[i % len(proxies)], sem, timeout))
             for i in range(n)]
    out = []
    for done, coro in enumerate(asyncio.as_completed(tasks), 1):
        out.append(await coro)
        progress(tag, done, n)
    return out


async def run_download(proxies, n, timeout, retries, tag):
    sem = asyncio.Semaphore(DOWN_CONCURRENCY)
    tasks = [asyncio.create_task(download(proxies[i % len(proxies)], sem, i, timeout, retries))
             for i in range(n)]
    out = []
    for done, coro in enumerate(asyncio.as_completed(tasks), 1):
        out.append(await coro)
        progress(tag, done, n)
    return out


async def score_ips(ips, user, key, tag):
    sem = asyncio.Semaphore(SCORE_CONCURRENCY)
    out = []
    async with aiohttp.ClientSession() as session:
        tasks = [asyncio.create_task(score_one(session, user, key, ip, sem)) for ip in ips]
        for done, coro in enumerate(asyncio.as_completed(tasks), 1):
            out.append(await coro)
            progress(tag, done, len(ips))
    return out


# ── input ──────────────────────────────────────────────────────────────────────

def read_proxies(path):
    if path:
        with open(path, encoding="utf-8") as f:
            lines = f.readlines()
    else:
        console.print("Paste proxies (one per line), then an empty line:")
        lines = []
        while True:
            try:
                ln = input()
            except EOFError:
                break
            if ln.strip() == "":
                if lines:
                    break
                continue
            lines.append(ln)
    return [p for p in (parse_proxy(l) for l in lines) if p]


def fmt(v, suffix=""):
    return f"{v}{suffix}"


# ── main ─────────────────────────────────────────────────────────────────────

def build_report(M):
    t = Table(title="POOL BENCHMARK — RESULTS", box=box.DOUBLE_EDGE, header_style="bold cyan",
              title_style="bold green")
    t.add_column("Metric", style="cyan")
    t.add_column("Value", style="bold white", justify="right")
    for section, rows in M["sections"]:
        t.add_row(f"[bold yellow]{section}[/]", "")
        for k, v in rows:
            t.add_row(f"  {k}", str(v))
    console.print()
    console.print(t)


async def run(args, proxies):
    M = {"label": args.label, "country": args.country or None,
         "timestamp": datetime.now().isoformat(timespec="seconds"),
         "proxies_input": len(proxies), "stages": {}}
    user = key = None

    # 1 — cleanliness (Scamalytics)

    clean_rows = []
    if not args.no_quality and args.quality > 0:
        user, key = load_creds()
        if not user or not key:
            console.print("[yellow]Scamalytics key not found — skipping cleanliness stage.[/]")
        else:
            console.rule(f"[bold]Cleanliness — {args.quality} IPs[/]")
            collected = await run_ipapi(proxies, int(args.quality * 1.6) + 10,
                                        args.concurrency, 15, 1, "collect")
            uniq = {}
            for r in collected:
                if r.get("ok") and r.get("ip") and r["ip"] not in uniq:
                    uniq[r["ip"]] = r
            ips = list(uniq.keys())[:args.quality]
            scored = await score_ips(ips, user, key, "score")
            ok = [r for r in scored if r.get("ok")]
            n = len(ok)
            if n:
                strict = sum(r["strict_clean"] for r in ok) / n * 100
                low = sum(1 for r in ok if r["risk"] == "low") / n * 100
                dc = sum(r["is_dc"] for r in ok) / n * 100
                bl = sum(r["on_bl"] for r in ok) / n * 100
                vpn = sum(r["is_vpn"] for r in ok)
                geo = None
                if args.country:
                    geo = sum(1 for r in ok if (r["country"] or "").upper() == args.country.upper()) / n * 100
                M["stages"]["cleanliness"] = {
                    "n": n, "strict_clean_pct": round(strict, 1), "low_risk_pct": round(low, 1),
                    "datacenter_pct": round(dc, 1), "blacklist_pct": round(bl, 1),
                    "geo_accuracy_pct": round(geo, 1) if geo is not None else None, "vpn": vpn}
                clean_rows = [("Strictly clean", f"{strict:.1f}%"),
                              ("Low fraud-risk (0–19)", f"{low:.1f}%"),
                              ("Datacenter", f"{dc:.1f}%"),
                              ("Blacklisted", f"{bl:.1f}%")]
                if geo is not None:
                    clean_rows.append((f"Geo-accuracy ({args.country.upper()})", f"{geo:.1f}%"))
                # per-IP CSV

                ts = datetime.now().strftime("%Y%m%d_%H%M%S")
                with open(f"benchmark_ips_{ts}.csv", "w", newline="", encoding="utf-8") as f:
                    w = csv.writer(f)
                    w.writerow(["ip", "score", "risk", "is_datacenter", "is_vpn", "on_blacklist",
                                "country", "isp", "asn", "strict_clean"])
                    for r in scored:
                        if r.get("ok"):
                            w.writerow([r["ip"], r["score"], r["risk"], r["is_dc"], r["is_vpn"],
                                        r["on_bl"], r["country"], r["isp"], r["asn"], r["strict_clean"]])

    # 2 — throughput

    console.rule(f"[bold]Throughput — {args.downloads} downloads[/]")
    dl = await run_download(proxies, args.downloads, 60, 1, "download")
    dok = [r for r in dl if r["ok"]]
    dl_rows = []
    if dok:
        mbps = [r["mbps"] for r in dok]
        ttfb = [r["ttfb_ms"] for r in dok]
        nodrop = sum(1 for r in dl if r["ok"] and not r["dropped"]) / len(dl) * 100
        M["stages"]["throughput"] = {
            "n": len(dl), "ok": len(dok),
            "median_mbps": round(statistics.median(mbps), 2), "p95_mbps": round(pct(mbps, 95), 2),
            "median_ttfb_ms": round(statistics.median(ttfb)), "completed_no_drop_pct": round(nodrop, 1)}
        dl_rows = [("Median download", f"{statistics.median(mbps):.1f} MB/s ({statistics.median(mbps)*8:.0f} Mbps)"),
                   ("p95 download", f"{pct(mbps,95):.1f} MB/s ({pct(mbps,95)*8:.0f} Mbps)"),
                   ("Median TTFB", f"{statistics.median(ttfb):.0f} ms"),
                   ("Completed without drop", f"{nodrop:.0f}%")]

    # 3 — latency (Cloudflare edge + ip-api origin)

    console.rule(f"[bold]Latency — {args.latency} probes[/]")
    cf = await run_cf(proxies, args.latency, args.concurrency, 15, "cf")
    cfok = [r for r in cf if r["ok"]]
    lat_rows = []
    if cfok:
        rtts = [r["rtt"] for r in cfok]
        colo = Counter(r["colo"] for r in cfok if r["colo"]).most_common(1)
        M["stages"].setdefault("latency", {})
        M["stages"]["latency"]["cloudflare"] = {
            "n": len(cfok), "p50_ms": round(statistics.median(rtts)),
            "p90_ms": round(pct(rtts, 90)), "p95_ms": round(pct(rtts, 95)),
            "top_colo": colo[0][0] if colo else None}
        lat_rows += [("Cloudflare edge — p50", f"{statistics.median(rtts):.0f} ms"),
                     ("Cloudflare edge — p90", f"{pct(rtts,90):.0f} ms"),
                     ("Cloudflare edge — p95", f"{pct(rtts,95):.0f} ms")]
        if colo:
            lat_rows.append(("Nearest datacenter", colo[0][0]))

    # 4 — rotation (also yields ip-api round-trip latency)

    console.rule(f"[bold]Rotation — {args.rotation} requests[/]")
    rot = await run_ipapi(proxies, args.rotation, args.concurrency, args.timeout, 2, "rotation")
    rok = [r for r in rot if r["ok"]]
    rot_rows = []
    if rok:
        uips = {r["ip"] for r in rok if r.get("ip")}
        uasn = {r["asn"] for r in rok if r.get("asn")}
        usub = {r["subnet"] for r in rok if r.get("subnet")}
        success = len(rok) / len(rot) * 100
        first = sum(1 for r in rok if r.get("first_try_ok")) / len(rot) * 100
        cmatch = None
        if args.country:
            cmatch = sum(1 for r in rok if (r["cc"] or "").upper() == args.country.upper()) / len(rok) * 100
        ipapi_rtts = [r["latency"] for r in rok]
        M["stages"]["rotation"] = {
            "n": len(rot), "success_pct": round(success, 1), "first_try_pct": round(first, 1),
            "unique_ips": len(uips), "unique_asns": len(uasn), "unique_subnets": len(usub),
            "country_match_pct": round(cmatch, 2) if cmatch is not None else None}
        M["stages"].setdefault("latency", {})
        M["stages"]["latency"]["ip_api"] = {
            "n": len(ipapi_rtts), "p50_ms": round(statistics.median(ipapi_rtts)),
            "p90_ms": round(pct(ipapi_rtts, 90))}
        lat_rows += [("ip-api origin — p50", f"{statistics.median(ipapi_rtts):.0f} ms"),
                     ("ip-api origin — p90", f"{pct(ipapi_rtts,90):.0f} ms")]
        rot_rows = [("Success rate", f"{success:.1f}%"),
                    ("First-try success", f"{first:.1f}%"),
                    ("Unique exit IPs", f"{len(uips)}"),
                    ("Unique networks (ASN)", f"{len(uasn)}"),
                    ("Unique /24 subnets", f"{len(usub)}")]
        if cmatch is not None:
            rot_rows.append((f"Country match ({args.country.upper()})", f"{cmatch:.2f}%"))

    M["sections"] = [s for s in [
        ("CLEANLINESS", clean_rows), ("LATENCY", lat_rows),
        ("ROTATION", rot_rows), ("THROUGHPUT", dl_rows)] if s[1]]
    build_report(M)

    out_path = args.json or f"benchmark_{args.label}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
    M.pop("sections", None)
    with open(out_path, "w", encoding="utf-8") as f:
        json.dump(M, f, indent=2, ensure_ascii=False)
    console.print(f"\n[green]✓[/] Saved: [bold]{out_path}[/]")


def main():
    ap = argparse.ArgumentParser(description="Jetproxy pool benchmark")
    ap.add_argument("--quality", type=int, default=100, help="IPs scored for cleanliness")
    ap.add_argument("--downloads", type=int, default=50, help="download samples")
    ap.add_argument("--latency", type=int, default=1000, help="latency probes")
    ap.add_argument("--rotation", type=int, default=2000, help="rotation requests")
    ap.add_argument("--concurrency", type=int, default=20)
    ap.add_argument("--timeout", type=float, default=15.0)
    ap.add_argument("--country", default="", help="expected ISO code for geo-accuracy")
    ap.add_argument("--proxies", default="", help="proxy list file (else paste)")
    ap.add_argument("--label", default="pool")
    ap.add_argument("--json", default="")
    ap.add_argument("--no-quality", action="store_true", help="skip the cleanliness stage")
    args = ap.parse_args()

    console.print("\n[bold cyan]═══  JETPROXY — POOL BENCHMARK  ═══[/]\n")
    proxies = read_proxies(args.proxies)
    if not proxies:
        console.print("[red]No valid proxies.[/]")
        return
    console.print(f"[green]✓[/] Proxies loaded: [bold]{len(proxies)}[/]")
    asyncio.run(run(args, proxies))


if __name__ == "__main__":
    try:
        main()
    except KeyboardInterrupt:
        console.print("\n[yellow]Interrupted.[/]")

Segmenta hasta el nivel de ciudad

«Prom. en línea» es el número promedio de dispositivos distintos conectados y disponibles en el mismo momento, no un total acumulado. Agrupado en Alto / Medio / Bajo.

RegionesCiudadesProveedores

Región	Latencia	Prom. en línea	Pool
Kwai Tsing District	149 ms	~710	Alto
Central and Western	150 ms	~648	Alto
Kowloon City	149 ms	~203	Alto
Yuen Long District	151 ms	~182	Alto
Sha Tin	150 ms	~171	Alto
Eastern District	149 ms	~163	Alto
Kwun Tong District	151 ms	~139	Alto
Yau Tsim Mong District	153 ms	~129	Medio
Tsuen Wan District	151 ms	~128	Medio
North District	148 ms	~119	Medio
Sham Shui Po District	149 ms	~101	Medio
Wong Tai Sin District	150 ms	~94	Medio
Sai Kung District	153 ms	~89	Bajo
Tai Po District	151 ms	~76	Bajo
Kowloon	153 ms	~73	Bajo
Tuen Mun	151 ms	~65	Bajo
Islands	154 ms	~45	Bajo
Southern District	151 ms	~42	Bajo
Wan Chai	154 ms	~27	Bajo

Ciudad	Latencia	Prom. en línea	Pool
Central	150 ms	~839	Alto
Kwai Chung	149 ms	~778	Alto
Tsing Yi	150 ms	~199	Alto
Hong Kong	153 ms	~136	Alto
Kwu Tung	150 ms	~126	Alto
Tin Shui Wai	151 ms	~93	Alto
Causeway Bay	148 ms	~79	Alto
Ho Man Tin	147 ms	~76	Alto
Tsuen Wan	153 ms	~69	Alto
Shatin	149 ms	~67	Medio
Tai Po	151 ms	~64	Medio
Sham Shui Po	149 ms	~64	Medio
Lam Tin	185 ms	~61	Medio
Tseung Kwan O	149 ms	~56	Medio
Hang Hau	155 ms	~56	Medio
Tai Kok Tsui	146 ms	~51	Medio
Mong Kok	161 ms	~49	Bajo
Kowloon Bay	149 ms	~45	Bajo
Yuen Long	146 ms	~45	Bajo
Chai Wan Kok	152 ms	~44	Bajo
Tung Chung	154 ms	~44	Bajo
Hung Hom	153 ms	~42	Bajo
Tuenmen	147 ms	~42	Bajo
Kam Tin	180 ms	~40	Bajo
Jordan	153 ms	~39	Bajo

Proveedor	Latencia	Prom. en línea	Pool
HKTfijo	150 ms	~1,433	Alto
HKBNfijo	137 ms	~1,075	Alto
HGCfijo	150 ms	~349	Alto
CommuniLinkmóvil	152 ms	~137	Medio
SmarTonemóvil	201 ms	~110	Bajo
HKCfijo	153 ms	~96	Bajo
NOVAfijo	148 ms	~4	Bajo

Precisión geográfica: cada IP vendida como RAE de Hong Kong (China) resuelve a RAE de Hong Kong (China) en tres bases de datos geográficas independientes (db-ip, MaxMind, ipinfo); la alta precisión geográfica es la señal en la que se apoyan los filtros geográficos locales.

Proxies de RAE de Hong Kong (China) por caso de uso

Organizado por lo que haces, no por plataforma. Los servicios locales aparecen donde importan.

E-commerce e investigación de mercado

Revisa tiendas, precios y listados locales desde dentro del mercado.

Monitoreo de tiendas
Seguimiento de precios locales
Investigación de vendedores

HKTVmallYOHO (友和)Fortress (豐澤)Broadway (百老滙)ParknShop (百佳)

Verificación y rendimiento de anuncios

Mira cómo se renderizan los anuncios, creatividades y la SERP para un usuario local, sin cambios manuales.

SERP local
Revisión de creatividades
Páginas de aterrizaje

WhatsAppFacebookInstagramWeChat

Viajes e inteligencia de precios

Captura tarifas de vuelos y hoteles tal como las ve un cliente local.

Tarifas con precio geográfico
Monitoreo de ofertas
Comparación de tarifas

Trip.comKlookKKdayCathay PacificHK Express

Streaming y verificación geográfica

Verifica catálogos con bloqueo regional y filtros geográficos desde la ubicación correcta.

Verificaciones geográficas
Verificación de catálogos
Disponibilidad regional

myTV SUPER (TVB)ViuNow E (PCCW)HBO GO AsiaNetflix

Clasificados y avisos locales

Monitorea artículos de segunda mano, autos y alquileres en los clasificados locales.

Monitoreo de avisos
Seguimiento de precios
Cobertura regional

CarousellDCFever28car (易發車網)Geo Expat

Desarrollo y automatización

IPs residenciales para pipelines, pruebas y recolección de datos permitida vía API.

Integración de pipelines
Gestión de API
Sesiones fijas

PythonScrapycURLGitHub

Más allá de los sitios locales, el mismo pool RAE de Hong Kong (China) funciona con las principales plataformas globales —Google, Meta, Amazon, YouTube, TikTok y Netflix— tal como se ven desde el mercado local RAE de Hong Kong (China): precios locales, anuncios, catálogos, SERP y contenido.

Desarrollador API

Genera endpoints acotados a RAE de Hong Kong (China) en el panel, copia snippets probados o automatiza listas de proxies a través de la API pública. Ciudad, ISP, sesiones fijas y listas guardadas se mantienen en un solo flujo de trabajo ordenado.

Documentación de la API

1import requests
2 
3headers = {"x-api-key": "gpx_live_YOUR_KEY"}
4payload = {
5  "country_code": "HK",
6  "city": "Central",
7  "session_type": "sticky",
8  "quantity": 5,
9  "protocol": "socks5"
10}
11 
12response = requests.post(
13  "https://jetproxy.io/api/v1/generate",
14  headers=headers,
15  json=payload,
16  timeout=30
17)
18print(response.json()["proxies"])

Paquetes sin condiciones ocultas

Más volumen significa menor precio por gigabyte. Sin suscripciones ni cargos ocultos.

1 GB$3.70

$3.70 / GB

Seleccionar

5 GB$18.00

$3.60 / GB

Seleccionar

10 GB$34.50

$3.45 / GB

Seleccionar

Popular

25 GB$80.00

$3.20 / GB

Seleccionar

50 GB$147.50

$2.95 / GB

Seleccionar

100 GB$270.00

$2.70 / GB

Seleccionar

250 GB$612.50

$2.45 / GB

Seleccionar

500 GB$1,100.00

$2.20 / GB

Seleccionar

1 TB$2,000.00

$2.00 / GB

Seleccionar

Paquete

Precio por GB

Total

1 GB

$3.70 / GB

$3.70Seleccionar

5 GB

$3.60 / GB

$18.00Seleccionar

10 GB

$3.45 / GB

$34.50Seleccionar

Popular

25 GB

$3.20 / GB

$80.00Seleccionar

50 GB

$2.95 / GB

$147.50Seleccionar

100 GB

$2.70 / GB

$270.00Seleccionar

250 GB

$2.45 / GB

$612.50Seleccionar

500 GB

$2.20 / GB

$1,100.00Seleccionar

1 TB

$2.00 / GB

$2,000.00Seleccionar

Métodos de pago disponibles

Preguntas que los compradores realmente hacen

¿Aún evalúas si el pool RAE de Hong Kong (China) se ajusta a tu caso de uso? Nuestro equipo responde preguntas reales en Telegram, las 24 horas, antes y después de tu compra.

Chatea en Telegram

¿Funcionarán para hacer scraping de HKTVmall y Fortress?

Ese es el caso de uso principal. El pool es residencial auténtico — la característica que buscan los sistemas anti-bot del e-commerce local — así que estas IPs pasan donde los rangos de datacenter quedan bloqueados. Los resultados igual dependen de tu huella digital, tus encabezados y el ritmo de las solicitudes, así que combina el proxy con una configuración limpia y una zona horaria de Hong Kong que coincida (HKT, UTC+8).

¿Puedo apuntar a una ciudad específica como Central o Causeway Bay?

Sí, según lo permita la profundidad del pool — elige la ciudad cuando generes la lista de proxies. Nuestras tablas de cobertura muestran la concurrencia en vivo de Central, Kwai Chung, Tsing Yi, Causeway Bay, Shatin, Tsuen Wan y más, así que puedes ver qué ciudades tienen la rotación más profunda antes de decidirte.

¿Las IPs se geolocalizan dentro de Hong Kong?

Sí — el pool resuelve a Hong Kong con 99.87% de precisión geográfica frente a Cloudflare y en varias bases de datos geográficas independientes en nuestro último benchmark, con nodos de salida confirmados en el colo de enrutamiento de Hong Kong (HKG). La alta precisión geográfica es la señal subyacente en la que se apoyan los geobloqueos de Hong Kong.

¿Puedo mantener una misma IP de Hong Kong para un flujo de varios pasos?

Sí. Usa una sesión persistente para conservar la misma IP de salida de Hong Kong — la retención promedio ronda las 5 horas y llega hasta 72 horas en nuestra medición de 3 días. Para escalar, rota por solicitud: la IP de salida cambia en cerca del 98% de las solicitudes, normalmente hacia un proveedor distinto, no solo a una dirección vecina.

¿Qué operadoras y ciudades de Hong Kong están cubiertas?

El pool abarca 9 ISP de Hong Kong encabezados por HKT, Hong Kong Broadband (HKBN), HGC, SmarTone y CommuniLink, a lo largo de 19 regiones y 25 ciudades — desde la Isla de Hong Kong (Central, Causeway Bay) hasta Kowloon (Sham Shui Po, Ho Man Tin) y los Nuevos Territorios (Shatin, Tsuen Wan, Tai Po, Kwai Chung).