Meksika

Gerçek ev IP'leri

Meksika konut proxy'leri

Meksika konut proxy'leri, Telmex (Infinitum), Total Play, Megacable ve Izzi gibi ev kullanıcısı ISP'leri tarafından Meksika'daki hanelere atanan gerçek IP adresleridir. Mercado Libre, Coppel ve yerel coğrafi kısıtlamaların görür görmez işaretleyip engellediği bir veri merkezi IP'si yerine; gerçek bir yerel kullanıcı gibi — Mexico City, Guadalajara, Monterrey ve Tijuana genelinde — Meksika mağazalarında gezinmenize, fiyatlarını ve içeriklerini kazımanıza ve doğrulamanıza olanak tanır.

1,99 $/GB ile deneyin Google ile oturum açın

HTTP / SOCKS5Şehir ve ISP hedeflemeTrafik asla sona ermezHer ay temizliği doğrulanır

276.405Havuzdaki IP'ler

25+Kapsanan şehirler

113ISP ağları

304 msOrtanca gecikme

99.4%Tamamen temiz

Bir bakışta Meksika konut proxy'leri

Meksika konut proxy'leri, tüketici ISP'leri tarafından atanan Meksika hanelerine ait gerçek IP adresleridir. Bunlar, yerel sitelerin işaretleyip engellediği bir veri merkezi IP'si yerine, gerçek bir yerel kullanıcı gibi Meksika web sitelerini, fiyatlandırmalarını ve içeriklerini gezmenize, scrape etmenize ve doğrulamanıza olanak tanır.

Havuz tipi: Konut, çoklu ISP
Kapsanan şehirler: Benito Juarez, Mexico City, Guadalajara
Önde gelen ISP'ler: Telmex (Infinitum) · Total Play · Megacable
Protokoller: HTTP, SOCKS5
Rotasyon: İstek başına veya sabit
Coğrafi doğruluk: 100%
Havuz temizliği: 99.4% clean
Fiyatlandırma: from $2.00/GB
Son ölçüm: 2026-06-23
Destek: 7/24

Ekipler neden Meksika havuzumuzu seçiyor

Gerçek konut IP'leri, hassas hedefleme ve körü körüne güvenmek zorunda olmadığınız bir kalite.

Gerçek konut IP'leri

Meksika tüketici ISP'lerinden gelen hakiki ev bağlantıları — görülür görülmez engellenen veri merkezi aralıkları değil.

Şehir ve ISP hedefleme

Havuz derinliğinin elverdiği şehirleri ve operatörleri, sağlayıcı düzeyine kadar tek tek hedefleyin.

Rotasyonlu veya sabit

Ölçek için istek başına rotasyon ya da çok adımlı akışlar için ~72 saate kadar sabit oturumlar.

HTTP ve SOCKS5

Her istemci, scraper veya otomasyon yığınıyla ek yapılandırma gerektirmeden çalışır.

Etik kaynaklı

Bant genişliğini paylaşmaya rıza gösteren gerçek kullanıcılardan oluşan, isteğe bağlı katılımlı bir konut ağından gelen IP'ler.

Her ay temizliği doğrulanır

Havuzu her ay yeniden ölçer ve rakamları yayımlarız; böylece güncel kalırlar.

Doğrulayabileceğiniz kalite

Her ay aynı kıyaslamayı çalıştırıyoruz — rastgele bir IP örneği Scamalytics'e göre puanlanır, tarafsız bir VPS'ten gecikme testi yapılır ve coğrafi doğruluk bağımsız veritabanları arasında kontrol edilir. Aşağıdaki rakamlar en iyi durum laboratuvar koşullarını değil, üretimi yansıtır.

Temizlik Scamalytics · 100.000 IP

Tamamen temiz99.4%

Veri merkezi kirliliği0%

Herhangi bir kara listede0.29%

Düşük dolandırıcılık riski (0–19)99.5%

Coğrafi doğruluk100%

Gecikme ve hız VPS → Cloudflare

Ortanca gecikme304ms

p90 / p95 gecikme394 / 488 ms

Bağlantı başarısı99.3%

Veri çıkışı (ortanca / p95)1.59 / 4.02 MB/s

Büyük dosya tamamlama86%

Ağ bileşimi

Bağlantı tipi%100 konut

ISP ağları (ASN)113

