México

IPs de hogares reales

Proxies residenciales de México

Los proxies residenciales mexicanos son direcciones IP reales de hogares mexicanos, asignadas por ISP de consumo como Telmex (Infinitum), Total Play, Megacable e Izzi. Te permiten navegar, hacer scraping y verificar tiendas, precios y contenido de México como un usuario auténtico dentro del país —en Ciudad de México, Guadalajara, Monterrey y Tijuana— en lugar de hacerlo desde una IP de centro de datos que Mercado Libre, Coppel y los bloqueos geográficos 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

276,405IPs en el pool

25+Ciudades cubiertas

113Redes de ISP

304 msLatencia mediana

99.4%Estrictamente limpias

Proxies residenciales de México, de un vistazo

Los proxies residenciales de México son direcciones IP reales de hogares México, asignadas por ISP de consumo. Te permiten navegar, hacer scraping y verificar sitios, precios y contenido México 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: Benito Juarez, Mexico City, Guadalajara
Principales ISP: Telmex (Infinitum) · Total Play · Megacable
Protocolos: HTTP, SOCKS5
Rotación: Por solicitud o fija
Precisión geográfica: 100%
Limpieza del pool: 99.4% clean
Precios: from $2.00/GB
Última medición: 2026-06-23
Soporte: 24/7

Por qué los equipos eligen nuestro pool México

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 México, 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.4%

Contaminación de datacenter0%

En alguna lista negra0.29%

Bajo riesgo de fraude (0–19)99.5%

Precisión geográfica100%

Latencia y velocidad VPS → Cloudflare

Latencia mediana304ms

Latencia p90 / p95394 / 488 ms

Conexiones exitosas99.3%

Rendimiento (mediana / p95)1.59 / 4.02 MB/s

Finalización de archivos grandes86%

Composición de la red

Tipo de conexión100% residencial

Redes de ISP (ASN)113

Modos de rotaciónpor solicitud · fija

Principales operadoresTelmex (Infinitum) · Total Play · Megacable

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
Mexico City	303 ms	~5,654	Alto
México	305 ms	~1,953	Alto
Jalisco	314 ms	~1,896	Alto
Nuevo León	295 ms	~1,871	Alto
Baja California	262 ms	~1,330	Alto
Veracruz	320 ms	~1,264	Alto
Puebla	308 ms	~958	Alto
Guanajuato	307 ms	~950	Alto
Sonora	266 ms	~793	Alto
Sinaloa	290 ms	~698	Alto
Coahuila	293 ms	~694	Medio
Tamaulipas	297 ms	~669	Medio
Michoacán	304 ms	~657	Medio
Chihuahua	298 ms	~628	Medio
Querétaro	305 ms	~508	Medio
Yucatán	332 ms	~458	Medio
Chiapas	326 ms	~454	Medio
San Luis Potosí	301 ms	~392	Medio
Tabasco	322 ms	~355	Medio
Quintana Roo	328 ms	~351	Medio
Baja California Sur	289 ms	~281	Bajo
Hidalgo	317 ms	~260	Bajo
Aguascalientes	307 ms	~227	Bajo
Oaxaca	353 ms	~227	Bajo
Zacatecas	315 ms	~219	Bajo
Morelos	329 ms	~194	Bajo
Colima	287 ms	~186	Bajo
Durango	343 ms	~165	Bajo
Guerrero	313 ms	~157	Bajo
Tlaxcala	310 ms	~140	Bajo

Ciudad	Latencia	Prom. en línea	Pool
Benito Juarez	298 ms	~2,525	Alto
Mexico City	311 ms	~2,502	Alto
Guadalajara	327 ms	~1,530	Alto
Monterrey	296 ms	~1,454	Alto
Gustavo Adolfo Madero	316 ms	~1,354	Alto
Tijuana	254 ms	~1,331	Alto
Puebla City	308 ms	~1,316	Alto
Veracruz	314 ms	~972	Alto
León	313 ms	~849	Alto
Cuauhtémoc	284 ms	~826	Medio
Zapopan	266 ms	~773	Medio
Mexicali	282 ms	~773	Medio
Querétaro City	303 ms	~757	Medio
Hermosillo	255 ms	~742	Medio
Iztapalapa	301 ms	~742	Medio
Mérida	331 ms	~719	Medio
Torreón	292 ms	~673	Bajo
Culiacán	282 ms	~643	Bajo
San Luis Potosí City	297 ms	~635	Bajo
Ciudad Juárez	290 ms	~627	Bajo
Morelia	304 ms	~620	Bajo
Guadalupe	292 ms	~604	Bajo
Tuxtla Gutiérrez	325 ms	~566	Bajo
Reynosa	301 ms	~536	Bajo
Naucalpan	307 ms	~520	Bajo

