Україна

Реальні домашні IP

Резидентські проксі — Україна

Українські резидентські проксі — це реальні IP-адреси українських домогосподарств, які виділяють побутові інтернет-провайдери, зокрема Kyivstar, Triolan, Lanet і Volia. З ними ви можете переглядати, парсити та перевіряти українські вітрини, ціни й контент як справжній місцевий користувач — у Києві, Львові, Одесі та Харкові, — а не з IP дата-центру, який Rozetka, Prom.ua і локальні гео-фільтри розпізнають і блокують з першого запиту.

Спробувати за $1.99/GB Увійти через Google

HTTP / SOCKS5Таргетинг за містом та ISPТрафік не згораєЧистота перевіряється щомісяця

546 369IP у пулі

25+Охоплення міст

418Мережі ISP

375 msМедіанна затримка

99.3%Строго чисті

Резидентські проксі для країни Україна — коротко

Резидентські проксі для країни Україна — це реальні IP-адреси з домогосподарств регіону Україна, видані споживчими ISP. Вони дають змогу переглядати, скрапити та перевіряти сайти, ціни й контент регіону Україна як справжній місцевий користувач — а не з дата-центрового IP, який локальні сайти позначають і блокують.

Тип пулу: Резидентський, кілька ISP
Охоплення міст: Kyiv, Lviv, Odesa
Топ ISP: Kyivstar · Triolan · Maxnet
Протоколи: HTTP, SOCKS5
Ротація: На кожен запит або sticky
Геоточність: 96.41%
Чистота пулу: 99.3% 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.3%

Частка дата-центрових0%

У будь-якому чорному списку0.14%

Низький ризик шахрайства (0–19)99.7%

Геоточність96.41%

Затримка та швидкість VPS → Cloudflare

Медіанна затримка375ms

Затримка p90 / p95416 / 455 ms

Успішність підключень98.9%

Пропускна здатність (медіана / p95)0.75 / 2.31 MB/s

Завантаження великих файлів90%

Склад мережі

Тип підключення100% резидентські

Мережі ISP (ASN)418

Режими ротаціїна запит · sticky

Топ операторівKyivstar · Triolan · Maxnet

Заміряно на 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.[/]")

Таргетинг аж до міста

«Сер. онлайн» — це середня кількість різних пристроїв, підключених і доступних в один і той самий момент, а не сумарний підсумок. Згруповано за рівнями Високий / Середній / Низький.

РегіониМістаПровайдери

Регіон	Затримка	Сер. онлайн	Пул
Kyiv City	365 ms	~7 633	Високий
Dnipropetrovsk Oblast	385 ms	~3 910	Високий
Lviv Oblast	374 ms	~3 817	Високий
Kharkiv Oblast	379 ms	~3 677	Високий
Odesa Oblast	381 ms	~3 537	Високий
Kyiv Oblast	369 ms	~2 793	Високий
Donetsk Oblast	396 ms	~2 048	Високий
Zaporizhzhia Oblast	372 ms	~1 862	Високий
Poltava Oblast	381 ms	~1 676	Високий
Vinnytsia Oblast	376 ms	~1 583	Середній
Ivano-Frankivsk Oblast	367 ms	~1 415	Середній
Mykolaiv Oblast	378 ms	~1 378	Середній
Khmelnytskyi Oblast	359 ms	~1 322	Середній
Zakarpattia Oblast	379 ms	~1 285	Середній
Cherkasy Oblast	364 ms	~1 229	Середній
Rivne Oblast	375 ms	~1 173	Середній
Zhytomyr Oblast	366 ms	~1 136	Низький
Ternopil Oblast	373 ms	~1 117	Низький
Sumy Oblast	371 ms	~1 024	Низький
Chernihiv Oblast	371 ms	~950	Низький
Volyn Oblast	368 ms	~912	Низький
Kherson Oblast	388 ms	~856	Низький
Chernivtsi Oblast	374 ms	~819	Низький
Kirovohrad Oblast	376 ms	~782	Низький
Luhansk Oblast	363 ms	~670	Низький

Місто	Затримка	Сер. онлайн	Пул
Kyiv	366 ms	~10 017	Високий
Lviv	374 ms	~9 198	Високий
Odesa	381 ms	~4 736	Високий
Kharkiv	379 ms	~3 506	Високий
Dnipro	386 ms	~2 231	Високий
Zaporizhzhia	372 ms	~1 594	Високий
Kryvyi Rih	384 ms	~1 503	Високий
Mykolaiv	378 ms	~1 366	Високий
Vinnytsia	376 ms	~1 184	Високий
Poltava	381 ms	~1 138	Середній
Chernihiv	371 ms	~1 002	Середній
Cherkasy	364 ms	~956	Середній
Khmelnytskyi	359 ms	~929	Середній
Chernivtsi	374 ms	~911	Середній
Zhytomyr	366 ms	~865	Середній
Sumy	371 ms	~838	Середній
Rivne	375 ms	~820	Низький
Ivano-Frankivsk	367 ms	~801	Низький
Ternopil	373 ms	~783	Низький
Kropyvnytskyi	376 ms	~765	Низький
Lutsk	368 ms	~729	Низький
Uzhhorod	379 ms	~710	Низький
Kremenchuk	382 ms	~692	Низький
Bila Tserkva	369 ms	~674	Низький
Kamianske	386 ms	~656	Низький

