Marruecos

IPs de hogares reales

Proxies residenciales de Marruecos

Los proxies residenciales marroquíes son direcciones IP reales de hogares de Marruecos, asignadas por ISPs de consumo como Maroc Telecom, Orange Maroc e Inwi. Te permiten navegar, hacer scraping y verificar tiendas, precios y contenido marroquíes como un usuario genuino dentro del país — en Casablanca, Rabat, Tánger y Marrakech — en lugar de hacerlo desde una IP de datacenter que Jumia, Marjane y los geobloqueos locales detectan y bloquean de inmediato.

Pruébalo por $1.99/GB Inicia sesión con Google

HTTP / SOCKS5Segmentación por ciudad e ISPEl tráfico nunca caducaLimpieza verificada cada mes

29,228IPs en el pool

25+Ciudades cubiertas

6Redes de ISP

397 msLatencia mediana

99.2%Estrictamente limpias

Proxies residenciales de Marruecos, de un vistazo

Los proxies residenciales de Marruecos son direcciones IP reales de hogares Marruecos, asignadas por ISP de consumo. Te permiten navegar, hacer scraping y verificar sitios, precios y contenido Marruecos como un usuario genuino dentro del país, en lugar de hacerlo desde una IP de datacenter que los sitios locales marcan y bloquean.

Tipo de pool: Residencial, multi-ISP
Ciudades cubiertas: Casablanca, Rabat, Tangier
Principales ISP: Maroc Telecom · Orange Maroc · Inwi
Protocolos: HTTP, SOCKS5
Rotación: Por solicitud o fija
Precisión geográfica: 99.93%
Limpieza del pool: 99.2% clean
Precios: from $2.00/GB
Última medición: 2026-06-23
Soporte: 24/7

Por qué los equipos eligen nuestro pool Marruecos

IPs residenciales reales, segmentación precisa y una calidad que no tienes que creer a ciegas.

IPs residenciales reales

Conexiones residenciales genuinas de ISP de consumo Marruecos, no rangos de datacenter que se bloquean apenas se detectan.

Segmentación por ciudad e ISP

Apunta a ciudades y operadores específicos donde la profundidad del pool lo permita, hasta el nivel del proveedor.

Rotativas o fijas

Rotación por solicitud para operar a escala, o sesiones fijas de hasta ~72 h para flujos de varios pasos.

HTTP y SOCKS5

Funciona con cualquier cliente, scraper o stack de automatización sin configuración adicional.

Obtenidas de forma ética

IPs de una red residencial con consentimiento explícito: usuarios reales que aceptaron compartir su ancho de banda.

Limpieza verificada, cada mes

Volvemos a medir el pool cada mes y publicamos las cifras, para que se mantengan al día.

Calidad que puedes verificar

Cada mes ejecutamos el mismo benchmark: una muestra aleatoria de IPs evaluada con Scamalytics, prueba de latencia desde un VPS neutral y verificación de precisión geográfica en bases de datos independientes. Las cifras de abajo reflejan producción, no una prueba de laboratorio en el mejor de los casos.

Limpieza Scamalytics · 100,000 IPs

Estrictamente limpias99.2%

Contaminación de datacenter0%

En alguna lista negra0.3%

Bajo riesgo de fraude (0–19)99.4%

Precisión geográfica99.93%

Latencia y velocidad VPS → Cloudflare

Latencia mediana397ms

Latencia p90 / p95510 / 685 ms

Conexiones exitosas99.2%

Rendimiento (mediana / p95)0.55 / 2.35 MB/s

Finalización de archivos grandes80%

Composición de la red

Tipo de conexión100% residencial

Redes de ISP (ASN)6

Modos de rotaciónpor solicitud · fija

Principales operadoresMaroc Telecom · Orange Maroc · Inwi

Medido sobre 100,000 direcciones desde un VPS neutral contra el edge de Cloudflare, vigente a la fecha del último benchmark. Una nueva ejecución puede diferir por un margen pequeño, pero las cifras reflejan plenamente el orden de magnitud y son una base sólida para juzgar si el pool se ajusta a tu caso de uso. La tasa de éxito de scraping por objetivo no se publica: depende de tu fingerprint y configuración, no solo de la IP.

benchmark.py — benchmark abierto del pool

