Turquia

IPs residenciais reais

Proxies residenciais do Turquia

Os proxies residenciais turcos são endereços IP reais de residências na Turquia, atribuídos por provedores de internet residenciais como Türk Telekom, Turkcell Superonline, TurkNet e Türksat. Com eles, você navega, faz scraping e verifica lojas, preços e conteúdos turcos como um usuário real dentro do país — em Istambul, Ancara, Esmirna e Bursa — em vez de usar um IP de datacenter que a Trendyol, a Hepsiburada e os bloqueios geográficos locais identificam e barram na hora.

Teste por US$ 1,99/GB Entrar com o Google

HTTP / SOCKS5Segmentação por cidade e ISPTráfego que nunca expiraLimpeza verificada mensalmente

268.851IPs no pool

25+Cidades cobertas

75Redes de ISP

417 msLatência mediana

99.8%Estritamente limpos

Proxies residenciais do Turquia, em resumo

Os proxies residenciais do Turquia são endereços IP reais de residências Turquia, atribuídos por provedores de internet residenciais. Eles permitem navegar, fazer scraping e verificar sites, preços e conteúdos Turquia como um usuário genuíno dentro do país — em vez de partir de um IP de datacenter que os sites locais sinalizam e bloqueiam.

Tipo de pool: Residencial, multi-ISP
Cidades cobertas: Istanbul, Ankara, Izmir
Principais ISPs: Türk Telekom · Turkcell Superonline · TurkNet
Protocolos: HTTP, SOCKS5
Rotação: Por requisição ou fixa
Precisão geográfica: 99.6%
Limpeza do pool: 99.8% clean
Preços: from $2.00/GB
Última medição: 2026-06-23
Suporte: 24/7

Por que as equipes escolhem nosso pool Turquia

IPs residenciais reais, segmentação precisa e qualidade que você não precisa aceitar só na confiança.

IPs residenciais reais

Conexões residenciais genuínas de provedores de internet residenciais Turquia — não faixas de datacenter que são bloqueadas de imediato.

Segmentação por cidade e ISP

Segmente cidades e operadoras específicas onde a profundidade do pool permite — até o nível do provedor.

Rotativos ou fixos

Rotação por requisição para escala, ou sessões fixas de até ~72h para fluxos de várias etapas.

HTTP e SOCKS5

Funciona com qualquer cliente, scraper ou stack de automação, sem configuração extra.

Origem ética

IPs de uma rede residencial opt-in — usuários reais que consentiram em compartilhar banda.

Limpeza verificada, mensalmente

Medimos o pool novamente todos os meses e publicamos os números, para que se mantenham atualizados.

Qualidade que você pode verificar

Todo mês rodamos o mesmo benchmark — uma amostra aleatória de IPs avaliada com o Scamalytics, latência testada a partir de um VPS neutro e precisão geográfica conferida em bancos de dados independentes. Os números abaixo refletem a produção, não uma rodada de laboratório em condições ideais.

Limpeza Scamalytics · 100.000 IPs

Estritamente limpos99.8%

Contaminação por datacenter0%

Em alguma blacklist0.2%

Baixo risco de fraude (0–19)99.9%

Precisão geográfica99.6%

Latência e velocidade VPS → Cloudflare

Latência mediana417ms

Latência p90 / p95507 / 704 ms

Sucesso de conexão99.2%

Throughput (mediana / p95)0.85 / 1.82 MB/s

Conclusão de arquivos grandes98%

Composição da rede

Tipo de conexão100% residencial

Redes de ISP (ASN)75

Modos de rotaçãopor requisição · fixa

Principais operadorasTürk Telekom · Turkcell Superonline · TurkNet

Medido em 100.000 endereços a partir de um VPS neutro contra a edge da Cloudflare, com dados precisos até o último benchmark. Uma nova rodada pode variar por uma pequena margem, mas os números refletem plenamente a ordem de grandeza e são uma base sólida para avaliar se o pool atende ao seu caso de uso. O sucesso de scraping por alvo não é publicado — ele depende do seu fingerprint e da sua configuração, não apenas do IP.

benchmark.py — benchmark aberto do pool

O benchmark aberto por trás dos números acima. Ele pega uma amostra aleatória de IPs do pool e mede quatro coisas — limpeza (risco de fraude no Scamalytics, datacenter, blacklist e precisão geográfica), latência (ida e volta até a edge da Cloudflare e a ip-api), rotação (IPs únicos, ASNs e sub-redes /24) e throughput (velocidade de download e time-to-first-byte) — e então reporta cada uma. É publicado por completo para que a metodologia por trás de cada número permaneça aberta à inspeção.

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

Segmente até o nível da cidade

“Média online” é o número médio de dispositivos distintos conectados e disponíveis ao mesmo tempo — não um total acumulado. Agrupado em Alta / Média / Baixa.

