Usando Proxies em Node.js (Axios + Puppeteer + SDK)

Por que usar Proxies em Node.js?

Node.js é um dos tempos de execução mais populares para a construção de raspadores web, integradores de API e ferramentas de automação. Mas se você estiver enviando centenas ou milhares de pedidos de um único endereço IP, você rapidamente irá encontrar limites de taxa, CAPTCHAs e proibições de IP. Proxies em Node.js resolver isso roteando suas solicitações através de diferentes endereços IP, fazendo com que cada um pareça vir de um usuário único.

Se você está raspando os preços do produto, monitorando rankings de mecanismos de busca ou coletando dados públicos em escala, proxies são infraestrutura essencial. Neste guia, vamos cobrir tudo o que você precisa para integrar proxies residenciais em seus projetos Node.js usando o Nó do ProxyHat SDK== Ligações externas ==

Se você ainda estiver avaliando qual tipo de proxy se encaixa no seu caso de uso, confira nossa comparação de residencial vs datacenter vs proxies móveis.

Instalação e Configuração

Instalando o SDK do ProxyHat

A maneira mais rápida de começar é com o oficial Node SDK. Lida com autenticação, rotação e ligação a juntar da caixa:

npm install proxyhat

Você também vai querer os clientes HTTP que você planeja usar:

npm install axios puppeteer playwright

autenticação

Todas as conexões proxyHat proxy autenticam-se através de suas credenciais API. Você pode encontrar seu nome de usuário e senha no Painel do ProxyHat. O SDK aceita-os como opções construtoras ou variáveis de ambiente:

// Option 1: Pass credentials directly
const ProxyHat = require('proxyhat');
const client = new ProxyHat({
  username: 'your_username',
  password: 'your_password',
});
// Option 2: Use environment variables
// Set PROXYHAT_USERNAME and PROXYHAT_PASSWORD in your .env
const client = new ProxyHat();

Simples GET Pedido com o SDK

O SDK fornece um alto nível fetch método que manipula automaticamente a rotação do proxy:

const ProxyHat = require('proxyhat');
const client = new ProxyHat();
async function main() {
  const response = await client.fetch('https://httpbin.org/ip', {
    country: 'us',
  });
  console.log('Status:', response.status);
  console.log('Body:', await response.text());
}
main().catch(console.error);

Cada chamada seleciona automaticamente um IP residencial diferente. Não é necessária a formatação manual da URL do proxy.

Usar Proxies com Axios

Axios é o cliente HTTP mais popular no ecossistema Node.js. Para rotear solicitações do Axios através do ProxyHat, você pode usar o URL proxy do SDK ou configurar o Axios diretamente.

Método 1: Agente Proxy SDK

const ProxyHat = require('proxyhat');
const axios = require('axios');
const client = new ProxyHat();
const agent = client.createAgent({ country: 'us' });
async function scrapeWithAxios() {
  const response = await axios.get('https://httpbin.org/ip', {
    httpAgent: agent,
    httpsAgent: agent,
    timeout: 30000,
  });
  console.log('IP:', response.data.origin);
}
scrapeWithAxios();

Método 2: URL de Proxy Direta

Se preferir a configuração manual, use o formato de URL de proxy padrão com o https-proxy-agent pacote:

const axios = require('axios');
const { HttpsProxyAgent } = require('https-proxy-agent');
const proxyUrl = 'http://USERNAME:PASSWORD@gate.proxyhat.com:8080';
const agent = new HttpsProxyAgent(proxyUrl);
async function scrapeWithAxios() {
  const response = await axios.get('https://httpbin.org/ip', {
    httpsAgent: agent,
    timeout: 30000,
  });
  console.log('IP:', response.data.origin);
}
scrapeWithAxios();

Instância Axios com Proxy Padrão

Para uso repetido, crie uma instância Axios pré-configurada:

const { HttpsProxyAgent } = require('https-proxy-agent');
const agent = new HttpsProxyAgent('http://USERNAME:PASSWORD@gate.proxyhat.com:8080');
const proxyClient = axios.create({
  httpsAgent: agent,
  timeout: 30000,
  headers: {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
  },
});
// All requests now go through the proxy
const res = await proxyClient.get('https://example.com');

Usar Proxies com o Puppeteer

Puppeteer lança um navegador Chrome sem cabeça, que é ideal para raspar sites com peso JavaScript. Proxies são configurados no nível de lançamento do navegador.

