Francia

IPs de hogares reales

Proxies residenciales de Francia

Los proxies residenciales franceses son direcciones IP reales de hogares de Francia, asignadas por ISP de consumo como Orange, SFR, Free y Bouygues Telecom. Te permiten navegar, hacer scraping y verificar tiendas, precios y contenidos franceses como un usuario auténtico dentro del país —en París, Marsella, Lyon y Toulouse— en lugar de hacerlo desde una IP de datacenter que Cdiscount, Fnac y los geobloqueos locales detectan y bloquean al instante.

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

276,416IPs en el pool

25+Ciudades cubiertas

19Redes de ISP

356 msLatencia mediana

98.9%Estrictamente limpias

Proxies residenciales de Francia, de un vistazo

Los proxies residenciales de Francia son direcciones IP reales de hogares Francia, asignadas por ISP de consumo. Te permiten navegar, hacer scraping y verificar sitios, precios y contenido Francia 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: Paris, Marseille, Toulouse
Principales ISP: Orange · SFR · Free
Protocolos: HTTP, SOCKS5
Rotación: Por solicitud o fija
Precisión geográfica: 99.92%
Limpieza del pool: 98.9% clean
Precios: from $2.00/GB
Última medición: 2026-06-23
Soporte: 24/7

Por qué los equipos eligen nuestro pool Francia

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 Francia, 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 limpias98.9%

Contaminación de datacenter0%

En alguna lista negra0.42%

Bajo riesgo de fraude (0–19)99.1%

Precisión geográfica99.92%

Latencia y velocidad VPS → Cloudflare

Latencia mediana356ms

Latencia p90 / p95397 / 449 ms

Conexiones exitosas98.2%

Rendimiento (mediana / p95)0.76 / 2.41 MB/s

Finalización de archivos grandes96%

Composición de la red

Tipo de conexión100% residencial

Redes de ISP (ASN)19

Modos de rotaciónpor solicitud · fija

Principales operadoresOrange · SFR · Free

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
Île-de-France	345 ms	~5,673	Alto
Rhône-Alpes	361 ms	~2,870	Alto
Provence-Alpes-Côte d'Azur	355 ms	~2,654	Alto
Occitanie	369 ms	~2,637	Alto
Hauts-de-France	355 ms	~2,258	Alto
Grand Est	357 ms	~1,967	Medio
New Aquitaine	367 ms	~1,801	Medio
Normandy	354 ms	~977	Bajo
Pays de la Loire	357 ms	~977	Bajo
Brittany	360 ms	~948	Bajo
Centre-Val de Loire	354 ms	~923	Bajo
Bourgogne	368 ms	~728	Bajo
Corsica	373 ms	~175	Bajo

Ciudad	Latencia	Prom. en línea	Pool
Paris	347 ms	~6,295	Alto
Marseille	345 ms	~2,149	Alto
Toulouse	357 ms	~1,612	Alto
Lyon	358 ms	~1,460	Alto
Lille	346 ms	~1,419	Alto
Nice	340 ms	~1,157	Alto
Montpellier	373 ms	~1,019	Alto
Strasbourg	350 ms	~813	Alto
Nantes	352 ms	~730	Alto
Orléans	351 ms	~703	Medio
Rennes	354 ms	~634	Medio
Villeurbanne	337 ms	~606	Medio
Bordeaux	371 ms	~592	Medio
Le Pecq	336 ms	~523	Medio
Annecy	335 ms	~510	Medio
Saint-Brieuc	360 ms	~496	Medio
Angers	364 ms	~482	Bajo
Tours	356 ms	~482	Bajo
Toulon	339 ms	~468	Bajo
Dijon	356 ms	~455	Bajo
Le Mans	342 ms	~427	Bajo
Vitry-sur-Seine	339 ms	~399	Bajo
Aix-en-Provence	361 ms	~399	Bajo
Argenteuil	343 ms	~386	Bajo
Perpignan	357 ms	~372	Bajo

Proveedor	Latencia	Prom. en línea	Pool
Orangemóvil	367 ms	~11,011	Alto
SFRmóvil	339 ms	~6,917	Alto
Freefijo	340 ms	~4,051	Alto
Bouygues Telecomfijo	345 ms	~2,324	Alto
Wifirstfijo	355 ms	~113	Medio
Vialisfijo	344 ms	~55	Medio
Nordnetfijo	370 ms	~29	Medio
Regies Mosellefijo	347 ms	~25	Bajo
Corio-Tefijo	331 ms	~21	Bajo
Regie Municipale D'Electricite De Creutzwaldfijo	342 ms	~21	Bajo
Communaute de Communes du Pays de Bitchemóvil	343 ms	~21	Bajo

Precisión geográfica: cada IP vendida como Francia resuelve a Francia 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 Francia 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

Amazon FranceCdiscountFnacDartyManoMano

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

FacebookInstagramTikTokXYouTube

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

SNCF ConnectAir FranceBooking.comSkyscannerTrainline

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

myCanalFrance.tvTF1+M6+Molotov

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

LeboncoinVintedLa CentraleParuVenduAutoScout24 France

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 Francia funciona con las principales plataformas globales —Google, Meta, Amazon, YouTube, TikTok y Netflix— tal como se ven desde el mercado local Francia: precios locales, anuncios, catálogos, SERP y contenido.

Desarrollador API

Genera endpoints acotados a Francia 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": "FR",
6  "city": "Paris",
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 Francia 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 Cdiscount y Fnac?

Ese es el caso de uso principal. El pool es residencial genuino —la propiedad que buscan los sistemas antibot del comercio electrónico local—, así que estas IP pasan donde los rangos de datacenter se bloquean. Los resultados aún dependen de tu huella digital, tus encabezados y el ritmo de tus solicitudes, así que combina el proxy con una configuración limpia y una zona horaria francesa acorde (CET/CEST).

¿Puedo apuntar a una ciudad específica como París o Marsella?

Sí, cuando la profundidad del pool lo permite: elige la ciudad al generar la lista de proxies. Nuestras tablas de cobertura muestran la concurrencia en vivo de París, Marsella, Lyon, Toulouse, Lille, Niza y más, así que puedes ver qué ciudades tienen la rotación más profunda antes de decidirte.

¿Las IP se geolocalizan dentro de Francia?

Sí: el pool se resuelve en Francia con un 99.92% de precisión geográfica frente a Cloudflare y en bases de datos geográficas independientes en nuestro último benchmark, con nodos de salida confirmados en París (CDG) y Marsella (MRS). La alta precisión geográfica es la señal subyacente en la que se apoyan los geobloqueos franceses.

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

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

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

El pool abarca 11 ISP franceses encabezados por Orange, SFR, Free y Bouygues Telecom, en 13 regiones y 25 ciudades, desde París, Lyon y Marsella hasta Toulouse, Lille, Niza, Estrasburgo, Nantes y Rennes.