Колумбия

Реальные домашние IP

Резидентные прокси — Колумбия

Колумбийские резидентные прокси — это реальные IP-адреса из колумбийских домохозяйств, выданные домашними интернет-провайдерами, такими как Claro (Telmex), Movistar, ETB и Tigo. С ними можно просматривать, парсить и проверять колумбийские витрины, цены и контент как настоящий местный пользователь — в Боготе, Медельине, Кали и Барранкилье, — а не с IP дата-центра, который Mercado Libre Colombia, Falabella и местные гео-фильтры сразу распознают и блокируют.

Попробовать за $1.99/GB Войти через Google

HTTP / SOCKS5Таргетинг по городу и ISPТрафик не сгораетЧистота проверяется ежемесячно

286 163IP в пуле

25+Охват городов

137Сети ISP

366 мсМедианная задержка

99.4%Строго чистые

Резидентные прокси для страны Колумбия — кратко

Резидентные прокси для страны Колумбия — это реальные IP-адреса из домохозяйств региона Колумбия, выданные пользовательскими ISP. Они позволяют просматривать, скрапить и проверять сайты, цены и контент региона Колумбия как настоящий местный пользователь — а не с дата-центрового IP, который локальные сайты помечают и блокируют.

Тип пула: Резидентный, несколько ISP
Охват городов: Bogotá, Medellín, Cali
Топ ISP: Claro Colombia · Movistar (Telefónica) · ETB
Протоколы: HTTP, SOCKS5
Ротация: На каждый запрос или sticky
Геоточность: 99.97%
Чистота пула: 99.4% clean
Тарифы: from $2.00/GB
Последний замер: 2026-06-23
Поддержка: 24/7

Почему команды выбирают наш пул региона Колумбия

Реальные резидентные IP, точный таргетинг и качество, которое не нужно принимать на веру.

Реальные резидентные IP

Настоящие домашние подключения от пользовательских ISP региона Колумбия — а не дата-центровые диапазоны, которые блокируются с ходу.

Таргетинг по городу и ISP

Нацеливайтесь на отдельные города и операторов там, где это позволяет глубина пула — вплоть до провайдера.

Ротация или sticky

Ротация на каждый запрос для масштаба или sticky-сессии до ~72 ч для многошаговых сценариев.

HTTP и SOCKS5

Работает с любым клиентом, скрапером или стеком автоматизации из коробки.

Этичный источник

IP из резидентной сети с явным согласием участников — реальные пользователи, согласившиеся делиться трафиком.

Проверенная чистота, ежемесячно

Мы заново замеряем пул каждый месяц и публикуем цифры, чтобы они оставались актуальными.

Качество, которое можно проверить

Каждый месяц мы прогоняем один и тот же бенчмарк — случайная выборка IP оценивается по Scamalytics, задержка тестируется с нейтрального VPS, а геоточность сверяется по независимым базам. Цифры ниже отражают боевую среду, а не идеальный лабораторный прогон.

Чистота Scamalytics · 100 000 IP

Строго чистые99.4%

Доля дата-центровых0%

В любом чёрном списке0.17%

Низкий риск фрода (0–19)99.3%

Геоточность99.97%

Задержка и скорость VPS → Cloudflare

Медианная задержка366мс

Задержка p90 / p95460 / 604 мс

Успешность подключений98.6%

Пропускная способность (медиана / p95)0.48 / 2.36 MB/s

Загрузка крупных файлов92%

Состав сети

Тип подключения100% резидентные

Сети ISP (ASN)137

Режимы ротациина запрос · sticky

Топ операторовClaro Colombia · Movistar (Telefónica) · ETB

Замерено на 100 000 адресах с нейтрального VPS относительно edge-сети Cloudflare, актуально на момент последнего бенчмарка. Повторный прогон может отличаться на небольшую величину, но цифры полностью отражают порядок величины и служат надёжной основой, чтобы оценить, подходит ли пул под вашу задачу. Успешность скрапинга по конкретным целям не публикуется — она зависит от вашего отпечатка и настройки, а не только от IP.

benchmark.py — открытый бенчмарк пула

Открытый бенчмарк, стоящий за приведёнными выше цифрами. Он берёт случайную выборку IP пула и измеряет четыре вещи — чистоту (фрод-риск Scamalytics, дата-центр, чёрные списки и геоточность), задержку (круговой обход до edge Cloudflare и ip-api), ротацию (уникальные IP, ASN и подсети /24) и пропускную способность (скорость загрузки и время до первого байта) — после чего сообщает каждый показатель. Он опубликован целиком, чтобы методология за каждой цифрой оставалась открытой для проверки.

# -*- 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.[/]")

Таргетинг вплоть до города

«Сред. онлайн» — это среднее число различных устройств, подключённых и доступных в один и тот же момент, а не суммарный итог. Сгруппировано по уровням Высокий / Средний / Низкий.

РегионыГородаПровайдеры

