Für HTTP-Requests aus dem Main-Prozess hat Electron ein eigenes net-Modul, das den Chromium-Stack nutzt — anders als das klassische Node-http. Vorteil: System-Proxy-Settings, Session-Cookies und Authentifizierung werden automatisch berücksichtigt. Hier wann man's braucht und wie man's nutzt.
Drei Optionen für HTTP
| Modul | Wo | Stack |
|---|---|---|
Node http/https | Main + Renderer | Node-eigener TLS-Stack |
node:fetch (global) | Main + Renderer | Node oder undici |
Electron net | Main only | Chromium-Stack |
Web fetch (im Renderer) | Renderer | Chromium-Stack |
Faustregel:
- Im Renderer:
fetch(Web-Standard, automatisch Chromium) - Im Main für externe APIs ohne App-Kontext:
fetch(global, Node) - Im Main für Requests, die App-Session/Proxy/Cookies mitnutzen sollen: Electron
net
Modernes net.fetch
Seit Electron 21 ist net.fetch Standard — eine Web-API-konforme Variante:
import { net } from 'electron';
const res = await net.fetch('https://api.example.com/data');
const data = await res.json();Genau wie fetch im Browser — aber:
- Nutzt Chromium-Network-Stack (Proxy, Cert-Store, HTTP/2, HTTP/3)
- Respektiert die App-Session (Cookies, Auth)
- Funktioniert mit
app://-URLs (siehe Custom Protocols)
Session-spezifische Requests
import { net, session } from 'electron';
// Default-Session (gleich wie BrowserWindow ohne partition)
const res1 = await net.fetch('https://example.com/');
// Spezifische Session — z. B. der User-A-Partition
const sessionA = session.fromPartition('persist:user-a');
const res2 = await net.fetch('https://example.com/', { session: sessionA });Klassischer Use-Case: ein User ist im Renderer eingeloggt (Cookies sind in der Session), und der Main-Prozess will im selben Auth-Kontext Requests machen — z. B. für Background-Sync.
Klassisches net.request
Vor net.fetch war net.request die einzige Option — Stream-basiert, ähnlich Node http.request:
const request = net.request({
method: 'GET',
url: 'https://example.com/large-file'
});
request.on('response', (response) => {
const chunks = [];
response.on('data', (chunk) => chunks.push(chunk));
response.on('end', () => {
const buffer = Buffer.concat(chunks);
// ...
});
});
request.end();Für Streaming oder sehr große Downloads. Bei normalen Calls ist net.fetch einfacher.
Proxy-Konfiguration
Default: System-Proxy wird automatisch genutzt. Für Override:
import { session } from 'electron';
await session.defaultSession.setProxy({
proxyRules: 'http://proxy.example.com:8080',
proxyBypassRules: 'localhost,*.intranet'
});Wichtig: Proxy ist Session-basiert. Pro session.fromPartition kann eine eigene Proxy-Konfig gelten.
Authentifizierung
import { app } from 'electron';
// System-weite Auth-Anfragen (Basic, NTLM, Negotiate)
app.on('login', (event, _webContents, _request, authInfo, callback) => {
event.preventDefault();
callback('username', 'password');
});Wer Custom-Auth-Header braucht: in net.fetch direkt mitgeben:
const res = await net.fetch('https://api.example.com/secure', {
headers: {
'Authorization': `Bearer ${token}`
}
});Cert-Pinning und Trust
// Custom CA / selbst-signierte Zertifikate akzeptieren
app.on('certificate-error', (event, _webContents, url, _error, _certificate, callback) => {
if (url.startsWith('https://internal.company.com')) {
event.preventDefault();
callback(true); // akzeptieren
} else {
callback(false); // ablehnen
}
});Für interne CAs oder Test-Setups. Niemals pauschal callback(true) — das macht jede MITM-Attack möglich.
Besonderheiten
net.fetch ist der moderne Default.
Web-API-kompatibel, Promise-basiert, mit dem Chromium-Stack. Für einfache Requests aus dem Main: lieber net.fetch als node:fetch — die App-Session wird mitgenommen.
System-Proxy wird AUTOMATISCH respektiert.
Im Gegensatz zu Node-http/https: Electron net liest die OS-Proxy-Settings standardmäßig. In Enterprise-Umgebungen mit Proxy-Pflicht ein wichtiger Unterschied.
Cookies aus dem Renderer in Main-Requests teilen.
Wenn der Renderer beim Login Cookies gesetzt hat, kann der Main in derselben Session ohne Auth-Header Requests machen — Cookies werden mitgeschickt. Sehr praktisch für Background-Sync.
net ist nur im Main verfügbar.
Im Renderer-Prozess: fetch benutzen — das ist sowieso schon Chromium-Stack. Im Sandbox-Renderer kein Import-Zugriff auf net.
HTTP/2 und HTTP/3 funktionieren out of the box.
Chromium-Stack unterstützt moderne Protokolle. Bei Server-Sent-Events und WebSockets gleiche Story — funktioniert ohne extra Setup.
certificate-error-Handler nur restriktiv nutzen.
Wer pauschal alle Zertifikatsfehler akzeptiert: macht die App offen für MITM. Immer URL-basiert prüfen, am besten nur für definierte interne Hosts.