Proxies in Node.js verwenden (Axios + Puppeteer + SDK)

Warum Proxies in Node.js verwenden?

Node.js ist eine der beliebtesten Laufzeiten für den Aufbau von Web-Schrottern, API-Integratoren und Automatisierungstools. Aber wenn Sie Hunderte oder Tausende von Anfragen von einer einzigen IP-Adresse senden, werden Sie schnell in Ratenlimits, CAPTCHAs und outright IP Verbote laufen. Proxies in Node.js Lösen Sie dies, indem Sie Ihre Anfragen durch verschiedene IP-Adressen, so dass jeder von einem einzigartigen Benutzer kommen.

Egal, ob Sie Produktpreise abkratzen, Suchmaschinen-Rankings überwachen oder öffentliche Daten im Maßstab sammeln, Proxies sind eine wesentliche Infrastruktur. In diesem Leitfaden werden wir alles abdecken, was Sie brauchen, um Wohn-Proxies in Ihre Node.js-Projekte mit der ProxyHat Node SDKAxios, Puppenspieler und Playwright.

Wenn Sie noch bewerten, welche Proxyart Ihrem Anwendungsfall passt, überprüfen Sie unseren Vergleich Wohnen vs datacenter vs mobile proxies.

Installation und Inbetriebnahme

Installation des ProxyHat SDK

Der schnellste Weg zum Start ist mit dem offiziellen Node SDK. Es behandelt Authentifizierung, Rotation und Verbindungspooling aus der Box:

npm install proxyhat

Sie möchten auch die HTTP-Clients, die Sie verwenden möchten:

npm install axios puppeteer playwright

Authentifizierung

Alle ProxyHat Proxy-Verbindungen authentifizieren sich über Ihre API-Anmeldeinformationen. Sie können Ihren Benutzernamen und Ihr Passwort in der ProxyHat dashboard. Das SDK akzeptiert sie als Konstruktor Optionen oder Umgebungsvariablen:

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

Einfaches GET Anfrage mit dem SDK

Das SDK bietet eine hohe Ebene fetch Verfahren, mit dem die Proxy-Rotation automatisch bearbeitet wird:

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

Jeder Anruf wählt automatisch eine andere Wohn-IP aus. Keine manuelle Proxy-URL-Formatierung erforderlich.

Verwendung von Proxies mit Axios

Axios ist der beliebteste HTTP Client im Node.js-Ökosystem. Um Axios-Anfragen über ProxyHat zu leiten, können Sie entweder die Proxy-URL des SDK verwenden oder Axios direkt konfigurieren.

Methode 1: SDK Proxy Agent

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

Methode 2: Direkte Proxy-URL

Wenn Sie eine manuelle Konfiguration bevorzugen, verwenden Sie das Standard-Proxy-URL-Format mit dem https-proxy-agent Paket:

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

Axios Instanz mit Default Proxy

Zur wiederholten Verwendung erstellen Sie eine vorkonfigurierte Axios-Instanz:

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

Proxies mit Puppenspieler

Puppeteer startet einen kopflosen Chrome-Browser, der ideal zum Abkratzen von JavaScript-heavy Websites ist. Proxies sind auf der Browser-Startebene konfiguriert.

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

Puppenspieler mit Geo-Targeting

Um ein bestimmtes Land anzusprechen, fügen Sie den Ländercode in Ihren Benutzernamen ein. ProxyHat verwendet das Format USERNAME-country-XX:

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

Alle verfügbaren Proxy-Standorte auf unseren Seite.

Proxies mit Playwright

Playwright unterstützt Chrom, Firefox und WebKit. Proxy-Konfiguration wird in die Startoptionen integriert, wodurch es noch einfacher:

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

Playwright ermöglicht verschiedene Proxies pro Browser-Kontext, was für Multi-Account oder Multi-Propaneel-Schrotten nützlich ist:

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 unterstützt zwei Sitzungsmodi, die unterschiedlichen Schrottanforderungen dienen:

Sticking Session Beispiel

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

Geo-Targeted Anfragen

Geo-Targeting ist für SERP-Tracking, lokalisierte Preisüberwachung und regionale Inhaltskontrolle. ProxyHat unterstützt Land- und Stadtebenen-Targeting durch Ihre Username-String:

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

Überprüfen Sie unsere vollständige Liste Standorte für unterstützte Länder und Städte.

Fehlerbehandlung und Retries

Netzwerkfehler sind bei der Arbeit mit Proxien im Maßstab unvermeidlich. Eine robuste Retry-Strategie ist für Produktionsabstreifer unerlässlich:

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

Concurrent Scraping mit Concurrency Control

Alle Anfragen gleichzeitig mit Promise.all kann sowohl Ihre Maschine als auch den Zielserver überwältigen. Verwenden Sie einen Konkursbegrenzer, um die Anzahl der Parallelverbindungen zu steuern:

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

Für großflächige Web-Schrottprojekte, die Konkurrenz zwischen 5 und 20 zu halten bietet eine gute Balance zwischen Geschwindigkeit und Zuverlässigkeit. Lesen Sie unseren Leitfaden auf der beste Proxies für Web-Schrott in 2026 für mehr Architekturberatung.

Produktionstipps

Verbindungsmanagement

• Verwenden Sie Axios-Instanzen und Proxy-Agenten, anstatt neue zu erstellen. Dies vermeidet eine Steckdosenerschöpfung.
• Set keepAlive: true auf Ihrem HTTP-Agent für persistente Verbindungen.
• Schließen Sie Puppeteer/Playwright-Browser sofort nach der Verwendung zum kostenlosen Speicher.

Erinnerung und Timeouts

• Für Puppenspieler, verwenden page.setRequestInterception(true) um Bilder, CSS und Schriftarten zu blockieren, wenn Sie nur HTML-Inhalte benötigen. Dies reduziert die Bandbreite und den Speicherverbrauch deutlich.
• Setzen Sie immer explizite Timeouts auf jeder Anfrage. Ein fehlender Timeout ist die Nummer eins Ursache für hängende Schaber.
• Monitor Node.js Speicher mit process.memoryUsage() bei langlaufenden Kratzern.

Fordern Sie die Rezeption für schnelleres Scraping an

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

Umweltvariablen

Nie Hardcode Anmeldeinformationen. Verwenden einer .env Datei und laden Sie es mit dotenv:

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

Fertig? Überprüfung unsere Preispläne die richtige Menge an Wohn-Proxy-Bandbreite für Ihr Projekt zu finden.

Schlüsselanhänger

• Die ProxyHat Node SDK ist der schnellste Weg, um Proxy-Unterstützung hinzuzufügen. Installieren mit npm install proxyhat und starten Sie in drei Zeilen von Code.
• Axios Arbeiten mit Proxies via https-proxy-agent oder der eingebaute Agent des SDK. Erstellen Sie eine wiederverwendbare Axios-Instanz für Effizienz.
• Plüschtiere akzeptiert Proxies als Start Argument. Anruf page.authenticate() um Anmeldeinformationen zu übergeben.
• Spiel hat native Proxy-Unterstützung in seinen Start- und Kontextoptionen, einschließlich Per-Context-Proxies für Multi-Region-Schrott.
• Verwendung klebrigen Sitzungen für mehrstufige Workflows und rotierende IPs für die groß angelegte Datenerhebung.
• Immer implementieren Retry-Logik mit exponentiellem Backoff und Konkurskontrolle in Produktionsabstreifern.
• Blockieren Sie unnötige Ressourcen in kopflosen Browsern, um die Bandbreite zu reduzieren und die Geschwindigkeit zu verbessern.