Rumania

IP rumahan asli

Proxy residensial Rumania

Proxy residensial Rumania adalah alamat IP asli dari rumah tangga di Rumania, yang dialokasikan oleh ISP konsumen seperti RCS & RDS (Digi), Orange Romania, Vodafone Romania dan NextGen Communications. Dengan proxy ini Anda bisa menjelajah, melakukan scraping, dan memverifikasi etalase toko, harga, serta konten Rumania layaknya pengguna asli di dalam negeri — di Bucharest, Cluj-Napoca, Timișoara dan Iași — alih-alih dari IP datacenter yang langsung ditandai dan diblokir oleh eMAG, Altex maupun geo-gate lokal.

Coba seharga $1.99/GB Masuk dengan Google

HTTP / SOCKS5Penargetan kota & ISPTraffic tidak pernah kedaluwarsaDiverifikasi bersih setiap bulan

33.882IP dalam pool

25+Kota terjangkau

17Jaringan ISP

376 msLatensi median

99.5%Benar-benar bersih

Sekilas tentang proxy residensial Rumania

Proxy residensial Rumania adalah alamat IP asli dari rumah tangga Rumania, yang diberikan oleh ISP konsumen. IP ini memungkinkan Anda menjelajah, melakukan scraping, dan memverifikasi situs web, harga, serta konten Rumania layaknya pengguna lokal sungguhan — bukan dari IP datacenter yang ditandai dan diblokir oleh situs lokal.

Jenis pool: Residensial, multi-ISP
Kota terjangkau: Bucharest, Timișoara, Arad
ISP teratas: RCS & RDS (Digi) · Orange Romania · Vodafone Romania
Protokol: HTTP, SOCKS5
Rotasi: Per-request atau sticky
Akurasi geo: 100%
Kebersihan pool: 99.5% clean
Harga: from $2.00/GB
Terakhir diukur: 2026-06-23
Dukungan: 24/7

Mengapa tim memilih pool Rumania kami

IP residensial asli, penargetan presisi, dan kualitas yang tidak perlu Anda percayai begitu saja.

IP residensial asli

Koneksi rumahan sungguhan dari ISP konsumen Rumania — bukan rentang datacenter yang langsung diblokir.

Penargetan kota & ISP

Targetkan kota dan operator tertentu sejauh kedalaman pool memungkinkan — hingga ke level penyedia.

Rotasi atau sticky

Rotasi per-request untuk skala besar, atau sesi sticky hingga ~72 jam untuk alur multi-langkah.

HTTP & SOCKS5

Langsung berfungsi dengan klien, scraper, atau stack otomasi apa pun tanpa konfigurasi tambahan.

Bersumber secara etis

IP dari jaringan residensial opt-in — pengguna nyata yang menyetujui untuk berbagi bandwidth.

Diverifikasi bersih, tiap bulan

Kami mengukur ulang pool setiap bulan dan mempublikasikan angkanya, agar selalu mutakhir.

Kualitas yang bisa Anda verifikasi

Setiap bulan kami menjalankan benchmark yang sama — sampel acak IP diberi skor oleh Scamalytics, latensi diuji dari VPS netral, dan akurasi geo diperiksa lintas basis data independen. Angka di bawah mencerminkan kondisi produksi, bukan hasil lab skenario terbaik.

Kebersihan Scamalytics · 100.000 IP

Benar-benar bersih99.5%

Kontaminasi datacenter0%

Ada di blacklist mana pun0.5%

Risiko penipuan rendah (0–19)99.5%

Akurasi geo100%

Latensi & kecepatan VPS → Cloudflare

Latensi median376ms

Latensi p90 / p95413 / 453 ms

Keberhasilan koneksi98.5%

Throughput (median / p95)1.36 / 2.34 MB/s

Penyelesaian file besar98%

Komposisi jaringan

Jenis koneksi100% residensial

Jaringan ISP (ASN)17

Mode rotasiper-request · sticky

