Colombia

IPs de hogares reales

Proxies residenciales de Colombia

Los proxies residenciales colombianos son direcciones IP reales de hogares de Colombia, asignadas por proveedores de internet domésticos como Claro (Telmex), Movistar, ETB y Tigo. Te permiten navegar, hacer scraping y verificar tiendas, precios y contenido colombianos como un usuario genuino dentro del país —en Bogotá, Medellín, Cali y Barranquilla— en lugar de hacerlo desde una IP de centro de datos que Mercado Libre Colombia, Falabella 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

286,163IPs en el pool

25+Ciudades cubiertas

137Redes de ISP

366 msLatencia mediana

99.4%Estrictamente limpias

Proxies residenciales de Colombia, de un vistazo

Los proxies residenciales de Colombia son direcciones IP reales de hogares Colombia, asignadas por ISP de consumo. Te permiten navegar, hacer scraping y verificar sitios, precios y contenido Colombia 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: Bogotá, Medellín, Cali
Principales ISP: Claro Colombia · Movistar (Telefónica) · ETB
Protocolos: HTTP, SOCKS5
Rotación: Por solicitud o fija
Precisión geográfica: 99.97%
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 Colombia

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 Colombia, 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.17%

Bajo riesgo de fraude (0–19)99.3%

Precisión geográfica99.97%

Latencia y velocidad VPS → Cloudflare

Latencia mediana366ms

Latencia p90 / p95460 / 604 ms

Conexiones exitosas98.6%

Rendimiento (mediana / p95)0.48 / 2.36 MB/s

Finalización de archivos grandes92%

Composición de la red

Tipo de conexión100% residencial

Redes de ISP (ASN)137

Modos de rotaciónpor solicitud · fija

Principales operadoresClaro Colombia · Movistar (Telefónica) · ETB

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
Bogota D.C.	355 ms	~8,117	Alto
Antioquia	369 ms	~4,089	Alto
Valle del Cauca Department	375 ms	~2,784	Alto
Cundinamarca	371 ms	~1,573	Alto
Atlántico	365 ms	~805	Alto
Santander Department	371 ms	~748	Alto
Nariño	381 ms	~715	Alto
Huila Department	361 ms	~703	Alto
Departamento de Bolívar	362 ms	~638	Alto
Risaralda Department	364 ms	~634	Medio
Magdalena Department	357 ms	~581	Medio
Tolima Department	359 ms	~549	Medio
Cauca Department	365 ms	~451	Medio
Norte de Santander Department	375 ms	~423	Medio
Departamento de Córdoba	369 ms	~415	Medio
Caldas Department	390 ms	~386	Medio
Departamento de Boyacá	370 ms	~358	Medio
Meta Department	383 ms	~358	Medio
Cesar Department	370 ms	~244	Bajo
Quindío Department	377 ms	~171	Bajo
Sucre Department	387 ms	~159	Bajo
Arauca Department	362 ms	~146	Bajo
La Guajira Department	391 ms	~142	Bajo
Departamento del Caquetá	402 ms	~110	Bajo
Departamento del Chocó	357 ms	~65	Bajo
Putumayo Department	412 ms	~57	Bajo
Casanare Department	367 ms	~37	Bajo

Ciudad	Latencia	Prom. en línea	Pool
Bogotá	352 ms	~8,936	Alto
Medellín	366 ms	~3,565	Alto
Cali	381 ms	~2,103	Alto
Barranquilla	364 ms	~932	Alto
Soacha	384 ms	~859	Alto
Cartagena	361 ms	~729	Alto
Pereira	366 ms	~703	Alto
Yumbo	336 ms	~687	Alto
Santa Marta	354 ms	~671	Alto
Bucaramanga	369 ms	~645	Medio
Pasto	378 ms	~630	Medio
Bogota	407 ms	~599	Medio
Ibague	366 ms	~557	Medio
Popayán	363 ms	~448	Medio
Neiva	362 ms	~442	Medio
Manizales	396 ms	~416	Medio
Villavicencio	388 ms	~375	Bajo
Envigado	374 ms	~370	Bajo
Cúcuta	375 ms	~359	Bajo
Pitalito	360 ms	~323	Bajo
Rionegro	397 ms	~239	Bajo
Fontibón	361 ms	~234	Bajo
Planeta Rica	366 ms	~224	Bajo
Kennedy	370 ms	~208	Bajo
Valledupar	364 ms	~203	Bajo

Proveedor	Latencia	Prom. en línea	Pool
Claro Colombiafijo	340 ms	~9,980	Alto
Movistar (Telefónica)fijo	347 ms	~4,437	Alto
ETBfijo	314 ms	~3,048	Alto
Tigo (UNE/EPM)fijo	374 ms	~2,332	Alto
Tigofijo	417 ms	~1,535	Alto
Celsia Colombia E.S.P.fijo	338 ms	~977	Medio
EMCALIfijo	391 ms	~506	Medio
Hv Televisionfijo	352 ms	~506	Medio
Velonetfijo	337 ms	~500	Medio
Conexion Digital Expressfijo	353 ms	~395	Bajo
Sinergy Soluciones Integralesfijo	361 ms	~320	Bajo
Sp Sistemas Palaciosfijo	382 ms	~320	Bajo
Somos Networks Colombia BICfijo	345 ms	~302	Bajo
Liberty Networks De Colombiafijo	373 ms	~297	Bajo

Precisión geográfica: cada IP vendida como Colombia resuelve a Colombia 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 Colombia 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 ColombiaFalabella ColombiaÉxitoAlkostoLinio Colombia

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

FacebookInstagramTikTokYouTube

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 ColombiaAviancaLATAM ColombiaWingoAviatur

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

Caracol PlayRCN (Deportes RCN)Win Sports+ / Win PlayDGO (DirecTV Go)Max Colombia

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

OLX ColombiaTuCarroCarroyaMercado Libre VehículosKavak Colombia

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

Desarrollador API

Genera endpoints acotados a Colombia 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": "CO",
6  "city": "Bogotá",
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 Colombia 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 en Mercado Libre Colombia y Falabella?

Ese es el uso principal. El pool es residencial genuino —la característica que buscan los sistemas anti-bot de los marketplaces locales—, así que estas IPs pasan donde los rangos de centro de datos quedan bloqueados. Los resultados igual dependen de tu fingerprint, tus encabezados y el ritmo de tus solicitudes, así que combina el proxy con una configuración limpia y una zona horaria colombiana acorde (COT, UTC-5).

¿Puedo apuntar a una ciudad específica como Bogotá o Medellín?

Sí, cuando la profundidad del pool lo permite —elige la ciudad al generar la lista de proxies—. Nuestras tablas de cobertura muestran la concurrencia en vivo de Bogotá, Medellín, Cali, Barranquilla, Cartagena y más, así que puedes ver qué ciudades tienen la rotación más profunda antes de decidir.

¿Las IPs se geolocalizan dentro de Colombia?

Sí: el pool resuelve a Colombia con 99.97% de precisión geográfica frente a Cloudflare y en bases de datos de geolocalización independientes en nuestro último benchmark, con nodos de salida confirmados en Bogotá (BOG) y Medellín (MDE). La alta precisión geográfica es la señal subyacente en la que se apoyan los bloqueos geográficos colombianos.

¿Puedo mantener una misma IP colombiana durante un flujo de varios pasos?

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

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

El pool abarca 14 ISPs colombianos encabezados por Claro (Telmex), Movistar, ETB, Tigo y EPM/UNE, en 27 regiones y 25 ciudades —desde Bogotá, Medellín y Cali hasta Barranquilla, Cartagena, Pereira, Santa Marta y Bucaramanga.