Rotasyon modlarıistek başına · sabit

Önde gelen operatörlerTelmex (Infinitum) · Total Play · Megacable

Cloudflare'in uç ağına karşı tarafsız bir VPS'ten 100.000 adres üzerinde ölçülmüştür ve son kıyaslama itibarıyla geçerlidir. Tekrarlanan bir çalıştırma küçük bir farkla değişebilir, ancak rakamlar büyüklük mertebesini tam olarak yansıtır ve havuzun kullanım senaryonuza uyup uymadığını değerlendirmek için sağlam bir temel oluşturur. Hedef başına scraping başarısı yayımlanmaz — bu yalnızca IP'ye değil, parmak izinize ve kurulumunuza bağlıdır.

benchmark.py — açık havuz kıyaslaması

Yukarıdaki rakamların arkasındaki açık kıyaslama. Rastgele bir havuz IP örneği alır ve dört şeyi ölçer — temizlik (Scamalytics dolandırıcılık riski, veri merkezi, kara liste ve coğrafi doğruluk), gecikme (Cloudflare uç ağı ve ip-api gidiş-dönüşü), rotasyon (benzersiz IP'ler, ASN'ler ve /24 alt ağları) ve veri çıkışı (indirme hızı ve ilk bayta kadar geçen süre) — ardından her birini raporlar. Her rakamın arkasındaki yöntemin incelemeye açık kalması için tam olarak yayımlanmıştır.

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

Şehir düzeyine kadar hedefleyin

«Ort. çevrimiçi», aynı anda bağlı ve kullanılabilir olan farklı cihazların ortalama sayısıdır — kümülatif bir toplam değil. Yüksek / Orta / Düşük olarak gruplandırılmıştır.

BölgelerŞehirlerSağlayıcılar

Bölge	Gecikme	Ort. çevrimiçi	Havuz
Mexico City	303 ms	~5.654	Yüksek
México	305 ms	~1.953	Yüksek
Jalisco	314 ms	~1.896	Yüksek
Nuevo León	295 ms	~1.871	Yüksek
Baja California	262 ms	~1.330	Yüksek
Veracruz	320 ms	~1.264	Yüksek
Puebla	308 ms	~958	Yüksek
Guanajuato	307 ms	~950	Yüksek
Sonora	266 ms	~793	Yüksek
Sinaloa	290 ms	~698	Yüksek
Coahuila	293 ms	~694	Orta
Tamaulipas	297 ms	~669	Orta
Michoacán	304 ms	~657	Orta
Chihuahua	298 ms	~628	Orta
Querétaro	305 ms	~508	Orta
Yucatán	332 ms	~458	Orta
Chiapas	326 ms	~454	Orta
San Luis Potosí	301 ms	~392	Orta
Tabasco	322 ms	~355	Orta
Quintana Roo	328 ms	~351	Orta
Baja California Sur	289 ms	~281	Düşük
Hidalgo	317 ms	~260	Düşük
Aguascalientes	307 ms	~227	Düşük
Oaxaca	353 ms	~227	Düşük
Zacatecas	315 ms	~219	Düşük
Morelos	329 ms	~194	Düşük
Colima	287 ms	~186	Düşük
Durango	343 ms	~165	Düşük
Guerrero	313 ms	~157	Düşük
Tlaxcala	310 ms	~140	Düşük

Şehir	Gecikme	Ort. çevrimiçi	Havuz
Benito Juarez	298 ms	~2.525	Yüksek
Mexico City	311 ms	~2.502	Yüksek
Guadalajara	327 ms	~1.530	Yüksek
Monterrey	296 ms	~1.454	Yüksek
Gustavo Adolfo Madero	316 ms	~1.354	Yüksek
Tijuana	254 ms	~1.331	Yüksek
Puebla City	308 ms	~1.316	Yüksek
Veracruz	314 ms	~972	Yüksek
León	313 ms	~849	Yüksek
Cuauhtémoc	284 ms	~826	Orta
Zapopan	266 ms	~773	Orta
Mexicali	282 ms	~773	Orta
Querétaro City	303 ms	~757	Orta
Hermosillo	255 ms	~742	Orta
Iztapalapa	301 ms	~742	Orta
Mérida	331 ms	~719	Orta
Torreón	292 ms	~673	Düşük
Culiacán	282 ms	~643	Düşük
San Luis Potosí City	297 ms	~635	Düşük
Ciudad Juárez	290 ms	~627	Düşük
Morelia	304 ms	~620	Düşük
Guadalupe	292 ms	~604	Düşük
Tuxtla Gutiérrez	325 ms	~566	Düşük
Reynosa	301 ms	~536	Düşük
Naucalpan	307 ms	~520	Düşük