RegiõesCidadesProvedores

Região	Latência	Média online	Pool
Istanbul	403 ms	~9.066	Alta
Ankara	423 ms	~3.019	Alta
İzmir Province	416 ms	~2.193	Alta
Antalya	420 ms	~1.201	Alta
Bursa Province	408 ms	~1.201	Alta
Mersin	435 ms	~652	Alta
Konya	417 ms	~532	Alta
Adana	427 ms	~473	Alta
Kocaeli	402 ms	~439	Alta
Gaziantep	438 ms	~417	Alta
Muğla	427 ms	~383	Média
Kayseri	424 ms	~341	Média
Manisa	416 ms	~328	Média
Hatay	426 ms	~328	Média
Sakarya	400 ms	~294	Média
Trabzon	432 ms	~273	Média
Samsun	428 ms	~273	Média
Balıkesir	418 ms	~268	Média
Canakkale	416 ms	~264	Média
Diyarbakır Province	447 ms	~264	Média
Tekirdağ	398 ms	~256	Baixa
Eskişehir	413 ms	~234	Baixa
Denizli	413 ms	~217	Baixa
Ordu	424 ms	~183	Baixa
Aydın	414 ms	~166	Baixa
Bolu	418 ms	~141	Baixa
Kahramanmaraş	419 ms	~136	Baixa
Zonguldak Province	427 ms	~132	Baixa
Çorum	416 ms	~132	Baixa
Bilecik	423 ms	~111	Baixa

Cidade	Latência	Média online	Pool
Istanbul	401 ms	~9.640	Alta
Ankara	428 ms	~3.112	Alta
Izmir	416 ms	~2.410	Alta
Bursa	408 ms	~1.409	Alta
Antalya	419 ms	~1.050	Alta
Mersin	437 ms	~675	Alta
Konya	417 ms	~441	Alta
Muğla	428 ms	~430	Alta
Çankaya	411 ms	~419	Alta
Adana	421 ms	~381	Média
Adapazarı	399 ms	~370	Média
Kayseri	425 ms	~354	Média
Merkez	415 ms	~343	Média
Beyoğlu	434 ms	~337	Média
Gaziantep	451 ms	~332	Média
Trabzon	433 ms	~321	Média
Samsun	430 ms	~283	Baixa
Denizli	415 ms	~245	Baixa
Ümraniye	423 ms	~228	Baixa
Balıkesir	411 ms	~218	Baixa
Muratpaşa	441 ms	~196	Baixa
Selçuklu	410 ms	~190	Baixa
Eskişehir	409 ms	~180	Baixa
Köseköy	397 ms	~180	Baixa
Bolu	417 ms	~174	Baixa

Provedor	Latência	Média online	Pool
Türk Telekomfixa	414 ms	~11.913	Alta
Turkcell Superonlinefixa	439 ms	~4.210	Alta
TurkNetfixa	389 ms	~2.727	Alta
Vodafonemóvel	402 ms	~1.678	Alta
Türksatfixa	402 ms	~1.499	Alta
Turkcellmóvel	505 ms	~661	Média
Millenicomfixa	412 ms	~462	Média
GibirNetfixa	412 ms	~223	Média
Netspeedfixa	404 ms	~170	Média
Atlantis Telekomfixa	380 ms	~105	Baixa
Andromeda TV Digital Platform Isletmeciligifixa	443 ms	~93	Baixa
High Speed For Internet Servicesfixa	499 ms	~65	Baixa
Fibim Fibernet GSM Sanayi VE Ticaret Anonim Sirketifixa	393 ms	~61	Baixa
Alfa Iletisim Hizmetleri Pazarlama Ticaretfixa	412 ms	~49	Baixa

Precisão geográfica — todo IP vendido como Turquia resolve para Turquia em três bancos de dados geográficos independentes (db-ip, MaxMind, ipinfo); a alta precisão geográfica é o sinal em que os geo-gates locais se baseiam.

Proxies do Turquia por caso de uso

Organizado pelo que você está fazendo, não pela plataforma. Os serviços locais aparecem onde fazem diferença.

E-commerce e pesquisa de mercado

Confira lojas, preços e anúncios locais de dentro do mercado.

Monitoramento de lojas
Acompanhamento de preços locais
Pesquisa de vendedores

TrendyolHepsiburadan11Amazon TurkiyeCiceksepeti

Verificação e desempenho de anúncios

Veja como anúncios, criativos e SERP aparecem para um usuário local — sem troca manual.

SERP local
Conferência de criativos
Páginas de destino

InstagramFacebookYouTubeTikTokX (Twitter)

Viagens e inteligência de preços

Capture tarifas de voos e hotéis do jeito que um cliente local as vê.

Tarifas com preço por geo
Monitoramento de ofertas
Comparação de tarifas

