Utiliser des proxies en Node.js (Axios + Puppeteer + SDK)

Pourquoi utiliser Proxies dans Node.js?

Node.js est l'un des runtimes les plus populaires pour la construction de racleurs web, intégrateurs API et outils d'automatisation. Mais si vous envoyez des centaines ou des milliers de demandes à partir d'une seule adresse IP, vous tomberez rapidement dans des limites de tarifs, CAPTCHAs, et des interdictions de PI pur et simple. Proxies dans Node.js Résoudre cela en acheminant vos requêtes à travers différentes adresses IP, ce qui fait que chacune semble provenir d'un utilisateur unique.

Que vous racliez les prix des produits, que vous surveilliez les classements des moteurs de recherche ou que vous recueilliez des données publiques à l'échelle, les procurations sont une infrastructure essentielle. Dans ce guide, nous couvrirons tout ce dont vous avez besoin pour intégrer les proxies résidentielles dans vos projets Node.js en utilisant la ProxyHat Node SDKAxios, Puppeteer et Playwright.

Si vous évaluez toujours quel type de proxy correspond à votre cas d'utilisation, consultez notre comparaison de proxies résidentiels vs datacenter vs mobiles.

Installation et configuration

Installation du SDK ProxyHat

Le moyen le plus rapide pour commencer est le Node SDK officiel. Il gère l'authentification, la rotation et la mise en commun des connexions hors de la boîte:

npm install proxyhat

Vous voudrez aussi que les clients HTTP que vous prévoyez utiliser :

npm install axios puppeteer playwright

Authentification

Toutes les connexions proxyHat proxy authentifient via vos identifiants API. Vous pouvez trouver votre nom d'utilisateur et votre mot de passe dans le Tableau de bord ProxyHat. Le SDK les accepte comme des options de constructeur ou des variables d'environnement:

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

Simple GET Demande avec le SDK

Le SDK fournit un haut niveau fetch méthode qui gère automatiquement la rotation de 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);

Chaque appel sélectionne automatiquement une IP résidentielle différente. Aucun formatage manuel d'URL proxy.

Utilisation de Proxies avec Axios

Axios est le client HTTP le plus populaire de l'écosystème Node.js. Pour parcourir les requêtes Axios via ProxyHat, vous pouvez soit utiliser l'URL proxy du SDK ou configurer Axios directement.

Méthode 1 : Agent mandataire 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éthode 2: URL de proxy direct

Si vous préférez la configuration manuelle, utilisez le format URL proxy standard avec le https-proxy-agent colis:

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

Instance Axios avec proxy par défaut

Pour une utilisation répétée, créez une instance Axios préconfigurée :

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

Utilisation de Proxies avec Puppeteer

Puppeteer lance un navigateur Chrome sans tête , qui est idéal pour gratter des sites JavaScript-lourds . Les proxies sont configurées au niveau du lancement du navigateur.

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 avec géo-tarification

Pour cibler un pays spécifique, incluez le code du pays dans votre nom d'utilisateur. ProxyHat utilise le format USERNAME-country-XX:

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

Parcourez tous les emplacements de proxy disponibles sur notre emplacement page.

Utilisation de Proxies avec Playwright

Playwright prend en charge Chrome, Firefox et WebKit. La configuration proxy est intégrée dans les options de lancement, ce qui la rend encore plus simple:

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

Dramaturge avec proxies par contexte

Playwright permet différents proxies par contexte de navigateur, qui est utile pour le grattage multi-comptes ou multi-régions:

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

Sessions rotatives et séances collantes

ProxyHat prend en charge deux modes de session qui répondent à différents besoins de grattage :

Exemple de séance collante

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

Demandes géographiées

Le géo-ciblage est essentiel pour Suivi SERP, suivi localisé des prix et vérification du contenu régional. ProxyHat prend en charge le ciblage au niveau du pays et de la ville via votre chaîne de noms d'utilisateur :

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

Consultez notre liste complète de lieux disponibles pour les pays et les villes soutenus.

Gestion des erreurs et retraits

Les erreurs de réseau sont inévitables lorsque vous travaillez avec des mandataires à l'échelle. Une stratégie robuste de réessayer est essentielle pour les racleurs de production:

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 concomitant avec contrôle des devises

Envoi de toutes les demandes en même temps avec Promise.all peut submerger votre machine et le serveur cible. Utilisez un limiteur de concordance pour contrôler le nombre de connexions parallèles :

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

Pour grande échelle projets de démolition de réseaux, maintenir la concordance entre 5 et 20 offre un bon équilibre entre vitesse et fiabilité. Lisez notre guide sur la les meilleurs proxies pour le grattage de toile en 2026 pour plus de conseils en architecture.

Conseils de production

Gestion des connexions

• Réutiliser les instances Axios et les mandataires au lieu de créer de nouveaux mandataires par requête. Cela évite l'épuisement des prises.
• Jeu keepAlive: true sur votre agent HTTP pour les connexions persistantes.
• Fermer les navigateurs Puppeteer / Playwright rapidement après l'utilisation à la mémoire libre.

Mémoire et chronométrage

• Pour Puppeteer, utiliser page.setRequestInterception(true) pour bloquer les images, CSS et polices lorsque vous avez seulement besoin de contenu HTML. Cela réduit considérablement la bande passante et l'utilisation de la mémoire.
• Toujours définir des délais explicites sur chaque demande. Un temps mort manquant est la cause numéro un des racleurs suspendus.
• Moniteur Node.js mémoire avec process.memoryUsage() dans des racleurs de longue durée.

Demande d'interception pour un scraping plus rapide

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

Variables d'environnement

Jamais de code dur. Utiliser un .env fichier et le charger avec dotenv:

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

Prêt à commencer ? Vérifier nos plans de prix pour trouver la bonne quantité de bande passante proxy résidentielle pour votre projet.

A emporter des clés

• Les ProxyHat Node SDK est le moyen le plus rapide pour ajouter le support mandataire. Installer avec npm install proxyhat et commencer à chercher dans trois lignes de code.
• Axios fonctionne avec des mandataires via https-proxy-agent ou l'agent intégré du SDK. Créez un exemple Axios réutilisable pour l'efficacité.
• Puppéteur accepte les procurations comme argument de lancement. Appeler page.authenticate() pour passer les lettres de créances.
• Dramaturge a un support proxy natif dans ses options de lancement et de contexte, y compris les proxys par contexte pour le grattage multi-régions.
• Utilisation sessions collantes pour les flux de travail en plusieurs étapes et IP tournants pour la collecte de données à grande échelle.
• Toujours mettre en œuvre réessayer la logique avec un recul exponentiel et Contrôle de la convergence dans les racleurs de production.
• Bloquer les ressources inutiles dans les navigateurs sans tête pour réduire la bande passante et améliorer la vitesse.