proxymix
Ferramenta

Verificador para a lista inteira: IPs vivos e anonimato

Um arquivo Node.js verifica a lista inteira: linhas ip:port e linhas com login e senha, HTTP e SOCKS5. Ele guarda os proxies que funcionam em um arquivo, dos mais rápidos aos mais lentos, e mostra de cada um o IP de saída e o anonimato.

O que o verificador faz

proxy-probe.mjs pega uma lista por link ou de um arquivo e pede, por cada linha, uma página judge, ou seja, um site que devolve os cabeçalhos da requisição recebida. A resposta dá três fatos sobre o proxy: se funciona, quanto durou a requisição e qual IP o site viu.

  • Formatos de linha: ip:port, host:port:login:password e login:password@host:port. O prefixo http:// ou socks5:// define o protocolo de uma linha específica.
  • Uma senha com dois-pontos ou @ é interpretada corretamente. O script remove duplicatas e pula linhas vazias ou fora do formato.
  • O script verifica 150 proxies ao mesmo tempo e espera cada um por no máximo 8 segundos, então mil linhas cabem em um minuto. Os dois números mudam por parâmetros.
  • Cada proxy que funciona recebe uma nota de anonimato: high, medium ou none.
  • Um proxy que respondeu, mas recusou o login ou a senha, vai para um contador separado e não para os mortos.
  • As linhas que funcionam ficam em alive.txt como vieram, das mais rápidas às mais lentas, e o arquivo já serve para o seu programa. O parâmetro --csv adiciona um relatório com latência, IP de saída e anonimato.

É preciso Node.js 18 ou mais recente. Não há pacotes externos, só módulos embutidos, e todo o código fica em um arquivo. A sua lista não sai daí: o script só se conecta aos proxies da lista e à página judge.

Baixar e rodar com um comando

Link direto para o arquivo:

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

Linux e macOS: o comando baixa o arquivo na pasta atual e inicia a verificação na hora.

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

O mesmo com curl, se o servidor não tiver wget:

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

Sem salvar o arquivo: o curl passa o script direto para o Node, e os argumentos vêm depois do hífen.

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

Troque list.txt pelo seu arquivo ou por um link da lista.

Formas de rodar

Pacote ilimitado: um link para a lista ip:port do painel, sem .csv no fim, porque o verificador não lê a tabela. Mantenha --parallel abaixo do número de threads do pacote, senão as conexões extras são recusadas e linhas boas vão para os mortos.

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

Planos por GB: um arquivo com linhas host:port:login:password. Verifique linhas SOCKS5 com --kind socks5.

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

Proxies grátis: em uma lista longa há muitas linhas mortas. Aumente o paralelismo, encurte a espera e deixe do relatório só a 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

Relatório para planilha: o CSV abre no Excel e no Google Sheets, com as colunas proxy, ms, exit_ip, anonymity.

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

Sua própria página judge, se o httpbin.org responder devagar ou estiver fechado na sua rede. Serve qualquer endereço em http comum que imprima os cabeçalhos da requisição.

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

O que o script imprime

O progresso vai para stderr em uma linha que se atualiza. Em stdout o script imprime os 15 proxies mais rápidos com latência, IP de saída e nota, e na última linha o número dos que funcionam. Assim fica a verificação de 38 proxies SOCKS5 grátis, com endereços trocados por exemplos:

saída
$ 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

Em alive.txt as linhas ficam como vieram na lista. O relatório CSV acrescenta as medições a elas:

arquivos
$ 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 em um servidor limpo

Primeiro confira a versão com node -v: serve v18 ou mais recente. Se não houver Node ou ele for antigo, instale para o seu sistema. Os comandos abaixo rodam como root, e um usuário comum precisa de sudo antes de apt, dnf e bash.

Debian 12 e Ubuntu 24.04: serve o Node do repositório padrão.

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

Ubuntu 20.04 e 22.04, Debian 11 e sistemas cujo repositório traz Node anterior ao 18: a LTS atual do repositório 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 e CentOS Stream:

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

Rodar no Windows

Instale o Node.js LTS pelo winget, que já vem no Windows 10 e 11. Depois abra uma nova janela do terminal para o PATH se atualizar.

PowerShell
winget install OpenJS.NodeJS.LTS

Baixar o script e iniciar a verificação no PowerShell:

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

No prompt do cmd funciona o curl embutido:

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

Coloque a lista na mesma pasta ou indique o caminho completo entre aspas: node proxy-probe.mjs "C:\proxy\list.txt". O arquivo alive.txt aparece na pasta de onde você rodou o comando.

Verificação agendada

Para o seu programa sempre pegar proxies vivos, rode o verificador por timer e mantenha o resultado em um arquivo fixo. O script grava a lista nova em um fresh.txt temporário, e depois um comando troca alive.txt por ele, assim o programa nunca pega o arquivo no meio da gravação. Se nenhum proxy sobreviver, o script termina com código 1 e alive.txt mantém a lista anterior.