Operator teratasRCS & RDS (Digi) · Orange Romania · Vodafone Romania

Diukur pada 100.000 alamat dari VPS netral terhadap edge Cloudflare, akurat per benchmark terakhir. Pengujian ulang mungkin berbeda dalam margin kecil, tetapi angka-angka ini sepenuhnya mencerminkan orde besarannya dan menjadi dasar yang kuat untuk menilai apakah pool cocok untuk kasus penggunaan Anda. Tingkat keberhasilan scraping per-target tidak dipublikasikan — hal itu bergantung pada fingerprint dan pengaturan Anda, bukan hanya pada IP.

benchmark.py — benchmark pool terbuka

Benchmark terbuka di balik angka-angka di atas. Ia mengambil sampel acak IP pool dan mengukur empat hal — kebersihan (risiko penipuan Scamalytics, datacenter, blacklist, dan akurasi geo), latensi (round-trip edge Cloudflare dan ip-api), rotasi (IP unik, ASN, dan subnet /24), serta throughput (kecepatan unduh dan time-to-first-byte) — lalu melaporkan masing-masing. Skrip ini dipublikasikan secara utuh agar metodologi di balik setiap angka tetap terbuka untuk diperiksa.

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

Targetkan hingga ke level kota

«Rata-rata online» adalah jumlah rata-rata perangkat berbeda yang terhubung dan tersedia pada saat bersamaan — bukan total kumulatif. Dikelompokkan menjadi Tinggi / Sedang / Rendah.

WilayahKotaPenyedia

Wilayah	Latensi	Rata-rata online	Pool
Bucharest	378 ms	~779	Tinggi
Ilfov	366 ms	~168	Tinggi
Timiș County	366 ms	~160	Tinggi
Constanța County	374 ms	~139	Tinggi
Brașov County	370 ms	~124	Tinggi
Arad County	371 ms	~119	Tinggi
Mureș County	375 ms	~117	Tinggi
Prahova	380 ms	~105	Tinggi
Bihor County	376 ms	~95	Tinggi
Cluj County	375 ms	~95	Tinggi
Dolj	370 ms	~94	Sedang
Iași County	393 ms	~87	Sedang
Suceava	383 ms	~83	Sedang
Arges	369 ms	~77	Sedang
Satu Mare County	388 ms	~71	Sedang
Alba County	371 ms	~65	Sedang
Dâmbovița County	383 ms	~62	Sedang
Galați County	373 ms	~59	Sedang
Bacău County	388 ms	~53	Sedang
Hunedoara County	368 ms	~50	Sedang
Buzău County	384 ms	~48	Rendah
Gorj County	388 ms	~47	Rendah
Maramureş	373 ms	~47	Rendah
Brăila County	375 ms	~43	Rendah
Caraș-Severin County	375 ms	~43	Rendah
Harghita County	384 ms	~40	Rendah
Neamț County	393 ms	~40	Rendah
Sibiu County	392 ms	~39	Rendah
Bistrița-Năsăud County	379 ms	~35	Rendah
Ialomița County	374 ms	~31	Rendah

Kota	Latensi	Rata-rata online	Pool
Bucharest	378 ms	~981	Tinggi
Timișoara	365 ms	~187	Tinggi
Arad	371 ms	~141	Tinggi
Constanța	372 ms	~121	Tinggi
Brasov	367 ms	~119	Tinggi
Craiova	370 ms	~118	Tinggi
Ploieşti	372 ms	~112	Tinggi
Cluj-Napoca	375 ms	~110	Tinggi
Târgu Mureş	373 ms	~110	Tinggi
Iași	393 ms	~104	Sedang
Oradea	375 ms	~94	Sedang
Suceava	379 ms	~87	Sedang
Piteşti	366 ms	~78	Sedang
Satu Mare	387 ms	~77	Sedang
Targoviste	379 ms	~70	Sedang
Alba Iulia	372 ms	~70	Sedang
Galati	372 ms	~63	Rendah
Chiajna	362 ms	~56	Rendah
Brăila	375 ms	~55	Rendah
Târgu Jiu	384 ms	~52	Rendah
Buzău	385 ms	~46	Rendah
Baia Mare	373 ms	~45	Rendah
Reşiţa	378 ms	~42	Rendah
Deva	364 ms	~39	Rendah
Alexandria	370 ms	~37	Rendah

