proxymix
Herramienta

Comprobador para toda la lista: IP vivas y anonimato

Un archivo de Node.js comprueba toda la lista: líneas ip:port y líneas con usuario y contraseña, HTTP y SOCKS5. Guarda los proxies que funcionan en un archivo, de más rápidos a más lentos, y muestra de cada uno la IP de salida y el anonimato.

Qué hace el comprobador

proxy-probe.mjs toma una lista desde un enlace o un archivo y pide a través de cada línea una página judge, es decir, un sitio que devuelve las cabeceras de la petición recibida. La respuesta da tres datos sobre el proxy: si funciona, cuánto tardó la petición y qué IP vio el sitio.

  • Formatos de línea: ip:port, host:port:login:password y login:password@host:port. El prefijo http:// o socks5:// fija el protocolo de una línea concreta.
  • Una contraseña con dos puntos o @ se interpreta bien. El script quita los duplicados y omite las líneas vacías o con mal formato.
  • El script comprueba 150 proxies a la vez y espera cada uno 8 segundos como máximo, así que mil líneas caben en un minuto. Ambos números cambian con parámetros.
  • Cada proxy que funciona recibe una nota de anonimato: high, medium o none.
  • Un proxy que respondió, pero rechazó el usuario o la contraseña, va a un contador aparte y no a los muertos.
  • Las líneas que funcionan quedan en alive.txt tal como estaban, de más rápidas a más lentas, y el archivo sirve de inmediato para su programa. El parámetro --csv añade un informe con latencia, IP de salida y anonimato.

Necesita Node.js 18 o superior. No hay paquetes externos, solo módulos integrados, y todo el código está en un archivo. Su lista no sale de su equipo: el script solo se conecta a los proxies de la lista y a la página judge.

Descargar y ejecutar con un comando

Enlace directo al archivo:

Descargar proxy-probe.mjshttps://proxymix.net/res/files/proxy-probe.mjs

Linux y macOS: el comando descarga el archivo en la carpeta actual y lanza la comprobación de inmediato.

bash
wget -qO proxy-probe.mjs https://proxymix.net/res/files/proxy-probe.mjs && node proxy-probe.mjs list.txt

Lo mismo con curl, si el servidor no tiene wget:

bash
curl -fsSLo proxy-probe.mjs https://proxymix.net/res/files/proxy-probe.mjs && node proxy-probe.mjs list.txt

Sin guardar el archivo: curl pasa el script directamente a Node, y los argumentos van tras el guion.

bash
curl -fsSL https://proxymix.net/res/files/proxy-probe.mjs | node --input-type=module - list.txt

Cambie list.txt por su archivo o por un enlace a la lista.

Formas de ejecutarlo

Paquete ilimitado: un enlace a la lista ip:port del panel, sin .csv al final, porque el comprobador no lee la tabla. Mantenga --parallel por debajo de los hilos del paquete, o las conexiones sobrantes recibirán rechazo y las líneas buenas acabarán entre las muertas.

bash
node proxy-probe.mjs "https://YOUR_LIST_LINK" --parallel 100

Planes por GB: un archivo con líneas host:port:login:password. Compruebe las líneas SOCKS5 con --kind socks5.

bash
node proxy-probe.mjs http-lines.txt
node proxy-probe.mjs socks-lines.txt --kind socks5

Proxies gratis: en una lista larga hay muchas líneas muertas. Suba el paralelismo, acorte la espera y deje del informe solo la nota high.

bash
node proxy-probe.mjs free.txt --parallel 400 --wait 4 --csv report.csv
grep ',high$' report.csv | cut -d, -f1 > high.txt

Informe para una hoja de cálculo: el CSV se abre en Excel y Google Sheets, con las columnas proxy, ms, exit_ip, anonymity.

bash
node proxy-probe.mjs list.txt --output ok.txt --csv report.csv

Su propia página judge, si httpbin.org responde despacio o está cerrado en su red. Sirve cualquier dirección en http normal que imprima las cabeceras de la petición.

bash
node proxy-probe.mjs list.txt --judge http://YOUR_SERVER/headers

Qué imprime el script