Linux: coloque o script em uma pasta separada e abra o agendador cron.

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

Adicione esta linha: verificação a cada 20 minutos, o flock não deixa subir uma segunda cópia enquanto a primeira roda, e o log vai para 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: crie a pasta C:\probe e coloque nela o script e um arquivo run.cmd com duas linhas:

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

Um comando cria a tarefa a cada 20 minutos:

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

Essa tarefa roda enquanto você estiver conectado. Para rodar sem login, execute o comando como administrador com a chave /ru SYSTEM. O sinal % no link da lista dentro de run.cmd é escrito duas vezes: %%.

No programa, indique alive.txt como arquivo de proxies: /opt/probe/alive.txt no Linux, C:\probe\alive.txt no Windows. Se o programa souber reler o arquivo por timer, ative isso, e as linhas novas entram sem reiniciar.

Como o anonimato é calculado

Antes da verificação, o script consulta a página judge diretamente e guarda o seu próprio endereço. Depois compara cada resposta com ele:

  • high: a página judge não viu nem o seu endereço nem cabeçalhos de proxy como Via ou X-Forwarded-For;
  • medium: o seu endereço está oculto, mas o proxy se entregou com cabeçalhos;
  • none: o seu endereço real chegou à página judge, o proxy só encaminha o tráfego.

Listas da ProxyMix

As linhas dos planos por GB têm a forma host:port:login:password: o login já está na linha, e o verificador o passa ao proxy sozinho. Verifique cada linha desses planos com o protocolo para o qual ela foi criada.

Para o verificador, use o link do pacote sem .csv no fim: não precisa de login, e o verificador não lê a tabela. O acesso fica aberto para o IP que você adicionou no painel, então rode o verificador a partir desse servidor. Uma porta recebe HTTP, HTTPS, SOCKS4 e SOCKS5: verifique com o protocolo que o seu programa usa.

As linhas verificadas de alive.txt são carregadas direto no ScrapeBox, no Key Collector ou em código Python.

Códigos de saída e mensagens

  • Código 0: pelo menos um proxy funciona. Código 1: nenhum funciona, ou a lista não tem linhas de proxy.
  • Código 2: parâmetro incorreto, o script imprime a ajuda.
  • "judge did not answer directly": a página judge está indisponível ou bloqueada para a sua máquina. Escolha outra, senão proxies transparentes passam despercebidos.
  • "N of M lines with credentials were rejected": esses proxies responderam, mas recusaram o login ou a senha. Eles não contam como mortos. Confira os dados de acesso no painel do provedor.

Código do script

O código é totalmente aberto, leia antes de rodar no seu servidor.

Mostrar o 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);

O que vem depois

Precisa de milhares de linhas que não morrem: monte um pedido do tipo e do país desejados. Endereços grátis por país estão na página de proxies grátis, e os guias de configuração mostram como carregar o arquivo verificado nos programas.

Perguntas

Perguntas

Todas as perguntas
O verificador trabalha com proxies com login e senha?

Sim. Ele interpreta sozinho as linhas host:port:login:password e login:password@host:port. Proxies HTTP recebem o login no cabeçalho Proxy-Authorization, proxies SOCKS5 na etapa de autorização. O script mostra um login recusado separado das linhas mortas.

O verificador envia a minha lista para algum lugar?

Não. Ele só se conecta aos proxies da sua lista e à página judge que você indicou.

Por que a página judge fica em http por padrão e não em https?

Por https o proxy só vê um túnel criptografado e não pode adicionar cabeçalhos, então vazamentos ficariam invisíveis. O http comum mostra o que o proxy muda.

O verificador funciona no Windows?

Sim. Instale o Node.js com winget install OpenJS.NodeJS.LTS e rode o script no PowerShell ou no cmd. Os comandos para os dois shells e a tarefa do agendador estão acima nesta página.

Com que frequência verificar uma lista por agendamento?

Proxies grátis duram pouco, verifique a cada 10 a 20 minutos. A lista de um pacote ilimitado basta verificar uma vez por hora. As linhas dos planos por GB levam a um gateway que escolhe sozinho o endereço de saída, então basta uma verificação depois de criar a lista.

Quantas linhas uma execução verifica?

O script não tem limite, e dezenas de milhares de linhas ficam na memória sem esforço. O tempo se estima assim: divida o número de linhas por --parallel e multiplique por --wait. Para 10 000 linhas, 400 threads e 4 segundos de espera, dá menos de dois minutos.

Pronto para testar?

Recarregue o saldo, crie uma lista do tipo e país desejados e teste o pool no seu site. 1 GB de teste custa desde $0,27 e o tráfego vale por três meses.

Montar pedido