EnuygunObiletTurnaTurkish AirlinesPegasus Airlines

Streaming e verificação geográfica

Verifique catálogos com bloqueio regional e geo-gates a partir do local certo.

Conferências geográficas
Verificação de catálogo
Disponibilidade regional

BluTVExxenGainTabiiTOD (beIN Connect)

Classificados e anúncios locais

Monitore usados, veículos e aluguéis nos classificados locais.

Monitoramento de anúncios
Acompanhamento de preços
Cobertura regional

SahibindenLetgoDolapGardropsModaCruz

Dev e automação

IPs residenciais para pipelines, testes e coleta de dados permitida via API.

Integração de pipeline
Gerenciamento de API
Sessões fixas

PythonScrapycURLGitHub

Além dos sites locais, o mesmo pool Turquia funciona para as grandes plataformas globais — Google, Meta, Amazon, YouTube, TikTok e Netflix — vistas a partir da localidade Turquia: preços locais, anúncios, catálogos, SERP e conteúdo.

Desenvolvedor API

Gere endpoints com escopo no Turquia pelo painel, copie snippets testados ou automatize listas de proxies pela API pública. Cidade, ISP, sessões fixas e listas salvas ficam em um único fluxo de trabalho organizado.

Documentação da API

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

Pacotes sem condições ocultas

Maior volume significa menor preço por gigabyte. Sem assinaturas nem taxas ocultas.

1 GB$3.70

$3.70 / GB

Selecionar

5 GB$18.00

$3.60 / GB

Selecionar

10 GB$34.50

$3.45 / GB

Selecionar

Popular

25 GB$80.00

$3.20 / GB

Selecionar

50 GB$147.50

$2.95 / GB

Selecionar

100 GB$270.00

$2.70 / GB

Selecionar

250 GB$612.50

$2.45 / GB

Selecionar

500 GB$1,100.00

$2.20 / GB

Selecionar

1 TB$2,000.00

$2.00 / GB

Selecionar

Pacote

Preço por GB

Total

1 GB

$3.70 / GB

$3.70Selecionar

5 GB

$3.60 / GB

$18.00Selecionar

10 GB

$3.45 / GB

$34.50Selecionar

Popular

25 GB

$3.20 / GB

$80.00Selecionar

50 GB

$2.95 / GB

$147.50Selecionar

100 GB

$2.70 / GB

$270.00Selecionar

250 GB

$2.45 / GB

$612.50Selecionar

500 GB

$2.20 / GB

$1,100.00Selecionar

1 TB

$2.00 / GB

$2,000.00Selecionar

Métodos de pagamento disponíveis

As perguntas que os compradores realmente fazem

Ainda em dúvida se o pool Turquia atende ao seu caso de uso? Nossa equipe responde perguntas reais no Telegram, a qualquer hora — antes e depois da compra.

Conversar no Telegram

Eles funcionam para fazer scraping da Trendyol e da Hepsiburada?

Esse é o principal caso de uso. O pool é genuinamente residencial — a característica que os sistemas antibot dos marketplaces locais procuram — então esses IPs passam onde as faixas de datacenter são bloqueadas. Os resultados ainda dependem do seu fingerprint, dos cabeçalhos e do ritmo das requisições, então combine o proxy com uma configuração limpa e um fuso horário turco correspondente (TRT, UTC+3).

Posso mirar uma cidade específica, como Istambul ou Ancara?

Sim, quando a profundidade do pool permite — escolha a cidade ao gerar a lista de proxies. Nossas tabelas de cobertura mostram a concorrência ao vivo em Istambul, Ancara, Esmirna, Bursa, Antália e outras, para você ver quais cidades têm a rotação mais profunda antes de se comprometer.

Os IPs têm geolocalização dentro da Turquia?

Sim — o pool resolve para a Turquia com 99,6% de precisão geográfica em relação ao Cloudflare e a bases de geolocalização independentes em nosso último benchmark, com nós de saída confirmados em Istambul (IST). A alta precisão geográfica é o sinal subjacente em que os bloqueios geográficos turcos se baseiam.

Posso manter um único IP turco durante um fluxo de várias etapas?

Sim. Use uma sessão fixa (sticky) para manter o mesmo IP de saída turco — a duração média é de cerca de 4,3 horas e chega a 72 horas em nossa medição de 3 dias. Para escala, rotacione a cada requisição: o IP de saída muda em 97% das requisições, normalmente para um provedor diferente, e não apenas para um endereço vizinho.

Quais operadoras e cidades turcas têm cobertura?

O pool abrange 14 ISPs turcos, liderados por Türk Telekom, Turkcell Superonline, TurkNet, Türksat e Vodafone, em 30 regiões e 25 cidades — de Istambul, Ancara e Esmirna a Bursa, Antália, Mersin, Konya e Adana.