Proveedor	Latencia	Prom. en línea	Pool
Telmex (Infinitum)fijo	296 ms	~9,404	Alto
Total Playfijo	294 ms	~6,615	Alto
Megacablefijo	313 ms	~4,733	Alto
Izzifijo	252 ms	~3,161	Alto
Alestrafijo	338 ms	~298	Alto
Velocom De CVfijo	340 ms	~74	Medio
Television POR Cable Tepa De C.Vfijo	292 ms	~44	Medio
Comunicación B15 de C.V.fijo	325 ms	~44	Medio
Fibra A LA Casafijo	289 ms	~39	Bajo
Soluciones de Tecnologia Jah de Cvfijo	328 ms	~39	Bajo
ENI NETWORKS SAPI de CVfijo	488 ms	~35	Bajo
Doornet de cvfijo	307 ms	~35	Bajo
Javier Tamayo Garciafijo	344 ms	~35	Bajo
Digy Networks De C.V.fijo	359 ms	~31	Bajo

Precisión geográfica: cada IP vendida como México resuelve a México 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 México 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

Mercado Libre MéxicoAmazon MexicoCoppelLiverpoolWalmart Mexico

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

FacebookInstagramTikTokYouTubeX (Twitter)

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

Despegar MéxicoVolarisVivaAerobusAeroméxicoPrice Travel

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

ViXTUDNClaro VideoAzteca DeportesHBO Max Mexico

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

Segundamano / VivanunciosMercado Libre AutosSeminuevosKavakSolo Autos

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 México funciona con las principales plataformas globales —Google, Meta, Amazon, YouTube, TikTok y Netflix— tal como se ven desde el mercado local México: precios locales, anuncios, catálogos, SERP y contenido.

Desarrollador API

Genera endpoints acotados a México 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": "MX",
6  "city": "Benito Juarez",
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 México 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 Mercado Libre y Coppel?

Ese es el caso de uso principal. El pool es residencial auténtico —la característica que buscan los sistemas anti-bot de los marketplaces locales—, así que estas IP pasan donde los rangos de centro de datos quedan bloqueados. Los resultados aún dependen de tu huella digital, encabezados y ritmo de solicitudes, así que combina el proxy con una configuración limpia y una zona horaria mexicana acorde (Centro, o Pacífico/Montaña en el noroeste).

¿Puedo apuntar a una ciudad específica como Ciudad de México o Guadalajara?

Sí, donde la profundidad del pool lo permita: elige la ciudad al generar la lista de proxies. Nuestras tablas de cobertura muestran la concurrencia en vivo de Ciudad de México, Guadalajara, Monterrey, Tijuana, Puebla y León, para que veas qué ciudades tienen la rotación más profunda antes de comprometerte.

¿Las IP geolocalizan dentro de México?

Sí —el pool resuelve a México con 100% de precisión geográfica frente a Cloudflare y en bases de datos geográficas independientes en nuestro último benchmark, con nodos de salida confirmados en Querétaro (QRO) y Guadalajara (GDL). La alta precisión geográfica es la señal de fondo en la que se apoyan los bloqueos geográficos mexicanos.

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

Sí. Usa una sesión persistente para conservar la misma IP de salida mexicana —la duración promedio ronda las 4.8 horas y hasta 72 horas en nuestra medición de 3 días—. Para escalar, rota por solicitud: la IP de salida cambia en alrededor del 96% de las solicitudes, normalmente a un proveedor distinto, no solo a una dirección vecina.

¿Qué operadores y ciudades de México están cubiertos?

El pool abarca 113 redes mexicanas encabezadas por Telmex (Infinitum), Total Play, Megacable, Izzi y Alestra, a lo largo de 30 regiones y 25 ciudades —desde Ciudad de México y Guadalajara hasta Monterrey, Tijuana, Puebla, León y Mexicali.