El progreso va a stderr en una línea que se actualiza. En stdout el script imprime los 15 proxies más rápidos con latencia, IP de salida y nota, y en la última línea el número de los que funcionan. Así se ve la comprobación de 38 proxies SOCKS5 gratis, con las direcciones cambiadas por otras de ejemplo:

salida
$ node proxy-probe.mjs socks.txt --kind socks5 --csv report.csv
checking 38 proxies, 150 at a time, via httpbin.org
38/38 checked, 25 alive
198.51.100.17:1088      3497 ms  203.0.113.40    high
192.0.2.63:10461        3667 ms  198.51.100.86   high
203.0.113.109:13391     3844 ms  192.0.2.132     high
198.51.100.155:38182    3954 ms  198.51.100.155  high
203.0.113.178:80        4170 ms  203.0.113.178   high
192.0.2.201:16209       4240 ms  198.51.100.224  high
203.0.113.247:1080      4327 ms  203.0.113.247   high
192.0.2.20:1080         4340 ms  198.51.100.43   high
203.0.113.66:1026       4494 ms  192.0.2.89      high
203.0.113.66:1059       4572 ms  192.0.2.89      high
203.0.113.66:1045       4654 ms  192.0.2.89      high
203.0.113.66:1087       4666 ms  198.51.100.112  high
203.0.113.66:1099       4752 ms  198.51.100.112  high
203.0.113.135:10800     4786 ms  203.0.113.135   high
192.0.2.158:1080        4917 ms  192.0.2.158     high
25 of 38 alive, saved to alive.txt

En alive.txt las líneas quedan tal como venían en la lista. El informe CSV les añade las mediciones:

archivos
$ head -3 alive.txt
198.51.100.17:1088
192.0.2.63:10461
203.0.113.109:13391
$ head -4 report.csv
proxy,ms,exit_ip,anonymity
198.51.100.17:1088,3497,203.0.113.40,high
192.0.2.63:10461,3667,198.51.100.86,high
203.0.113.109:13391,3844,192.0.2.132,high

Instalar Node.js en un servidor limpio

Primero compruebe la versión con node -v: sirve v18 o superior. Si no hay Node o es antiguo, instálelo para su sistema. Los comandos de abajo se ejecutan como root, un usuario normal necesita sudo delante de apt, dnf y bash.

Debian 12 y Ubuntu 24.04: sirve el Node del repositorio estándar.

bash
apt update && apt install -y nodejs
node -v

Ubuntu 20.04 y 22.04, Debian 11 y sistemas cuyo repositorio trae un Node anterior a 18: la LTS actual del repositorio de NodeSource.

bash
apt update && apt install -y curl
curl -fsSL https://deb.nodesource.com/setup_22.x | bash -
apt install -y nodejs
node -v

AlmaLinux, Rocky Linux y CentOS Stream:

bash
curl -fsSL https://rpm.nodesource.com/setup_22.x | bash -
dnf install -y nodejs
node -v

Ejecución en Windows

Instale Node.js LTS con winget, incluido en Windows 10 y 11. Después abra una nueva ventana de terminal para que se actualice el PATH.

PowerShell
winget install OpenJS.NodeJS.LTS

Descargar el script y lanzar la comprobación en PowerShell:

PowerShell
iwr https://proxymix.net/res/files/proxy-probe.mjs -OutFile proxy-probe.mjs -UseBasicParsing; node proxy-probe.mjs list.txt

En el símbolo del sistema cmd funciona el curl integrado:

cmd
curl -fsSLo proxy-probe.mjs https://proxymix.net/res/files/proxy-probe.mjs && node proxy-probe.mjs list.txt

Ponga la lista en la misma carpeta o indique la ruta completa entre comillas: node proxy-probe.mjs "C:\proxy\list.txt". El archivo alive.txt aparecerá en la carpeta desde la que lanzó el comando.

Comprobación por horario

Para que su programa tome siempre proxies vivos, lance el comprobador con un temporizador y guarde el resultado en un archivo fijo. El script escribe la lista nueva en un fresh.txt temporal y luego un comando reemplaza con él alive.txt, así el programa nunca encuentra el archivo a medio escribir. Si no sobrevive ningún proxy, el script termina con el código 1 y en alive.txt queda la lista anterior.

