Utilizzo dei proxy in Node.js (Axios + Puppeteer + SDK)

Perché utilizzare i proxy in Node.js?

Node.js è uno dei runtime più popolari per la costruzione di raschietti web, integratori API e strumenti di automazione. Ma se state inviando centinaia o migliaia di richieste da un unico indirizzo IP, si correrà rapidamente nei limiti di velocità, CAPTCHA e divieti IP. Proxies in Node.js risolvere questo problema inviando le vostre richieste attraverso diversi indirizzi IP, rendendo ciascuno sembra provenire da un utente unico.

Che si tratti di raschiare i prezzi dei prodotti, monitorare le classifiche dei motori di ricerca, o la raccolta di dati pubblici in scala, i proxy sono infrastrutture essenziali. In questa guida, copriremo tutto il necessario per integrare i proxy residenziali nei vostri progetti Node.js utilizzando SDK del nodo del proxy, Axios, Puppeteer e Playwright.

Se stai ancora valutando quale tipo di proxy si adatta al tuo caso di utilizzo, controlla il nostro confronto di residenziale vs datacenter vs proxy mobili.

Installazione e configurazione

Installazione di ProxyHat SDK

Il modo più veloce per iniziare è con il Node SDK ufficiale. Gestisce l'autenticazione, la rotazione e la connessione di pooling fuori dalla scatola:

npm install proxyhat

Si desidera anche i client HTTP che si prevede di utilizzare:

npm install axios puppeteer playwright

Autenticazione

Tutte le connessioni proxy ProxyHat autenticano tramite le credenziali API. Puoi trovare il tuo nome utente e la tua password cruscotto ProxyHat. L'SDK li accetta come opzioni di costruzione o variabili di 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();

GET semplice Richiesta con SDK

L'SDK fornisce un livello elevato fetch metodo che gestisce automaticamente la rotazione del 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);

Ogni chiamata seleziona automaticamente un IP residenziale diverso. Non è necessaria la formattazione manuale dell'URL proxy.

Utilizzo di Proxies con Axios

Axios è il client HTTP più popolare nell'ecosistema Node.js. Per indirizzare le richieste di Axios tramite ProxyHat, è possibile utilizzare l'URL proxy di SDK o configurare Axios direttamente.

Metodo 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();

Metodo 2: Direct Proxy URL

Se si preferisce la configurazione manuale, utilizzare il formato standard proxy URL con il https-proxy-agent pacchetto:

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();

Axiosista con Proxy predefinito

Per un uso ripetuto, creare un'istanza Axios preconfigurata:

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');

Utilizzo di proxy con Puppeteer

Puppeteer lancia un browser Chrome senza testa, che è ideale per la demolizione di siti web JavaScript-heavy. I proxy sono configurati al livello di lancio del browser.

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 con Geo-Targeting

Per indirizzare un paese specifico, includere il codice paese nel tuo nome utente. ProxyHat utilizza il formato USERNAME-country-XX:

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

Sfoglia tutte le posizioni proxy disponibili sul nostro pagina delle sedi.

Utilizzo di Proxies con Playwright

Playwright supporta Chromium, Firefox e WebKit. La configurazione del proxy è integrata nelle opzioni di lancio, rendendolo ancora più semplice:

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 con Per-Context Proxies

Playwright permette diversi proxy per contesto del browser, che è utile per la raschiatura multi-account o multi-regione:

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'),
]);

Rotating vs Sticky Sessions

ProxyHat supporta due modalità di sessione che servono diverse esigenze di raschiamento:

Esempio di sessione Sticky

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

Richieste Geo-Targeted

Geo-targeting è fondamentale per monitoraggio SERP, monitoraggio dei prezzi localizzato e verifica dei contenuti regionali. ProxyHat supporta il targeting di livello nazionale e di livello città attraverso la stringa del nome utente:

// 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'
);

Controlla la nostra lista completa di luoghi disponibili per i paesi e le città sostenute.

Gestione degli errori e Retries

Gli errori di rete sono inevitabili quando si lavora con i proxy in scala. Una solida strategia di riprovazione è essenziale per i raschiatori di produzione:

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,
});

Scraping con corrente con controllo di frequenza

Inviare tutte le richieste contemporaneamente Promise.all può sopraffare sia la macchina che il server di destinazione. Utilizzare un limitatore di frequenza per controllare il numero di connessioni parallele:

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 });
});

Per grandi dimensioni web scraping progetti, mantenere la convalutazione tra 5 e 20 offre un buon equilibrio tra velocità e affidabilità. Leggi la nostra guida migliori proxy per la raschiatura web nel 2026 per ulteriori consigli di architettura.

Consigli di produzione

Gestione della connessione

• Riutilizzare le istanze Axios e gli agenti proxy invece di crearne di nuovi per richiesta. Questo evita la stanchezza della presa.
• Set keepAlive: true sul tuo agente HTTP per connessioni persistenti.
• Chiudere i browser Puppeteer/Playwright subito dopo l'uso per la memoria gratuita.

Memoria e Timeout

• Per Puppeteer, utilizzare page.setRequestInterception(true) per bloccare immagini, CSS e font quando hai solo bisogno di contenuti HTML. Questo riduce la larghezza di banda e l'utilizzo della memoria in modo significativo.
• Impostare sempre timeout espliciti su ogni richiesta. Un timeout mancante è la causa numero uno di raschietti appesi.
• Monitora la memoria Node.js con process.memoryUsage() in raschietti lunghi.

Richiedi Intercettazione per Scraping più veloce

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');

Variabili dell'ambiente

Mai le credenziali di codice. Utilizzare .env file e caricare con dotenv:

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

Pronto per iniziare? Check i nostri piani di prezzi per trovare la giusta quantità di banda proxy residenziale per il vostro progetto.

Asporto chiave

• The SDK del nodo del proxy è il modo più veloce per aggiungere supporto proxy. Installare con npm install proxyhat e iniziare a prendere in tre linee di codice.
• Axios opere con proxy via https-proxy-agent o l'agente integrato della SDK. Creare un'istanza Axios riutilizzabile per l'efficienza.
• Puppete accetta i proxy come argomento di lancio. Chiamata page.authenticate() per passare le credenziali.
• Giocare a destra ha supporto proxy nativo nelle sue opzioni di lancio e contesto, compresi i proxy per-context per la raschiatura multi-regione.
• Uso sessioni appiccicose per flussi di lavoro multi-step e IP rotanti per la raccolta di dati su larga scala.
• Attuare sempre retry logica con backoff esponenziale e controllo della concorrenza in raschietti di produzione.
• Bloccare risorse inutili nei browser senza testa per ridurre la larghezza di banda e migliorare la velocità.