Sağlayıcı	Gecikme	Ort. çevrimiçi	Havuz
Telmex (Infinitum)sabit	296 ms	~9.404	Yüksek
Total Playsabit	294 ms	~6.615	Yüksek
Megacablesabit	313 ms	~4.733	Yüksek
Izzisabit	252 ms	~3.161	Yüksek
Alestrasabit	338 ms	~298	Yüksek
Velocom De CVsabit	340 ms	~74	Orta
Television POR Cable Tepa De C.Vsabit	292 ms	~44	Orta
Comunicación B15 de C.V.sabit	325 ms	~44	Orta
Fibra A LA Casasabit	289 ms	~39	Düşük
Soluciones de Tecnologia Jah de Cvsabit	328 ms	~39	Düşük
ENI NETWORKS SAPI de CVsabit	488 ms	~35	Düşük
Doornet de cvsabit	307 ms	~35	Düşük
Javier Tamayo Garciasabit	344 ms	~35	Düşük
Digy Networks De C.V.sabit	359 ms	~31	Düşük

Coğrafi doğruluk — Meksika olarak satılan her IP, üç bağımsız coğrafi veritabanında (db-ip, MaxMind, ipinfo) Meksika ülkesine çözümlenir; yüksek coğrafi doğruluk, yerel coğrafi kapıların güvendiği sinyaldir.

Kullanım senaryosuna göre Meksika proxy'leri

Platforma göre değil, ne yaptığınıza göre düzenlenmiştir. Yerel hizmetler önem taşıdıkları yerlerde listelenir.

E-ticaret ve pazar araştırması

Mağaza vitrinlerini, fiyatları ve yerel ürün listelerini pazarın içinden kontrol edin.

Mağaza vitrini izleme
Yerel fiyat takibi
Satıcı araştırması

Mercado Libre MéxicoAmazon MexicoCoppelLiverpoolWalmart Mexico

Reklam doğrulama ve performans

Reklamların, kreatiflerin ve SERP'in yerel bir kullanıcıya nasıl göründüğünü görün — manuel geçiş olmadan.

Yerel SERP
Kreatif kontrolleri
Açılış sayfaları

FacebookInstagramTikTokYouTubeX (Twitter)

Seyahat ve fiyat istihbaratı

Uçuş ve otel ücretlerini yerel bir müşterinin gördüğü şekilde yakalayın.

Coğrafi fiyatlı ücretler
Teklif izleme
Fiyat karşılaştırması

Despegar MéxicoVolarisVivaAerobusAeroméxicoPrice Travel

Yayın ve coğrafi doğrulama

Bölgeye kilitli katalogları ve coğrafi kapıları doğru konumdan doğrulayın.

Coğrafi kontroller
Katalog doğrulama
Bölgesel erişilebilirlik

ViXTUDNClaro VideoAzteca DeportesHBO Max Mexico

Seri ilanlar ve yerel ilanlar

İkinci el ürünleri, araçları ve kiralıkları yerel ilan sitelerinde izleyin.

İlan izleme
Fiyat takibi
Bölgesel kapsam

Segundamano / VivanunciosMercado Libre AutosSeminuevosKavakSolo Autos

Geliştirme ve otomasyon

Veri hatları, testler ve API üzerinden izin verilen veri toplama için konut IP'leri.

Veri hattı entegrasyonu
API yönetimi
Sabit oturumlar

PythonScrapycURLGitHub

Yerel sitelerin ötesinde, aynı Meksika havuzu başlıca küresel platformlar için de çalışır — Google, Meta, Amazon, YouTube, TikTok ve Netflix — Meksika yerel ayarından görüldüğü şekliyle: yerel fiyatlandırma, reklamlar, kataloglar, SERP ve içerik.

Geliştirici API

Meksika kapsamındaki uç noktaları panelde oluşturun, test edilmiş kod parçacıklarını kopyalayın veya proxy listelerini herkese açık API üzerinden otomatikleştirin. Şehir, ISP, sabit oturumlar ve kayıtlı listeler tek ve düzenli bir iş akışında bir arada kalır.