Linux: ponga el script en una carpeta aparte y abra el programador cron.

bash
mkdir -p /opt/probe && cd /opt/probe
wget -qO proxy-probe.mjs https://proxymix.net/res/files/proxy-probe.mjs
crontab -e

Añada esta línea: comprobación cada 20 minutos, flock no deja arrancar una segunda copia mientras corre la primera, y el registro va a probe.log.

crontab
*/20 * * * * cd /opt/probe && flock -n probe.lock node proxy-probe.mjs "https://YOUR_LIST_LINK" --output fresh.txt >> probe.log 2>&1 && mv fresh.txt alive.txt

Windows: cree la carpeta C:\probe y ponga en ella el script y un archivo run.cmd con dos líneas:

run.cmd
cd /d C:\probe
node proxy-probe.mjs "https://YOUR_LIST_LINK" --output fresh.txt >> probe.log 2>&1 && move /y fresh.txt alive.txt

Un solo comando crea la tarea cada 20 minutos:

cmd
schtasks /create /tn "proxy-probe" /tr "C:\probe\run.cmd" /sc minute /mo 20

Esta tarea funciona mientras usted tenga la sesión abierta. Para que corra sin iniciar sesión, ejecute el comando como administrador con la clave /ru SYSTEM. El signo % del enlace a la lista dentro de run.cmd se escribe doble: %%.

En el programa indique alive.txt como archivo de proxies: /opt/probe/alive.txt en Linux, C:\probe\alive.txt en Windows. Si el programa puede releer el archivo con un temporizador, actívelo, y las líneas nuevas entrarán sin reiniciar.

Cómo se calcula el anonimato

Antes de comprobar, el script consulta la página judge directamente y recuerda su propia dirección. Luego compara con ella cada respuesta:

  • high: la página judge no vio ni su dirección ni cabeceras de proxy como Via o X-Forwarded-For;
  • medium: su dirección está oculta, pero el proxy se delató con cabeceras;
  • none: su dirección real llegó a la página judge, el proxy solo reenvía el tráfico.

Listas de ProxyMix

Las líneas de los planes por GB tienen la forma host:port:login:password: el usuario ya está en la línea, y el comprobador se lo pasa al proxy por sí solo. Compruebe cada línea de estos planes con el protocolo para el que se creó.

Para el comprobador, use el enlace del paquete sin .csv al final: no hace falta usuario y el comprobador no lee la tabla. El acceso está abierto a la IP que añadió en el panel, así que lance el comprobador desde ese servidor. Un puerto admite HTTP, HTTPS, SOCKS4 y SOCKS5: compruebe con el protocolo que usa su programa.

Las líneas comprobadas de alive.txt se cargan directamente en ScrapeBox, Key Collector o en código en Python.

Códigos de salida y mensajes

  • Código 0: funciona al menos un proxy. Código 1: no funciona ninguno, o la lista no tiene líneas de proxy.
  • Código 2: parámetro incorrecto, el script imprime la ayuda.
  • «judge did not answer directly»: la página judge no está disponible o está bloqueada para su equipo. Elija otra, o los proxies transparentes pasarán inadvertidos.
  • «N of M lines with credentials were rejected»: estos proxies respondieron, pero rechazaron el usuario o la contraseña. No cuentan como muertos. Revise los datos de acceso en el panel del proveedor.

Código del script

El código está abierto por completo, léalo antes de ejecutarlo en su servidor.

Mostrar el código de proxy-probe.mjs
proxy-probe.mjs
import net from 'node:net';
import { readFile, writeFile } from 'node:fs/promises';

const settings = {
  parallel: 150,
  kind: 'http',
  wait: 8,
  judge: 'http://httpbin.org/get',
  output: 'alive.txt',
  csv: '',
};

const help = `usage: node proxy-probe.mjs <list-url-or-file> [options]

  list lines     ip:port, host:port:login:password or login:password@host:port;
                 start a line with socks5:// or http:// to set its protocol,
                 colons and @ signs inside a password are fine

  --parallel N   proxies checked at the same time (150)
  --kind K       http or socks5 (http)
  --wait S       seconds per proxy (8)
  --judge URL    plain http page that echoes request headers (http://httpbin.org/get)
  --output FILE  working proxies, fastest first (alive.txt)
  --csv FILE     extra report: proxy, ms, exit ip, anonymity`;