Penyedia	Latensi	Rata-rata online	Pool
RCS & RDS (Digi)tetap	372 ms	~2.427	Tinggi
Orange Romaniaseluler	388 ms	~272	Tinggi
Vodafone Romaniaseluler	402 ms	~229	Tinggi
NextGen Communicationstetap	382 ms	~24	Tinggi
Impuls Constructtetap	362 ms	~18	Sedang
Banat Telecom Satelittetap	374 ms	~7	Rendah
Sc Create Onlinetetap	373 ms	~7	Rendah
Gliga Comimpextetap	359 ms	~7	Rendah
Tia Conecttetap	384 ms	~7	Rendah
Sc Media Sudtetap	386 ms	~6	Rendah
Tv 2002tetap	375 ms	~5	Rendah
Smart Agencyseluler	354 ms	~5	Rendah

Akurasi geo — setiap IP yang dijual sebagai Rumania terpetakan ke Rumania di tiga basis data geo independen (db-ip, MaxMind, ipinfo); akurasi geo yang tinggi adalah sinyal yang diandalkan oleh geo-gate lokal.

Proxy Rumania berdasarkan kasus penggunaan

Disusun berdasarkan apa yang Anda lakukan, bukan berdasarkan platform. Layanan lokal dicantumkan di tempat yang relevan.

E-commerce & riset pasar

Periksa etalase, harga, dan listing lokal dari dalam pasar itu sendiri.

Pemantauan etalase
Pelacakan harga lokal
Riset penjual

eMAGAltexFlancoPC GarageDedeman

Verifikasi & performa iklan

Lihat bagaimana iklan, materi kreatif, dan SERP tampil bagi pengguna lokal — tanpa pergantian manual.

SERP lokal
Pengecekan kreatif
Halaman landing

FacebookInstagramTikTokYouTube

Perjalanan & intelijen harga

Tangkap tarif penerbangan dan hotel sebagaimana dilihat oleh pelanggan lokal.

Tarif berbasis geo
Pemantauan penawaran
Perbandingan tarif

Vola.roFly-GoTAROMeSkyWizz Air

Streaming & verifikasi geo

Verifikasi katalog yang dikunci wilayah dan geo-gate dari lokasi yang tepat.

Pengecekan geo
Verifikasi katalog
Ketersediaan regional

VoyoAntenaPLAYPrimaPlayHBO MaxNetflix

Iklan baris & listing lokal

Pantau barang bekas, mobil, dan sewaan di berbagai iklan baris lokal.

Pemantauan listing
Pelacakan harga
Cakupan regional

OLXAutovitPubli24LajumateAnuntul.ro

Dev & otomasi

IP residensial untuk pipeline, pengujian, dan pengumpulan data yang diizinkan melalui API.

Integrasi pipeline
Manajemen API
Sesi sticky

PythonScrapycURLGitHub

Selain situs lokal, pool Rumania yang sama juga berfungsi untuk platform global besar — Google, Meta, Amazon, YouTube, TikTok, dan Netflix — dilihat dari locale Rumania: harga lokal, iklan, katalog, SERP, dan konten.

Developer API

Buat endpoint dengan cakupan Rumania di dashboard, salin snippet yang sudah teruji, atau otomatiskan daftar proxy melalui API publik. Kota, ISP, sesi sticky, dan daftar tersimpan tetap dalam satu alur kerja yang rapi.

Dokumentasi API

