# Puppeteer Proxy-Authentifizierung mit Residential- und mobile 4G-Proxys

> Puppeteer Proxy-Authentifizierung: --proxy-server plus page.authenticate(), eine Sitzung pro Browser-Kontext, Anfrageinterzeption zur Traffic-Einsparung.

- URL: https://crawlrelay.com/de/docs/puppeteer/
- Zuletzt aktualisiert: 2026-10-13
- Publisher: CrawlRelay (https://crawlrelay.com)

Chrome nimmt die Proxy-Adresse aus einem Start-Flag und die Zugangsdaten aus page.authenticate(). Verwenden Sie pro Sitzung einen Browser-Kontext, damit die Zugangsdaten nicht zwischen Jobs durchsickern.

**Kurze Antwort — Wie benutze ich einen authentifizierten Proxy in Puppeteer?**

Starten Sie Chrome mit `--proxy-server=http://gw.crawlrelay.com:7777`, rufen Sie dann vor der ersten `goto` `page.authenticate({ username, password })` auf. Chrome ignoriert Zugangsdaten im Flag. **CrawlRelay** Residential-Proxys lesen Land und Sticky Session aus dem Benutzernamen, so hat jede Seite oder jeder Kontext seinen eigenen Exit. Traffic kostet 0,50 $/GB ab 50 GB. Bezahlen Sie mit Krypto, ohne KYC.

## Puppeteer Einrichtung auf einen Blick

| Attribut | Wert |
| --- | --- |
| Proxy-Adresse | `--proxy-server=http://gw.crawlrelay.com:7777` in `args` oder `proxyServer` in einem Browser-Kontext |
| Zugangsdaten | `await page.authenticate({ username, password })` vor der Navigation |
| Separate Sessions | `browser.createBrowserContext({ proxyServer })`: ein Kontext pro Sitzung |
| SOCKS5 | Nicht mit Authentifizierung in Chrome: verwenden Sie den HTTP-Port |
| Traffic sparen | `page.setRequestInterception(true)` und brechen Sie Bilder, Schriften und Medien ab |

## Wie richte ich einen einzelnen authentifizierten Proxy ein?

Das ist das minimalste Muster. Der `try … finally` Block schließt Chrome auch, wenn eine Navigation fehlschlägt - wichtig auf Servern, wo verwaiste Browser sich anhäufen.

*Node.js (ES Modul): ein Browser, ein Exit*

```javascript
import puppeteer from "puppeteer";

const browser = await puppeteer.launch({
  args: ["--proxy-server=http://gw.crawlrelay.com:7777"],
});
try {
  const page = await browser.newPage();
  await page.authenticate({ username: "USERNAME-country-us", password: "PASSWORD" });
  await page.setRequestInterception(true);
  page.on("request", (req) =>
    ["image", "font", "media"].includes(req.resourceType()) ? req.abort() : req.continue()
  );
  const res = await page.goto("https://example.com/", { waitUntil: "domcontentloaded", timeout: 60000 });
  console.log(res.status(), await page.title());
} finally {
  await browser.close();
}
```

## Wie führe ich mehrere Sessions oder Länder in einem Browser aus?

Erstellen Sie pro Sitzung einen Browser-Kontext. Ein Kontext ist ein isoliertes Profil mit eigenen Cookies, Cache und Netzwerkstatus, so dass die Zugangsdaten eines Kontexts nicht in einen anderen gelangen. Geben Sie jedem Kontext einen Benutzernamen mit eigenem Land oder Sitzungs-ID.

*Node.js: ein Kontext pro Sticky-Session*

```javascript
import puppeteer from "puppeteer";
import { randomUUID } from "node:crypto";

const GATEWAY = "http://gw.crawlrelay.com:7777";
const browser = await puppeteer.launch();

async function visit(country, url) {
  const session = randomUUID().replaceAll("-", "").slice(0, 10);
  const context = await browser.createBrowserContext({ proxyServer: GATEWAY });
  try {
    const page = await context.newPage();
    await page.authenticate({
      username: `USERNAME-country-${country}-session-${session}-ttl-20`,
      password: "PASSWORD",
    });
    await page.goto(url, { waitUntil: "domcontentloaded", timeout: 60000 });
    return { country, session, ip: await page.evaluate(() => document.body.innerText.trim()) };
  } finally {
    await context.close();
  }
}

try {
  const results = await Promise.all([
    visit("us", "https://api.ipify.org"),
    visit("gb", "https://api.ipify.org"),
  ]);
  console.table(results);
} finally {
  await browser.close();
}
```

## Warum zeigt Puppeteer einen 407 oder ERR_TUNNEL_CONNECTION_FAILED?

Weil Chrome keine oder falsche Zugangsdaten gesendet hat. Prüfen Sie drei Dinge:

1. `page.authenticate()` läuft **vor** der ersten `goto` auf dieser Seite.
2. Das `--proxy-server`-Flag oder `proxyServer` enthält nur Schema, Host und Port, kein `user:pass@`-Teil.
3. Der Benutzername hat keinen Tippfehler im Zielteil: testen Sie ihn zuerst mit curl, wie auf der [407-Seite](https://crawlrelay.com/de/docs/errors/407-proxy-authentication-required/) gezeigt.

Gelingt curl mit Benutzername und Passwort und Puppeteer schlägt trotzdem fehl, lesen Sie [ERR_TUNNEL_CONNECTION_FAILED](https://crawlrelay.com/de/docs/errors/err-tunnel-connection-failed/).

## Wie viel Traffic verursacht eine Puppeteer-Seite?

Alles, was Chrome lädt, wird berechnet: HTML, Skripte, Styles, Bilder, Schriften und die API-Aufrufe der Seite. Der HTTP Archive Web Almanac 2025 ermittelte ein Median-Seitengewicht von 2.164 KB mobil und 2.412 KB Desktop. Das Blockieren von Bildern, Schriften und Medien per Anfrageinterzeption reduziert dies meist auf ein paar hundert KB, das Zurückliefern gecachter Antworten für wiederholte Skripte spart noch mehr. Verwenden Sie [rotierende mobile IPs](https://crawlrelay.com/de/mobile-proxies/) nur für Seiten, die sie brauchen: mobiler Traffic kostet 1,50 $/GB ab 5 GB, Residential-Proxys 0,50 $/GB ab 50 GB.

## Puppeteer und Proxys: Fragen

### Kann ich Benutzername und Passwort in --proxy-server setzen?

Nein. Chrome ignoriert Zugangsdaten im `--proxy-server`-Flag, die erste HTTPS-Anfrage schlägt dann mit einem 407 fehl, versteckt hinter `ERR_TUNNEL_CONNECTION_FAILED`. Setzen Sie nur `http://host:port` ins Flag und übergeben Sie die Zugangsdaten mit `page.authenticate()` bei jeder neuen Seite.

### Wie rotiere ich die IP zwischen Seiten in Puppeteer?

Öffnen Sie jede Seite in einem neuen Browser-Kontext oder geben Sie jeder Seite einen Benutzernamen ohne Sitzungs-ID. Ein neuer Kontext öffnet neue Verbindungen, und jede neue Verbindung erhält gewöhnlich einen anderen Residential-Exit. Innerhalb einer Seite verwendet Chrome Verbindungen weiter, so dass Anfragen zur selben Seite oft denselben Exit teilen, bis die Verbindung schließt.

### Funktioniert page.authenticate() mit Anfrageinterzeption?

Ja. Puppeteer bearbeitet die Authentifizierungs-Anforderung des Proxys selbst, Ihr Interzeptions-Handler muss nur `continue()` oder `abort()` für jede Anfrage aufrufen. Richten Sie zuerst `authenticate()` ein, dann schalten Sie Interception an, wie im ersten Beispiel.

### Sollte ich puppeteer-extra Stealth Plugins mit Proxys verwenden?

Wir dokumentieren oder unterstützen keine Tools, die Automatisierung verbergen oder Bot-Erkennung umgehen sollen. Deren Zweck ist es, eine Entscheidung einer Seite zu umgehen, automatisierte Besucher herauszufiltern, was unsere [Acceptable Use Policy](https://crawlrelay.com/de/acceptable-use/) nicht erlaubt. Rufen Sie öffentliche Seiten in angemessenem Tempo auf und nutzen Sie offizielle APIs, wenn sie verfügbar sind.

### Welchen Chrome benutzt Puppeteer mit dem Proxy?

Neuere Puppeteer-Versionen laden standardmäßig eine passende Chrome for Testing-Version herunter und verwenden diese. Die Proxy-Flags und `page.authenticate()` funktionieren dort genauso wie im regulären Chrome. Wenn Sie Puppeteer auf Ihren eigenen Chrome mit `executablePath` zeigen lassen, halten Sie diesen Browser aktuell.

**Puppeteer über Residential-Proxys ausführen** 5,94 $ für 10 GB, 0,50 $/GB von 50 GB. [Preise ansehen](https://crawlrelay.com/de/pricing/) · [Node.js Anleitung](https://crawlrelay.com/de/docs/node/)

---

CrawlRelay: CrawlRelay ist ein entwicklerfreundlicher rotierender Residential-Proxy- und 4G/5G mobile Proxy-Service für Scraper und KI-Datenpipelines: nicht verfallende Pay-as-you-go-Traffic ab 0,50 $/GB, mit Krypto bezahlt, ohne ID-Upload. Kein KYC — keine ID, kein Selfie, keine Dokumente. Mit Krypto bezahlen.