Провайдер	Затримка	Сер. онлайн	Пул
Kyivstarмобільний	379 ms	~13 679	Високий
Triolanфіксований	382 ms	~4 700	Високий
Maxnetфіксований	374 ms	~4 280	Високий
Eksintechфіксований	377 ms	~3 878	Високий
Lanetфіксований	336 ms	~3 305	Високий
HomeNetфіксований	387 ms	~2 885	Середній
Voliaфіксований	379 ms	~2 866	Середній
TENETфіксований	387 ms	~2 751	Середній
Vodafone Ukraineфіксований	373 ms	~2 541	Середній
Datagroupфіксований	400 ms	~2 407	Низький
Ukrtelecomфіксований	389 ms	~1 452	Низький
Dovecomфіксований	327 ms	~1 376	Низький
Donbass Electronic Communicationsфіксований	419 ms	~1 261	Низький
Crystal Telecomфіксований	390 ms	~1 223	Низький

Геоточність — кожен IP, що продається як Україна, резолвиться в країну Україна за трьома незалежними гео-базами (db-ip, MaxMind, ipinfo); висока геоточність — це сигнал, на який спираються локальні гео-фільтри.

Проксі для країни Україна за сценаріями використання

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

E-commerce та аналіз ринку

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

Моніторинг вітрин
Відстеження локальних цін
Дослідження продавців

RozetkaProm.uaEpicentrAlloComfy

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

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

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

TelegramFacebookInstagramTikTokYouTube

Тревел та аналіз цін

Знімайте тарифи на авіаквитки та готелі так, як їх бачить місцевий клієнт.

Гео-залежні тарифи
Моніторинг пропозицій
Порівняння розцінок

Tickets.uaKiwi.comSkyUp AirlinesUkraine International AirlinesProizd

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

Перевіряйте регіональні каталоги та гео-фільтри з потрібної локації.

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

MegogoSweet.tvKyivstar TVOLL.TVNetflix

Оголошення та локальні лістинги

Відстежуйте товари б/в, авто та оренду на локальних дошках оголошень.

Моніторинг оголошень
Відстеження цін
Регіональне охоплення

OLXAUTO.RIARIA.comBesplatkaObyava

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

Резидентські 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": "UA",
6  "city": "Kyiv",
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

Чи підійдуть вони для парсингу Rozetka і Prom.ua?

Це основний сценарій використання. Пул повністю резидентський — саме та властивість, яку шукають антибот-системи місцевих маркетплейсів, — тож ці IP проходять там, де діапазони дата-центрів блокуються. Результат усе одно залежить від вашого відбитка, заголовків і темпу запитів, тому поєднуйте проксі з чистою конфігурацією та відповідним українським часовим поясом (EET/EEST).

Чи можу я націлитися на конкретне місто, наприклад Київ або Львів?

Так, якщо дозволяє глибина пулу — оберіть місто під час генерації списку проксі. Наші таблиці покриття показують актуальну кількість одночасно доступних IP по Києву, Львову, Одесі, Харкову, Дніпру та інших містах, тож ви бачите, де доступна найглибша ротація, ще до початку роботи.

Чи визначається геолокація цих IP як Україна?

Так — за підсумками нашого останнього бенчмарку пул визначається як Україна з точністю геолокації 96,41% за даними Cloudflare і незалежних гео-баз, а вихідні вузли підтверджені через шлюзи Києва (KBP) і Варшави (WAW). Висока точність геолокації — це базовий сигнал, на який спираються українські гео-фільтри.

Чи можу я утримати один український IP протягом багатокрокового сценарію?

Так. Використовуйте sticky-сесію, щоб зберігати ту саму українську вихідну IP-адресу — середній час утримання близько 4,6 години та до 72 годин за нашими 3-денними вимірюваннями. Для масштабу застосовуйте ротацію на кожен запит: вихідна IP-адреса змінюється приблизно у 97% запитів, зазвичай переходячи на іншого провайдера, а не просто на сусідню адресу.

Які українські оператори та міста охоплено?

Пул охоплює 14 українських провайдерів на чолі з Kyivstar, Triolan, Lanet, Volia, Maxnet Telecom і Ukrtelecom, у 30 областях і 25 містах — від Києва, Львова й Одеси до Харкова, Дніпра, Вінниці та Чернівців.