Регион	Задержка	Сред. онлайн	Пул
Bogota D.C.	355 ms	~8 117	Высокий
Antioquia	369 ms	~4 089	Высокий
Valle del Cauca Department	375 ms	~2 784	Высокий
Cundinamarca	371 ms	~1 573	Высокий
Atlántico	365 ms	~805	Высокий
Santander Department	371 ms	~748	Высокий
Nariño	381 ms	~715	Высокий
Huila Department	361 ms	~703	Высокий
Departamento de Bolívar	362 ms	~638	Высокий
Risaralda Department	364 ms	~634	Средний
Magdalena Department	357 ms	~581	Средний
Tolima Department	359 ms	~549	Средний
Cauca Department	365 ms	~451	Средний
Norte de Santander Department	375 ms	~423	Средний
Departamento de Córdoba	369 ms	~415	Средний
Caldas Department	390 ms	~386	Средний
Departamento de Boyacá	370 ms	~358	Средний
Meta Department	383 ms	~358	Средний
Cesar Department	370 ms	~244	Низкий
Quindío Department	377 ms	~171	Низкий
Sucre Department	387 ms	~159	Низкий
Arauca Department	362 ms	~146	Низкий
La Guajira Department	391 ms	~142	Низкий
Departamento del Caquetá	402 ms	~110	Низкий
Departamento del Chocó	357 ms	~65	Низкий
Putumayo Department	412 ms	~57	Низкий
Casanare Department	367 ms	~37	Низкий

Город	Задержка	Сред. онлайн	Пул
Bogotá	352 ms	~8 936	Высокий
Medellín	366 ms	~3 565	Высокий
Cali	381 ms	~2 103	Высокий
Barranquilla	364 ms	~932	Высокий
Soacha	384 ms	~859	Высокий
Cartagena	361 ms	~729	Высокий
Pereira	366 ms	~703	Высокий
Yumbo	336 ms	~687	Высокий
Santa Marta	354 ms	~671	Высокий
Bucaramanga	369 ms	~645	Средний
Pasto	378 ms	~630	Средний
Bogota	407 ms	~599	Средний
Ibague	366 ms	~557	Средний
Popayán	363 ms	~448	Средний
Neiva	362 ms	~442	Средний
Manizales	396 ms	~416	Средний
Villavicencio	388 ms	~375	Низкий
Envigado	374 ms	~370	Низкий
Cúcuta	375 ms	~359	Низкий
Pitalito	360 ms	~323	Низкий
Rionegro	397 ms	~239	Низкий
Fontibón	361 ms	~234	Низкий
Planeta Rica	366 ms	~224	Низкий
Kennedy	370 ms	~208	Низкий
Valledupar	364 ms	~203	Низкий

Провайдер	Задержка	Сред. онлайн	Пул
Claro Colombiaфиксированный	340 ms	~9 980	Высокий
Movistar (Telefónica)фиксированный	347 ms	~4 437	Высокий
ETBфиксированный	314 ms	~3 048	Высокий
Tigo (UNE/EPM)фиксированный	374 ms	~2 332	Высокий
Tigoфиксированный	417 ms	~1 535	Высокий
Celsia Colombia E.S.P.фиксированный	338 ms	~977	Средний
EMCALIфиксированный	391 ms	~506	Средний
Hv Televisionфиксированный	352 ms	~506	Средний
Velonetфиксированный	337 ms	~500	Средний
Conexion Digital Expressфиксированный	353 ms	~395	Низкий
Sinergy Soluciones Integralesфиксированный	361 ms	~320	Низкий
Sp Sistemas Palaciosфиксированный	382 ms	~320	Низкий
Somos Networks Colombia BICфиксированный	345 ms	~302	Низкий
Liberty Networks De Colombiaфиксированный	373 ms	~297	Низкий

Геоточность — каждый IP, продаваемый как Колумбия, резолвится в страну Колумбия по трём независимым гео-базам (db-ip, MaxMind, ipinfo); высокая геоточность — это сигнал, на который опираются локальные гео-фильтры.

Прокси для страны Колумбия по сценариям использования

Организовано по тому, что вы делаете, а не по платформам. Локальные сервисы перечислены там, где они важны.

E-commerce и анализ рынка

Проверяйте витрины, цены и локальные листинги изнутри рынка.

Мониторинг витрин
Отслеживание локальных цен
Исследование продавцов

Mercado Libre ColombiaFalabella ColombiaÉxitoAlkostoLinio Colombia

Верификация и эффективность рекламы

Смотрите, как реклама, креативы и SERP отображаются локальному пользователю — без ручного переключения.

Локальная SERP
Проверка креативов
Лендинги

FacebookInstagramTikTokYouTube

Тревел и анализ цен

Снимайте тарифы на авиабилеты и отели так, как их видит местный клиент.

Гео-зависимые тарифы
Мониторинг предложений
Сравнение расценок