API belgeleri

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

Gizli şart içermeyen paketler

Hacim arttıkça GB başına fiyat düşer. Abonelik veya gizli ücret yok.

1 GB$3.70

$3.70 / GB

Seç

5 GB$18.00

$3.60 / GB

Seç

10 GB$34.50

$3.45 / GB

Seç

Popüler

25 GB$80.00

$3.20 / GB

Seç

50 GB$147.50

$2.95 / GB

Seç

100 GB$270.00

$2.70 / GB

Seç

250 GB$612.50

$2.45 / GB

Seç

500 GB$1,100.00

$2.20 / GB

Seç

1 TB$2,000.00

$2.00 / GB

Seç

Paket

GB başına fiyat

Toplam

1 GB

$3.70 / GB

$3.70Seç

5 GB

$3.60 / GB

$18.00Seç

10 GB

$3.45 / GB

$34.50Seç

Popüler

25 GB

$3.20 / GB

$80.00Seç

50 GB

$2.95 / GB

$147.50Seç

100 GB

$2.70 / GB

$270.00Seç

250 GB

$2.45 / GB

$612.50Seç

500 GB

$2.20 / GB

$1,100.00Seç

1 TB

$2.00 / GB

$2,000.00Seç

Kullanılabilir ödeme yöntemleri

Alıcıların gerçekten sorduğu sorular

Meksika havuzunun kullanım senaryonuza uyup uymadığını hâlâ tartıyor musunuz? Ekibimiz Telegram'da, satın almadan önce ve sonra, günün her saati gerçek soruları yanıtlıyor.

Telegram'da sohbet edin

Bunlar Mercado Libre ve Coppel kazımak için işe yarar mı?

Birincil kullanım senaryosu budur. Havuz gerçek konut kaynaklıdır — yerel pazar yeri bot karşıtı sistemlerinin aradığı özellik — bu nedenle bu IP'ler, veri merkezi aralıklarının engellendiği yerlerde geçer. Yine de sonuçlar parmak izinize, başlıklarınıza ve istek hızınıza bağlıdır; bu yüzden proxy'yi temiz bir kurulum ve eşleşen bir Meksika saat dilimiyle (Central, veya kuzeybatıda Pacific/Mountain) birlikte kullanın.

Mexico City veya Guadalajara gibi belirli bir şehri hedefleyebilir miyim?

Evet, havuz derinliğinin elverdiği yerlerde — proxy listesini oluştururken şehri seçin. Kapsama tablolarımız Mexico City, Guadalajara, Monterrey, Tijuana, Puebla ve León için canlı eşzamanlılığı gösterir; böylece karar vermeden önce hangi şehirlerin en derin rotasyonu taşıdığını görebilirsiniz.

IP'ler coğrafi olarak Meksika içinde mi konumlanıyor?

Evet — son kıyaslamamızda havuz, Cloudflare karşısında ve bağımsız coğrafi veritabanları genelinde %100 coğrafi doğrulukla Meksika'ya çözümleniyor; çıkış düğümleri Querétaro (QRO) ve Guadalajara (GDL) konumlarında doğrulandı. Yüksek coğrafi doğruluk, Meksika coğrafi kısıtlamalarının dayandığı temel sinyaldir.

Çok adımlı bir akış için tek bir Meksika IP'sini elimde tutabilir miyim?

Evet. Aynı Meksika çıkış IP'sini korumak için sabit (sticky) oturum kullanın — 3 günlük ölçümümüzde ortalama tutma süresi yaklaşık 4,8 saat, en fazla 72 saattir. Ölçeklendirme için istek başına rotasyon yapın: çıkış IP'si isteklerin yaklaşık %96'sında değişir; genellikle yalnızca komşu bir adrese değil, farklı bir sağlayıcıya geçer.

Hangi Meksika operatörleri ve şehirleri kapsanıyor?

Havuz; Telmex (Infinitum), Total Play, Megacable, Izzi ve Alestra liderliğinde 113 Meksika ağını, 30 bölge ve 25 şehir genelinde kapsar — Mexico City ve Guadalajara'dan Monterrey, Tijuana, Puebla, León ve Mexicali'ye kadar.