El benchmark abierto detrás de las cifras de arriba. Toma una muestra aleatoria de IPs del pool y mide cuatro cosas: limpieza (riesgo de fraude de Scamalytics, datacenter, lista negra y precisión geográfica), latencia (ida y vuelta al edge de Cloudflare y a ip-api), rotación (IPs únicas, ASN y subredes /24) y rendimiento (velocidad de descarga y tiempo hasta el primer byte), y luego reporta cada una. Se publica completo para que la metodología detrás de cada cifra quede abierta a inspección.

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

Segmenta hasta el nivel de ciudad

«Prom. en línea» es el número promedio de dispositivos distintos conectados y disponibles en el mismo momento, no un total acumulado. Agrupado en Alto / Medio / Bajo.

RegionesCiudadesProveedores

Región	Latencia	Prom. en línea	Pool
Casablanca-Settat	392 ms	~804	Alto
Rabat-Salé-Kénitra	390 ms	~621	Alto
Fes-Meknes	415 ms	~331	Alto
Tanger-Tetouan-Al Hoceima	383 ms	~284	Alto
Marrakesh-Safi	417 ms	~230	Medio
Oriental	415 ms	~129	Medio
Souss-Massa	414 ms	~116	Bajo
Beni Mellal-Khenifra	387 ms	~80	Bajo
Guelmim-Oued Noun	419 ms	~3	Bajo
Drâa-Tafilalet	482 ms	~2	Bajo

Ciudad	Latencia	Prom. en línea	Pool
Casablanca	390 ms	~747	Alto
Rabat	389 ms	~385	Alto
Tangier	387 ms	~236	Alto
Fes	411 ms	~203	Alto
Marrakesh	408 ms	~200	Alto
Meknes	423 ms	~131	Alto
Kenitra	371 ms	~90	Alto
Salé	405 ms	~88	Alto
Agadir	400 ms	~84	Alto
Oujda	402 ms	~62	Medio
Beni Mellal	381 ms	~61	Medio
Temara	383 ms	~56	Medio
Tétouan	376 ms	~50	Medio
Nador	401 ms	~44	Medio
Safi	497 ms	~32	Medio
El Jadida	404 ms	~24	Medio
Settat	402 ms	~21	Bajo
Ben Taieb	510 ms	~18	Bajo
Méchouar de Casablanca	422 ms	~16	Bajo
Khemisset	413 ms	~12	Bajo
Dakhla	445 ms	~12	Bajo
Tiznit	470 ms	~10	Bajo
Inezgane	450 ms	~7	Bajo
El Ksiba	422 ms	~7	Bajo
Berkane	484 ms	~6	Bajo

Proveedor	Latencia	Prom. en línea	Pool
Maroc Telecommóvil	378 ms	~1,439	Alto
Orange Marocfijo	404 ms	~748	Medio
Inwifijo	406 ms	~413	Bajo

Precisión geográfica: cada IP vendida como Marruecos resuelve a Marruecos en tres bases de datos geográficas independientes (db-ip, MaxMind, ipinfo); la alta precisión geográfica es la señal en la que se apoyan los filtros geográficos locales.

Proxies de Marruecos por caso de uso

Organizado por lo que haces, no por plataforma. Los servicios locales aparecen donde importan.

E-commerce e investigación de mercado

Revisa tiendas, precios y listados locales desde dentro del mercado.

Monitoreo de tiendas
Seguimiento de precios locales
Investigación de vendedores

JumiaMarjane MallMarjaneElectroplanetDecathlon Maroc

Verificación y rendimiento de anuncios

Mira cómo se renderizan los anuncios, creatividades y la SERP para un usuario local, sin cambios manuales.

SERP local
Revisión de creatividades
Páginas de aterrizaje

FacebookInstagramYouTubeTikTok

Viajes e inteligencia de precios

Captura tarifas de vuelos y hoteles tal como las ve un cliente local.

Tarifas con precio geográfico
Monitoreo de ofertas
Comparación de tarifas

Royal Air MarocONCF VoyagesONCFSelfReservationVacancia

Streaming y verificación geográfica

Verifica catálogos con bloqueo regional y filtros geográficos desde la ubicación correcta.

Verificaciones geográficas
Verificación de catálogos
Disponibilidad regional

Shahid (MBC)SNRT Live2M

Clasificados y avisos locales

Monitorea artículos de segunda mano, autos y alquileres en los clasificados locales.

Monitoreo de avisos
Seguimiento de precios
Cobertura regional

AvitoMoteur.maWandaloo

Desarrollo y automatización