Despegar ColombiaAviancaLATAM ColombiaWingoAviatur

Стриминг и гео-верификация

Проверяйте региональные каталоги и гео-фильтры из нужной локации.

Гео-проверки
Верификация каталога
Региональная доступность

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

Объявления и локальные листинги

Отслеживайте товары б/у, авто и аренду на локальных досках объявлений.

Мониторинг объявлений
Отслеживание цен
Региональный охват

OLX ColombiaTuCarroCarroyaMercado Libre VehículosKavak Colombia

Разработка и автоматизация

Резидентные IP для пайплайнов, тестов и разрешённого сбора данных через API.

Интеграция в пайплайн
Управление через API
Sticky-сессии

PythonScrapycURLGitHub

Помимо локальных сайтов, тот же пул региона Колумбия работает с крупнейшими глобальными платформами — Google, Meta, Amazon, YouTube, TikTok и Netflix — в том виде, в каком они отображаются в локали региона Колумбия: локальные цены, реклама, каталоги, SERP и контент.

Для разработчиков API

Генерируйте эндпоинты с привязкой к стране Колумбия в панели управления, копируйте проверенные сниппеты или автоматизируйте списки прокси через публичный API. Город, ISP, sticky-сессии и сохранённые списки — всё в одном удобном рабочем процессе.

Документация 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"])

Пакеты без скрытых условий

Чем больше объём, тем ниже цена за гигабайт. Без подписок и скрытых платежей.

1 GB$3.70

$3.70 / GB

Выбрать

5 GB$18.00

$3.60 / GB

Выбрать

10 GB$34.50

$3.45 / GB

Выбрать

Популярный

25 GB$80.00

$3.20 / GB

Выбрать

50 GB$147.50

$2.95 / GB

Выбрать

100 GB$270.00

$2.70 / GB

Выбрать

250 GB$612.50

$2.45 / GB

Выбрать

500 GB$1,100.00

$2.20 / GB

Выбрать

1 TB$2,000.00

$2.00 / GB

Выбрать

Пакет

Цена за ГБ

Итого

1 GB

$3.70 / GB

$3.70Выбрать

5 GB

$3.60 / GB

$18.00Выбрать

10 GB

$3.45 / GB

$34.50Выбрать

Популярный

25 GB

$3.20 / GB

$80.00Выбрать

50 GB

$2.95 / GB

$147.50Выбрать

100 GB

$2.70 / GB

$270.00Выбрать

250 GB

$2.45 / GB

$612.50Выбрать

500 GB

$2.20 / GB

$1,100.00Выбрать

1 TB

$2.00 / GB

$2,000.00Выбрать

Доступные способы оплаты

Вопросы, которые покупатели задают на самом деле

Всё ещё взвешиваете, подойдёт ли пул региона Колумбия под вашу задачу? Наша команда отвечает на реальные вопросы в Telegram, круглосуточно — до и после покупки.

Написать в Telegram

Подойдут ли они для парсинга Mercado Libre Colombia и Falabella?

Это основной сценарий использования. Пул полностью резидентный — именно это свойство ищут антибот-системы местных маркетплейсов, — поэтому такие IP проходят там, где диапазоны дата-центров блокируются. Результат всё же зависит от вашего цифрового отпечатка, заголовков и темпа запросов, поэтому используйте прокси с чистой конфигурацией и соответствующим колумбийским часовым поясом (COT, UTC-5).

Можно ли таргетировать конкретный город, например Боготу или Медельин?

Да, где позволяет глубина пула, — выберите город при генерации списка прокси. Наши таблицы покрытия показывают актуальное число одновременных сессий для Боготы, Медельина, Кали, Барранкильи, Картахены и других городов, так что вы заранее видите, в каких городах самая глубокая ротация, прежде чем сделать выбор.

Геолоцируются ли IP внутри Колумбии?

Да — пул определяется как Колумбия с геоточностью 99,97% по данным Cloudflare и независимых гео-баз в нашем последнем бенчмарке, а выходные узлы подтверждены в Боготе (BOG) и Медельине (MDE). Высокая геоточность — это и есть тот базовый сигнал, на который опираются колумбийские гео-фильтры.

Можно ли удерживать один колумбийский IP в многошаговом сценарии?

Да. Используйте sticky-сессию, чтобы сохранить тот же колумбийский выходной IP — в среднем он удерживается около 4,8 часа, а в нашем трёхдневном замере удержание доходило до 72 часов. Для масштабирования меняйте IP на каждом запросе: выходной IP меняется в 96% запросов, обычно на адрес другого провайдера, а не просто на соседний.

Какие колумбийские операторы и города покрыты?

Пул охватывает 14 колумбийских ISP во главе с Claro (Telmex), Movistar, ETB, Tigo и EPM/UNE, в 27 регионах и 25 городах — от Боготы, Медельина и Кали до Барранкильи, Картахены, Перейры, Санта-Марты и Букараманги.