1import requests
2 
3headers = {"x-api-key": "gpx_live_YOUR_KEY"}
4payload = {
5  "country_code": "RO",
6  "city": "Bucharest",
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"])

Paket tanpa syarat tersembunyi

Semakin besar volume, semakin rendah harga per gigabyte. Tanpa langganan atau biaya tersembunyi.

1 GB$3.70

$3.70 / GB

Pilih

5 GB$18.00

$3.60 / GB

Pilih

10 GB$34.50

$3.45 / GB

Pilih

Populer

25 GB$80.00

$3.20 / GB

Pilih

50 GB$147.50

$2.95 / GB

Pilih

100 GB$270.00

$2.70 / GB

Pilih

250 GB$612.50

$2.45 / GB

Pilih

500 GB$1,100.00

$2.20 / GB

Pilih

1 TB$2,000.00

$2.00 / GB

Pilih

Paket

Harga per GB

Total

1 GB

$3.70 / GB

$3.70Pilih

5 GB

$3.60 / GB

$18.00Pilih

10 GB

$3.45 / GB

$34.50Pilih

Populer

25 GB

$3.20 / GB

$80.00Pilih

50 GB

$2.95 / GB

$147.50Pilih

100 GB

$2.70 / GB

$270.00Pilih

250 GB

$2.45 / GB

$612.50Pilih

500 GB

$2.20 / GB

$1,100.00Pilih

1 TB

$2.00 / GB

$2,000.00Pilih

Metode pembayaran yang tersedia

Pertanyaan yang benar-benar ditanyakan pembeli

Masih menimbang apakah pool Rumania cocok untuk kasus penggunaan Anda? Tim kami menjawab pertanyaan nyata di Telegram, sepanjang waktu — sebelum dan sesudah Anda membeli.

Ngobrol di Telegram

Apakah proxy ini cocok untuk scraping eMAG dan Altex?

Itulah kasus penggunaan utamanya. Pool ini benar-benar residensial — karakteristik yang dicari sistem anti-bot marketplace lokal — sehingga IP ini lolos di tempat rentang datacenter diblokir. Hasilnya tetap bergantung pada fingerprint, header, dan ritme permintaan Anda, jadi pasangkan proxy dengan konfigurasi yang bersih dan zona waktu Rumania yang sesuai (EET/EEST).

Bisakah saya menargetkan kota tertentu seperti Bucharest atau Cluj-Napoca?

Bisa, selama kedalaman pool memungkinkan — pilih kotanya saat Anda membuat daftar proxy. Tabel cakupan kami menampilkan jumlah koneksi simultan secara real-time untuk Bucharest, Timișoara, Cluj-Napoca, Iași, Constanța dan lainnya, sehingga Anda bisa melihat kota mana yang memiliki rotasi terdalam sebelum memutuskan.

Apakah IP-nya tergeolokasi di dalam Rumania?

Ya — pool ini teresolusi ke Rumania dengan akurasi geo 100% terhadap Cloudflare dan di seluruh basis data geo independen pada benchmark terakhir kami, dengan exit node yang terkonfirmasi di Bucharest (OTP) dan dirutekan melalui hub terdekat seperti Sofia (SOF). Akurasi geo yang tinggi adalah sinyal mendasar yang diandalkan geo-gate Rumania.

Bisakah saya mempertahankan satu IP Rumania untuk alur multi-langkah?

Bisa. Gunakan sticky session untuk mempertahankan exit IP Rumania yang sama — rata-rata bertahan sekitar 4,4 jam dan hingga 72 jam dalam pengukuran 3 hari kami. Untuk skala besar, rotasikan per permintaan: exit IP berubah pada sekitar 98% permintaan, biasanya berpindah ke provider yang berbeda, bukan sekadar alamat tetangga.

Operator dan kota Rumania mana saja yang tercakup?

Pool ini mencakup 14 ISP Rumania yang dipimpin oleh RCS & RDS (Digi), Orange Romania, Vodafone Romania dan NextGen Communications, di 30 wilayah dan 25 kota — mulai dari Bucharest dan Timișoara hingga Cluj-Napoca, Iași, Constanța, Brasov dan Craiova.