IPs residenciales para pipelines, pruebas y recolección de datos permitida vía API.

Integración de pipelines
Gestión de API
Sesiones fijas

PythonScrapycURLGitHub

Más allá de los sitios locales, el mismo pool Marruecos funciona con las principales plataformas globales —Google, Meta, Amazon, YouTube, TikTok y Netflix— tal como se ven desde el mercado local Marruecos: precios locales, anuncios, catálogos, SERP y contenido.

Desarrollador API

Genera endpoints acotados a Marruecos en el panel, copia snippets probados o automatiza listas de proxies a través de la API pública. Ciudad, ISP, sesiones fijas y listas guardadas se mantienen en un solo flujo de trabajo ordenado.

Documentación de la API

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

Paquetes sin condiciones ocultas

Más volumen significa menor precio por gigabyte. Sin suscripciones ni cargos ocultos.

1 GB$3.70

$3.70 / GB

Seleccionar

5 GB$18.00

$3.60 / GB

Seleccionar

10 GB$34.50

$3.45 / GB

Seleccionar

Popular

25 GB$80.00

$3.20 / GB

Seleccionar

50 GB$147.50

$2.95 / GB

Seleccionar

100 GB$270.00

$2.70 / GB

Seleccionar

250 GB$612.50

$2.45 / GB

Seleccionar

500 GB$1,100.00

$2.20 / GB

Seleccionar

1 TB$2,000.00

$2.00 / GB

Seleccionar

Paquete

Precio por GB

Total

1 GB

$3.70 / GB

$3.70Seleccionar

5 GB

$3.60 / GB

$18.00Seleccionar

10 GB

$3.45 / GB

$34.50Seleccionar

Popular

25 GB

$3.20 / GB

$80.00Seleccionar

50 GB

$2.95 / GB

$147.50Seleccionar

100 GB

$2.70 / GB

$270.00Seleccionar

250 GB

$2.45 / GB

$612.50Seleccionar

500 GB

$2.20 / GB

$1,100.00Seleccionar

1 TB

$2.00 / GB

$2,000.00Seleccionar

Métodos de pago disponibles

Preguntas que los compradores realmente hacen

¿Aún evalúas si el pool Marruecos se ajusta a tu caso de uso? Nuestro equipo responde preguntas reales en Telegram, las 24 horas, antes y después de tu compra.

Chatea en Telegram

¿Funcionarán para hacer scraping de Jumia y Marjane?

Ese es el caso de uso principal. El pool es residencial genuino — la característica que buscan los sistemas anti-bot de los marketplaces locales — así que estas IPs pasan donde los rangos de datacenter quedan bloqueados. El resultado sigue dependiendo de tu fingerprint, tus encabezados y tu ritmo de solicitudes, así que combina el proxy con una configuración limpia y una zona horaria marroquí acorde (WEST, GMT+1).

¿Puedo segmentar una ciudad específica como Casablanca o Rabat?

Sí, donde la profundidad del pool lo permita — elige la ciudad al generar la lista de proxies. Nuestras tablas de cobertura muestran la concurrencia en vivo de Casablanca, Rabat, Tánger, Fez, Marrakech y más, para que puedas ver qué ciudades tienen la rotación más profunda antes de decidirte.

¿Las IPs geolocalizan dentro de Marruecos?

Sí — el pool resuelve a Marruecos con 99.93% de precisión geográfica frente a Cloudflare y en bases de datos geográficas independientes en nuestro último benchmark, con enrutamiento de salida cercano confirmado a través de Marsella (MRS) y Madrid (MAD). La alta precisión geográfica es la señal de fondo en la que se apoyan los geobloqueos marroquíes.

¿Puedo mantener una misma IP marroquí para un flujo de varios pasos?

Sí. Usa una sesión sticky para conservar la misma IP de salida marroquí — la retención promedio ronda las 5 horas y llega hasta 72 horas en nuestra medición de 3 días. Para operar a escala, rota por solicitud: la IP de salida cambia en alrededor del 98% de las solicitudes, normalmente hacia un proveedor distinto, no solo a una dirección vecina.

¿Qué operadores y ciudades de Marruecos están cubiertos?

El pool abarca 4 ISPs marroquíes encabezados por Maroc Telecom, Orange Maroc e Inwi, en 10 regiones y 25 ciudades — desde Casablanca, Rabat y Tánger hasta Fez, Marrakech, Mequinez, Agadir y Oujda.