const args = process.argv.slice(2);
const source = args.find((a, i) => !a.startsWith('--') && !(args[i - 1] || '').startsWith('--'));
for (let i = 0; i < args.length; i++) {
  const name = args[i].startsWith('--') ? args[i].slice(2) : '';
  if (name === 'help') {
    console.log(help);
    process.exit(0);
  }
  if (name in settings) settings[name] = typeof settings[name] === 'number' ? Number(args[++i]) : args[++i];
}
if (!source || !['http', 'socks5'].includes(settings.kind) || !(settings.parallel > 0) || !(settings.wait > 0)) {
  console.error(help);
  process.exit(2);
}

const judge = new URL(settings.judge);
const judgePort = Number(judge.port || 80);
const leakHeaders = /\b(via|x-forwarded-for|forwarded|x-real-ip|client-ip|x-proxy-id)\b/i;
const ipv4 = /\b(?:\d{1,3}\.){3}\d{1,3}\b/g;
const scrub = (text) => text.split(judge.hostname).join('');

const protoPrefix = /^(http|socks5h?):\/\/(.+)$/i;
const plausible = (host) => host === 'localhost' || /^[\w-]+(\.[\w-]+)+$/.test(host);
const validPort = (port) => /^\d{1,5}$/.test(port) && Number(port) > 0 && Number(port) < 65536;
const keyed = (item) => item.login !== undefined;
const label = (item) => (keyed(item) ? `${item.login}@${item.host}:${item.port}` : item.text);
const cell = (value) => (/[",\r\n]/.test(value) ? `"${value.replace(/"/g, '""')}"` : value);
const rejected = () => Object.assign(new Error('credentials rejected'), { rejected: true });

function decode(raw) {
  const text = raw.trim();
  const tagged = text.match(protoPrefix);
  const body = tagged ? tagged[2].replace(/\/+$/, '') : text;
  const kind = tagged ? (tagged[1].toLowerCase() === 'http' ? 'http' : 'socks5') : '';
  const guesses = [];
  const colonForm = body.match(/^([^:@]+):(\d+):([^:]*):(.*)$/);
  if (colonForm) guesses.push({ host: colonForm[1], port: colonForm[2], login: colonForm[3], password: colonForm[4] });
  const atForm = body.match(/^([^:]*)(?::(.*))?@([^:@]+):(\d+)$/);
  if (atForm) guesses.push({ host: atForm[3], port: atForm[4], login: atForm[1], password: atForm[2] ?? '' });
  const usable = guesses.filter((g) => validPort(g.port));
  const best = usable.find((g) => plausible(g.host)) || usable[0];
  if (best) return { text, kind, ...best, port: Number(best.port) };
  if (tagged) {
    const bare = body.match(/^([^:@/]+):(\d+)$/);
    return bare && validPort(bare[2]) ? { text, kind, host: bare[1], port: Number(bare[2]) } : null;
  }
  const [host, port] = text.split(':');
  return host && /^\d+$/.test(port || '') ? { text: `${host}:${port}`, kind, host, port: Number(port) } : null;
}

async function loadLines(from) {
  const text = /^https?:\/\//.test(from) ? await (await fetch(from)).text() : await readFile(from, 'utf8');
  const seen = new Map();
  for (const raw of text.split(/\r?\n/)) {
    const item = decode(raw);
    if (item && !seen.has(item.text)) seen.set(item.text, item);
  }
  return [...seen.values()];
}

function talk(host, port) {
  const sock = net.connect({ host, port: Number(port) });
  let buffered = Buffer.alloc(0);
  let waiter = null;
  let ended = false;
  const wake = () => waiter && waiter();
  sock.on('data', (chunk) => { buffered = Buffer.concat([buffered, chunk]); wake(); });
  sock.on('end', () => { ended = true; wake(); });
  sock.on('error', () => { ended = true; wake(); });
  sock.on('close', () => { ended = true; wake(); });
  const take = (count) => new Promise((resolve, reject) => {
    const check = () => {
      if (buffered.length >= count) {
        const part = buffered.subarray(0, count);
        buffered = buffered.subarray(count);
        waiter = null;
        resolve(part);
      } else if (ended) {
        waiter = null;
        reject(new Error('closed'));
      }
    };
    waiter = check;
    check();
  });
  const rest = () => new Promise((resolve) => {
    const check = () => { if (ended) resolve(buffered.toString('latin1')); };
    waiter = check;
    check();
  });
  const ready = new Promise((resolve, reject) => {
    sock.once('connect', resolve);
    sock.once('error', reject);
    sock.once('close', () => reject(new Error('closed')));
  });
  return { sock, take, rest, ready };
}

async function socksOpen(link, item) {
  const withLogin = keyed(item);
  link.sock.write(Buffer.from([5, 1, withLogin ? 2 : 0]));
  const hello = await link.take(2);
  if (hello[0] !== 5) throw new Error('socks reply');
  if (withLogin && hello[1] === 255) throw rejected();
  if (withLogin && hello[1] === 2) {
    const user = Buffer.from(item.login);
    const secret = Buffer.from(item.password);
    if (!user.length || user.length > 255 || secret.length > 255) throw rejected();
    link.sock.write(Buffer.concat([Buffer.from([1, user.length]), user, Buffer.from([secret.length]), secret]));
    const ack = await link.take(2);
    if (ack[1] !== 0) throw rejected();
  } else if (hello[1] !== 0) {
    throw new Error('socks auth');
  }
  const name = Buffer.from(judge.hostname);
  link.sock.write(Buffer.concat([Buffer.from([5, 1, 0, 3, name.length]), name, Buffer.from([judgePort >> 8, judgePort & 255])]));
  const head = await link.take(4);
  if (head[1] !== 0) throw new Error('socks refused');
  const tail = head[3] === 1 ? 6 : head[3] === 4 ? 18 : (await link.take(1))[0] + 2;
  await link.take(tail);
}

async function probe(item) {
  const kind = item.kind || settings.kind;
  const started = performance.now();
  const link = talk(item.host, item.port);
  const timer = setTimeout(() => link.sock.destroy(), settings.wait * 1000);
  try {
    await link.ready;
    if (kind === 'socks5') await socksOpen(link, item);
    const target = kind === 'socks5' ? judge.pathname + judge.search : judge.href;
    const pass = kind === 'http' && keyed(item)
      ? `Proxy-Authorization: Basic ${Buffer.from(`${item.login}:${item.password}`).toString('base64')}\r\n`
      : '';
    link.sock.write(`GET ${target} HTTP/1.1\r\nHost: ${judge.host}\r\nUser-Agent: proxy-probe\r\nAccept: */*\r\n${pass}Connection: close\r\n\r\n`);
    const answer = await link.rest();
    const [head, ...bodyParts] = answer.split('\r\n\r\n');
    if (pass && /^HTTP\/1\.[01] 407/.test(head)) return { item, rejected: true };
    if (!/^HTTP\/1\.[01] 200/.test(head)) return null;
    const body = bodyParts.join('\r\n\r\n');
    return { item, ms: Math.round(performance.now() - started), body };
  } catch (err) {
    return err.rejected ? { item, rejected: true } : null;
  } finally {
    clearTimeout(timer);
    link.sock.destroy();
  }
}

function grade(body, myIp) {
  const text = scrub(body);
  if (myIp && text.includes(myIp)) return 'none';
  return leakHeaders.test(text) ? 'medium' : 'high';
}

let myIp = '';
try {
  myIp = (scrub(await (await fetch(judge.href, { signal: AbortSignal.timeout(10000) })).text()).match(ipv4) || [''])[0];
} catch {
  console.error('judge did not answer directly, anonymity will not detect transparent proxies');
}

const entries = await loadLines(source);
if (!entries.length) {
  console.error('no proxy lines found in', source);
  process.exit(1);
}
const withCredentials = entries.filter(keyed).length;
console.error(`checking ${entries.length} proxies${withCredentials ? ` (${withCredentials} with credentials)` : ''}, ${settings.parallel} at a time, via ${judge.host}`);

const alive = [];
const turnedAway = [];
let cursor = 0;
let done = 0;
let lastShown = 0;
const lane = async () => {
  while (cursor < entries.length) {
    const hit = await probe(entries[cursor++]);
    done++;
    if (hit && hit.rejected) {
      turnedAway.push(hit.item);
    } else if (hit) {
      const found = scrub(hit.body).match(ipv4) || [];
      const exit = found.find((ip) => ip !== myIp) || found[0] || '';
      alive.push({ entry: hit.item.text, shown: label(hit.item), ms: hit.ms, exit, level: grade(hit.body, myIp) });
    }
    if (done - lastShown >= Math.max(1, Math.ceil(entries.length / 20)) || done === entries.length) {
      lastShown = done;
      const denied = turnedAway.length ? `, ${turnedAway.length} rejected credentials` : '';
      process.stderr.write(`\r${done}/${entries.length} checked, ${alive.length} alive${denied} `);
    }
  }
};
await Promise.all(Array.from({ length: Math.min(settings.parallel, entries.length) }, lane));
process.stderr.write('\n');

alive.sort((a, b) => a.ms - b.ms);
await writeFile(settings.output, alive.map((p) => p.entry).join('\n') + (alive.length ? '\n' : ''));
if (settings.csv) {
  const rows = ['proxy,ms,exit_ip,anonymity', ...alive.map((p) => `${cell(p.entry)},${p.ms},${p.exit},${p.level}`)];
  await writeFile(settings.csv, rows.join('\n') + '\n');
}
const top = alive.slice(0, 15);
const width = Math.max(22, ...top.map((p) => p.shown.length));
for (const p of top) console.log(`${p.shown.padEnd(width)} ${String(p.ms).padStart(5)} ms  ${p.exit.padEnd(15)} ${p.level}`);
if (turnedAway.length) {
  console.log(`${turnedAway.length} of ${withCredentials} lines with credentials were rejected, first ${label(turnedAway[0])}: check the login and password`);
}
console.log(`${alive.length} of ${entries.length} alive, saved to ${settings.output}`);
process.exit(alive.length ? 0 : 1);

Qué sigue

¿Necesita miles de líneas que no mueran? Monte un pedido del tipo y el país que necesita. Las direcciones gratis por país están en la página de proxies gratis, y las guías de configuración muestran cómo cargar el archivo comprobado en sus programas.

Preguntas

Preguntas

Todas las preguntas
¿El comprobador trabaja con proxies con usuario y contraseña?

Sí. Interpreta por sí solo las líneas host:port:login:password y login:password@host:port. Los proxies HTTP reciben el usuario en la cabecera Proxy-Authorization, los SOCKS5 en el paso de autorización. El script muestra el usuario rechazado aparte de las líneas muertas.

¿El comprobador envía mi lista a alguna parte?

No. Solo se conecta a los proxies de su lista y a la página judge que indicó.

¿Por qué la página judge va por defecto en http y no en https?

Por https el proxy solo ve un túnel cifrado y no puede añadir cabeceras, así que las fugas pasarían inadvertidas. El http normal muestra qué cambia el proxy.

¿El comprobador funciona en Windows?

Sí. Instale Node.js con winget install OpenJS.NodeJS.LTS y lance el script en PowerShell o cmd. Los comandos para ambos intérpretes y la tarea del programador están arriba en esta página.

¿Con qué frecuencia compruebo una lista por horario?

Los proxies gratis duran poco, compruébelos cada 10 a 20 minutos. La lista de un paquete ilimitado basta con comprobarla una vez por hora. Las líneas de los planes por GB llevan a una pasarela que elige sola la dirección de salida, así que basta con una comprobación tras crear la lista.

¿Cuántas líneas se pueden comprobar en una ejecución?

El script no tiene límite, y mantiene en memoria decenas de miles de líneas sin esfuerzo. El tiempo se estima así: divida el número de líneas entre --parallel y multiplique por --wait. Con 10 000 líneas, 400 hilos y 4 segundos de espera, sale menos de dos minutos.

¿Listo para probar?

Recarga el saldo, crea una lista del tipo y país que necesitas y prueba el pool en tu sitio. 1 GB de prueba cuesta desde $0,27 y el tráfico dura tres meses.

Armar pedido