const puppeteer = require('puppeteer');
async function scrapeWithPuppeteer() {
  const browser = await puppeteer.launch({
    args: ['--proxy-server=gate.proxyhat.com:8080'],
    headless: 'new',
  });
  const page = await browser.newPage();
  // Authenticate with the proxy
  await page.authenticate({
    username: 'USERNAME',
    password: 'PASSWORD',
  });
  await page.goto('https://httpbin.org/ip', {
    waitUntil: 'networkidle2',
    timeout: 60000,
  });
  const content = await page.evaluate(() => document.body.innerText);
  console.log('IP:', content);
  await browser.close();
}
scrapeWithPuppeteer();

Puppeteer com Geo-Targeting

Para direcionar um país específico, inclua o código de país em seu nome de usuário. O ProxyHat usa o formato USERNAME-country-XX:

await page.authenticate({
  username: 'USERNAME-country-de',  // Route through Germany
  password: 'PASSWORD',
});

Navegue todos os locais de proxy disponíveis em nosso página de localização.

Usando Proxies com Playwright

O dramaturgo suporta Chromium, Firefox e WebKit. A configuração do proxy é incorporada nas opções de lançamento, tornando-a ainda mais simples:

const { chromium } = require('playwright');
async function scrapeWithPlaywright() {
  const browser = await chromium.launch({
    proxy: {
      server: 'http://gate.proxyhat.com:8080',
      username: 'USERNAME',
      password: 'PASSWORD',
    },
  });
  const context = await browser.newContext();
  const page = await context.newPage();
  await page.goto('https://httpbin.org/ip');
  const body = await page.textContent('body');
  console.log('IP:', body);
  await browser.close();
}
scrapeWithPlaywright();

Playwright com Proxies por Contexto

O dramaturgo permite diferentes proxies por contexto de navegador, que é útil para raspagem multi-conta ou multi-região:

const browser = await chromium.launch();
// US context
const usContext = await browser.newContext({
  proxy: {
    server: 'http://gate.proxyhat.com:8080',
    username: 'USERNAME-country-us',
    password: 'PASSWORD',
  },
});
// UK context
const ukContext = await browser.newContext({
  proxy: {
    server: 'http://gate.proxyhat.com:8080',
    username: 'USERNAME-country-gb',
    password: 'PASSWORD',
  },
});
const usPage = await usContext.newPage();
const ukPage = await ukContext.newPage();
await Promise.all([
  usPage.goto('https://www.google.com/search?q=proxy+service'),
  ukPage.goto('https://www.google.co.uk/search?q=proxy+service'),
]);

Rodando vs Sessões Fixos

O ProxyHat suporta dois modos de sessão que atendem diferentes necessidades de raspagem:

Exemplo de Sessão Fixo

const { HttpsProxyAgent } = require('https-proxy-agent');
const axios = require('axios');
// Generate a random session ID
const sessionId = 'session_' + Math.random().toString(36).slice(2, 10);
const agent = new HttpsProxyAgent(
  `http://USERNAME-session-${sessionId}:PASSWORD@gate.proxyhat.com:8080`
);
// All requests with this agent use the same IP
const client = axios.create({ httpsAgent: agent, timeout: 30000 });
const res1 = await client.get('https://httpbin.org/ip');
const res2 = await client.get('https://httpbin.org/ip');
console.log(res1.data.origin === res2.data.origin); // true

Pedidos Geo- Targeted

Geo-alvo é fundamental para Monitoramento SERP, monitoramento de preços localizado e verificação de conteúdo regional. O ProxyHat suporta segmentação em nível nacional e municipal através da string de nome de usuário:

// Country targeting
const countryAgent = new HttpsProxyAgent(
  'http://USERNAME-country-jp:PASSWORD@gate.proxyhat.com:8080'
);
// City targeting
const cityAgent = new HttpsProxyAgent(
  'http://USERNAME-country-us-city-newyork:PASSWORD@gate.proxyhat.com:8080'
);

Confira nossa lista completa de locais disponíveis para países e cidades apoiados.

Tratamento de Erros e Repetições

Erros de rede são inevitáveis quando se trabalha com proxies em escala. Uma estratégia de repetição robusta é essencial para raspadores de produção:

const axios = require('axios');
const { HttpsProxyAgent } = require('https-proxy-agent');
async function fetchWithRetry(url, options = {}) {
  const maxRetries = options.maxRetries || 3;
  const baseDelay = options.baseDelay || 1000;
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      const agent = new HttpsProxyAgent(
        'http://USERNAME:PASSWORD@gate.proxyhat.com:8080'
      );
      const response = await axios.get(url, {
        httpsAgent: agent,
        timeout: options.timeout || 30000,
      });
      if (response.status === 200) return response;
      throw new Error(`HTTP ${response.status}`);
    } catch (error) {
      console.warn(`Attempt ${attempt}/${maxRetries} failed: ${error.message}`);
      if (attempt === maxRetries) throw error;
      // Exponential backoff: 1s, 2s, 4s...
      const delay = baseDelay * Math.pow(2, attempt - 1);
      await new Promise(r => setTimeout(r, delay));
    }
  }
}
// Usage
const response = await fetchWithRetry('https://example.com', {
  maxRetries: 3,
  timeout: 20000,
});

Raspagem concomitante com controle de concorrência

Enviando todos os pedidos de uma vez com Promise.all pode sobrecarregar tanto a sua máquina como o servidor de destino. Use um limitador de concorrência para controlar o número de conexões paralelas:

async function asyncPool(concurrency, items, iteratorFn) {
  const results = [];
  const executing = new Set();
  for (const [index, item] of items.entries()) {
    const promise = Promise.resolve().then(() => iteratorFn(item, index));
    results.push(promise);
    executing.add(promise);
    const cleanup = () => executing.delete(promise);
    promise.then(cleanup, cleanup);
    if (executing.size >= concurrency) {
      await Promise.race(executing);
    }
  }
  return Promise.all(results);
}
// Scrape 100 URLs, 10 at a time
const urls = Array.from({ length: 100 }, (_, i) =>
  `https://example.com/page/${i + 1}`
);
const results = await asyncPool(10, urls, async (url) => {
  return fetchWithRetry(url, { maxRetries: 2, timeout: 15000 });
});

Para grandes dimensões projetos de raspagem web, manter a concordância entre 5 e 20 oferece um bom equilíbrio entre velocidade e confiabilidade. Leia nosso guia sobre melhores proxies para raspagem web em 2026 para mais conselhos de arquitetura.

Dicas de produção

Gestão de Ligação

• Reuse instâncias Axios e agentes proxy em vez de criar novos por solicitação. Isto evita a exaustão do soquete.
• Definir keepAlive: true em seu agente HTTP para conexões persistentes.
• Fechar navegadores Puppeteer/Playwright imediatamente após o uso para memória livre.

Memória e Tempo- limite

• Para o Puppeteer, utilizar page.setRequestInterception(true) para bloquear imagens, CSS e fontes quando você só precisa de conteúdo HTML. Isso reduz significativamente a largura de banda e o uso de memória.
• Defina sempre prazos explícitos em cada pedido. Uma pausa é a causa número um de pendurar raspadores.
• Monitor de memória Node.js com process.memoryUsage() em raspadores de longa duração.

Pedido de Intercepção para Raspamento Mais Rápido

const page = await browser.newPage();
await page.setRequestInterception(true);
page.on('request', (req) => {
  const blocked = ['image', 'stylesheet', 'font', 'media'];
  if (blocked.includes(req.resourceType())) {
    req.abort();
  } else {
    req.continue();
  }
});
await page.goto('https://example.com');

Variáveis de Ambiente

Nunca codifique credenciais. Usar um .env arquivo e carregá-lo com dotenv:

require('dotenv').config();
const proxyUrl = `http://${process.env.PROXY_USER}:${process.env.PROXY_PASS}@gate.proxyhat.com:8080`;

Pronto para começar? Verificar os nossos planos de preços para encontrar a quantidade certa de largura de banda proxy residencial para o seu projeto.

Tiras de Chaves

• A Nó do ProxyHat SDK é a maneira mais rápida de adicionar suporte proxy. Instalar com npm install proxyhat e começar a obter em três linhas de código.
• Axios funciona com proxies via https-proxy-agent Ou o agente incorporado do SDK. Crie uma instância Axios reutilizável para eficiência.
• Puppeteer aceita proxies como argumento de lançamento. Chamada page.authenticate() para passar credenciais.
• dramaturgo possui suporte proxy nativo em suas opções de lançamento e contexto, incluindo proxies por contexto para raspagem multirregião.
• Utilização sessões pegajosas para fluxos de trabalho multi- etapas e IPs rotativos Para a recolha de dados em larga escala.
• Sempre implementar repetir a lógica com retrocesso exponencial e controlo da concorrência em raspadores de produção.
• Bloqueie recursos desnecessários em navegadores sem cabeça para reduzir a largura de banda e melhorar a velocidade.