So konfigurieren Sie Proxy-Server für das PDF-Rendering in C

Minimaler Arbeitsablauf (3 Schritte)

1. Installieren Sie IronPDF über NuGet: Install-Package IronPdf
2. Übergeben Sie die Proxy-Zeichenkette als dritten Parameter an RenderHtmlAsPdf
3. Format: http(s)://host:port oder http(s)://user:pass@host:port für authentifizierte Proxys

Wie übergibt man einen Proxy an RenderHtmlAsPdf?

Der Parameter Proxy ist ein optionaler string in vier Methodensignaturen:

// Instance methods
PdfDocument RenderHtmlAsPdf(string Html, string BaseUrlOrPath, string Proxy = null)
PdfDocument RenderHtmlAsPdf(string Html, Uri BaseUrl = null, string Proxy = null)

// Static methods
PdfDocument StaticRenderHtmlAsPdf(string Html, ChromePdfRenderOptions Options = null, string Proxy = null)
PdfDocument StaticRenderHtmlAsPdf(string Html, string BaseUrlOrPath, ChromePdfRenderOptions Options = null, string Proxy = null)

// Instance methods
PdfDocument RenderHtmlAsPdf(string Html, string BaseUrlOrPath, string Proxy = null)
PdfDocument RenderHtmlAsPdf(string Html, Uri BaseUrl = null, string Proxy = null)

// Static methods
PdfDocument StaticRenderHtmlAsPdf(string Html, ChromePdfRenderOptions Options = null, string Proxy = null)
PdfDocument StaticRenderHtmlAsPdf(string Html, string BaseUrlOrPath, ChromePdfRenderOptions Options = null, string Proxy = null)

' Instance methods
Function RenderHtmlAsPdf(Html As String, BaseUrlOrPath As String, Optional Proxy As String = Nothing) As PdfDocument
End Function

Function RenderHtmlAsPdf(Html As String, Optional BaseUrl As Uri = Nothing, Optional Proxy As String = Nothing) As PdfDocument
End Function

' Static methods
Shared Function StaticRenderHtmlAsPdf(Html As String, Optional Options As ChromePdfRenderOptions = Nothing, Optional Proxy As String = Nothing) As PdfDocument
End Function

Shared Function StaticRenderHtmlAsPdf(Html As String, BaseUrlOrPath As String, Optional Options As ChromePdfRenderOptions = Nothing, Optional Proxy As String = Nothing) As PdfDocument
End Function

Wenn dieser Parameter auf null (Standard) gesetzt ist, stellt die Chromium-Engine von IronPDF eine direkte Verbindung zu externen Ressourcen her – Stylesheets, Bilder, Schriftarten und JavaScript-Dateien, auf die in Ihrem HTML-Code verwiesen wird. Wenn Sie eine Proxy-Zeichenkette angeben, werden alle HTTP/HTTPS-Anfragen der Rendering-Engine über diesen Proxy geleitet.

using IronPdf;

var renderer = new ChromePdfRenderer();

// Direct connection (default — no proxy)
var pdfDirect = renderer.RenderHtmlAsPdf("<h1>Direct</h1>");

// Through an unauthenticated proxy
var pdfProxied = renderer.RenderHtmlAsPdf(
    "<h1>Proxied</h1>",
    baseUrlOrPath: null,
    proxy: "http://squid.internal:3128"
);

// Using the Uri overload
var pdfUri = renderer.RenderHtmlAsPdf(
    "<h1>Proxied via Uri overload</h1>",
    baseUrl: new Uri("https://assets.example.com/"),
    proxy: "https://proxy.co/rp.local:8443"
);

using IronPdf;

var renderer = new ChromePdfRenderer();

// Direct connection (default — no proxy)
var pdfDirect = renderer.RenderHtmlAsPdf("<h1>Direct</h1>");

// Through an unauthenticated proxy
var pdfProxied = renderer.RenderHtmlAsPdf(
    "<h1>Proxied</h1>",
    baseUrlOrPath: null,
    proxy: "http://squid.internal:3128"
);

// Using the Uri overload
var pdfUri = renderer.RenderHtmlAsPdf(
    "<h1>Proxied via Uri overload</h1>",
    baseUrl: new Uri("https://assets.example.com/"),
    proxy: "https://proxy.co/rp.local:8443"
);

Imports IronPdf

Dim renderer As New ChromePdfRenderer()

' Direct connection (default — no proxy)
Dim pdfDirect = renderer.RenderHtmlAsPdf("<h1>Direct</h1>")

' Through an unauthenticated proxy
Dim pdfProxied = renderer.RenderHtmlAsPdf(
    "<h1>Proxied</h1>",
    baseUrlOrPath:=Nothing,
    proxy:="http://squid.internal:3128"
)

' Using the Uri overload
Dim pdfUri = renderer.RenderHtmlAsPdf(
    "<h1>Proxied via Uri overload</h1>",
    baseUrl:=New Uri("https://assets.example.com/"),
    proxy:="https://proxy.co/rp.local:8443"
)

Die Proxy-Zeichenkette unterstützt sowohl das Schema http:// als auch das Schema https://. Verwenden Sie https://, wenn der Proxy selbst eine TLS-Verschlüsselung für die Verbindung zwischen Ihrer Anwendung und dem Proxy-Server erfordert. Das Schema bezieht sich hier auf die Proxy-Verbindung, nicht auf die endgültige Ressource – ein http://-Proxy kann weiterhin https://-Ressourcen über CONNECT-Tunneling abrufen.

Die statischen Methodenvarianten akzeptieren denselben Proxy-Parameter, was für einmalige Renderings in Konsolenanwendungen oder Unit-Tests nützlich ist:

// Static render with proxy — no renderer instance needed
var pdf = ChromePdfRenderer.StaticRenderHtmlAsPdf(
    "<h1>Static render through proxy</h1>",
    options: null,
    proxy: "http://proxy.co/rp.local:8080"
);

// Static render with proxy — no renderer instance needed
var pdf = ChromePdfRenderer.StaticRenderHtmlAsPdf(
    "<h1>Static render through proxy</h1>",
    options: null,
    proxy: "http://proxy.co/rp.local:8080"
);

' Static render with proxy — no renderer instance needed
Dim pdf = ChromePdfRenderer.StaticRenderHtmlAsPdf(
    "<h1>Static render through proxy</h1>",
    options:=Nothing,
    proxy:="http://proxy.co/rp.local:8080"
)

Wichtig: Es gibt keine Proxy-Eigenschaft bei ChromePdfRenderOptions. Suchen Sie dort nicht danach. Der Proxy ist ausschließlich ein Methodenparameter bei den Überladungen von RenderHtmlAsPdf und FromHtml.

Wie authentifiziert man sich über einen Unternehmensproxy?

Die meisten Enterprise-Proxys erfordern Anmeldedaten. Sie binden sie direkt in die Proxy-URL ein, indem Sie das Format http(s)://username:password@host:port verwenden:

using IronPdf;

var renderer = new ChromePdfRenderer();

string proxyWithAuth = "http://svc-account:P%40ssw0rd%21@proxy.co/rp.local:8080";

PdfDocument pdf = renderer.RenderHtmlAsPdf(
    htmlContent,
    baseUrlOrPath: @"C:\templates\assets\",
    proxy: proxyWithAuth
);
pdf.SaveAs("report.pdf");

using IronPdf;

var renderer = new ChromePdfRenderer();

string proxyWithAuth = "http://svc-account:P%40ssw0rd%21@proxy.co/rp.local:8080";

PdfDocument pdf = renderer.RenderHtmlAsPdf(
    htmlContent,
    baseUrlOrPath: @"C:\templates\assets\",
    proxy: proxyWithAuth
);
pdf.SaveAs("report.pdf");

Imports IronPdf

Dim renderer As New ChromePdfRenderer()

Dim proxyWithAuth As String = "http://svc-account:P%40ssw0rd%21@proxy.co/rp.local:8080"

Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(
    htmlContent,
    baseUrlOrPath: "C:\templates\assets\",
    proxy:=proxyWithAuth
)
pdf.SaveAs("report.pdf")

Sonderzeichen in Passwörtern müssen URL-kodiert werden. Wenn Ihr Passwort @, #, :, / oder andere reservierte URI-Zeichen enthält, müssen diese prozentkodiert werden. Gängige Kodierungen:

Verwenden Sie Uri.EscapeDataString(), um das Passwort programmgesteuert zu verschlüsseln:

string rawPassword = "P@ssw0rd!";
string encoded = Uri.EscapeDataString(rawPassword); // "P%40ssw0rd%21"
string proxy = $"http://svc-account:{encoded}@proxy.co/rp.local:8080";

string rawPassword = "P@ssw0rd!";
string encoded = Uri.EscapeDataString(rawPassword); // "P%40ssw0rd%21"
string proxy = $"http://svc-account:{encoded}@proxy.co/rp.local:8080";

Imports System

Dim rawPassword As String = "P@ssw0rd!"
Dim encoded As String = Uri.EscapeDataString(rawPassword) ' "P%40ssw0rd%21"
Dim proxy As String = $"http://svc-account:{encoded}@proxy.co/rp.local:8080"

Verwechseln Sie die Proxy-Authentifizierung nicht mit der Webseiten-Authentifizierung. Die Eigenschaften ChromeHttpLoginCredentials.Net/workUsername und NetworkPassword dienen der Authentifizierung gegenüber der gerenderten Webseite (NTLM/Negotiate mit einer Website), nicht gegenüber einem Proxy-Server. Für die Proxy-Authentifizierung werden die Anmeldedaten wie oben gezeigt in die Proxy-URL-Zeichenkette eingefügt.

Wie werden URLs hinter einem Proxy gerendert?

RenderUrlToPdf akzeptiert keinen Proxy-Parameter. Dies ist eine bewusste Entscheidung beim API-Design – NavigateUrl navigiert Chromium zu einer URL, und die Proxy-Konfiguration für diese Navigation wird anders gehandhabt als beim Laden von Ressourcen während der HTML-Darstellung.

Die empfohlene Vorgehensweise: Rufen Sie den HTML-Code selbst ab, indem Sie HttpClient mit einem HttpProxy konfigurieren, und übergeben Sie dann die HTML-Zeichenkette an RenderHtmlAsPdf mit dem Proxy-Parameter (damit referenzierte Assets – Bilder, CSS, Schriftarten – ebenfalls über den Proxy geleitet werden).

using IronPdf;
using System.Net;
using System.Net.Http;

// Step 1: Configure HttpClient with the corporate proxy
var proxy = new WebProxy("http://proxy.co/rp.local:8080")
{
    Credentials = new NetworkCredential("svc-account", "P@ssw0rd!")
};

var handler = new HttpClientHandler { Proxy = proxy, UseProxy = true };
using var httpClient = new HttpClient(handler);

// Step 2: Fetch the HTML from the target URL
string targetUrl = "https://dashboard.internal.co/rp/quarterly-report";
string html = await httpClient.GetStringAsync(targetUrl);

// Step 3: Render the fetched HTML, with the proxy for asset loading
var renderer = new ChromePdfRenderer();

PdfDocument pdf = renderer.RenderHtmlAsPdf(
    html,
    baseUrlOrPath: targetUrl,  // Resolves relative asset paths against the original URL
    proxy: "http://svc-account:P%40ssw0rd%21@proxy.co/rp.local:8080"
);
pdf.SaveAs("quarterly-report.pdf");

using IronPdf;
using System.Net;
using System.Net.Http;

// Step 1: Configure HttpClient with the corporate proxy
var proxy = new WebProxy("http://proxy.co/rp.local:8080")
{
    Credentials = new NetworkCredential("svc-account", "P@ssw0rd!")
};

var handler = new HttpClientHandler { Proxy = proxy, UseProxy = true };
using var httpClient = new HttpClient(handler);

// Step 2: Fetch the HTML from the target URL
string targetUrl = "https://dashboard.internal.co/rp/quarterly-report";
string html = await httpClient.GetStringAsync(targetUrl);

// Step 3: Render the fetched HTML, with the proxy for asset loading
var renderer = new ChromePdfRenderer();

PdfDocument pdf = renderer.RenderHtmlAsPdf(
    html,
    baseUrlOrPath: targetUrl,  // Resolves relative asset paths against the original URL
    proxy: "http://svc-account:P%40ssw0rd%21@proxy.co/rp.local:8080"
);
pdf.SaveAs("quarterly-report.pdf");

Imports IronPdf
Imports System.Net
Imports System.Net.Http

' Step 1: Configure HttpClient with the corporate proxy
Dim proxy As New WebProxy("http://proxy.co/rp.local:8080") With {
    .Credentials = New NetworkCredential("svc-account", "P@ssw0rd!")
}

Dim handler As New HttpClientHandler With {
    .Proxy = proxy,
    .UseProxy = True
}

Using httpClient As New HttpClient(handler)
    ' Step 2: Fetch the HTML from the target URL
    Dim targetUrl As String = "https://dashboard.internal.co/rp/quarterly-report"
    Dim html As String = Await httpClient.GetStringAsync(targetUrl)

    ' Step 3: Render the fetched HTML, with the proxy for asset loading
    Dim renderer As New ChromePdfRenderer()

    Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(
        html,
        baseUrlOrPath:=targetUrl,  ' Resolves relative asset paths against the original URL
        proxy:="http://svc-account:P%40ssw0rd%21@proxy.co/rp.local:8080"
    )
    pdf.SaveAs("quarterly-report.pdf")
End Using

Der Parameter baseUrlOrPath ist auf die ursprüngliche Ziel-URL gesetzt, damit relative Pfade im abgerufenen HTML (<img src="/images/logo.png">, <link href="/css/styles.css">) korrekt aufgelöst werden. Der Parameter proxy stellt sicher, dass diese Asset-Anfragen während des Renderings über den Proxy geleitet werden.

Dieses Muster funktioniert auch bei Seiten, die hinter einer Authentifizierung liegen – konfigurieren Sie HttpClient vor dem Abruf mit den entsprechenden Cookies oder Headern und übergeben Sie dann den authentifizierten HTML-Code an IronPDF. Die Anleitung zu HTTP-Request-Headern behandelt die Konfiguration von Headern für authentifizierte Anfragen.

Wenn die Seite für die Darstellung auf JavaScript angewiesen ist (SPAs, React-Dashboards, Angular-Apps), enthält der abgerufene HTML-Code nur die anfängliche Hülle – die clientseitige Darstellung wird während des Abrufs nicht ausgeführt. In diesen Fällen haben Sie zwei Möglichkeiten: Legen Sie Umgebungsvariablen auf Systemebene fest HTTPS_PROXY auf Systemebene festlegen (siehe nächster Abschnitt), damit RenderUrlAsPdf() auf Betriebssystemebene über den Proxy geleitet wird, oder einen Headless-Browser verwenden, um das vollständig gerenderte HTML abzurufen, bevor es an RenderHtmlAsPdf() übergeben wird.

Wie konfiguriert man einen Proxy in Docker-Containern?

In containerisierten Umgebungen ziehen Sie möglicherweise eine Proxy-Konfiguration auf Systemebene den Parametern pro Methode vor. Die Chromium-Engine von IronPDF berücksichtigt die Standard-Umgebungsvariablen HTTP_PROXY und HTTPS_PROXY, die Linux-Container für das Routing des ausgehenden Datenverkehrs verwenden.

Legen Sie diese in Ihrer Dockerfile fest:

FROM mcr.microsoft.com/dotnet/aspnet:8.0

# System-level proxy for all outbound HTTP/HTTPS traffic
ENV HTTP_PROXY=http://proxy.co/rp.local:8080
ENV HTTPS_PROXY=http://proxy.co/rp.local:8080
ENV NO_PROXY=localhost,127.0.0.1,.internal.co/rp

# Install IronPDF dependencies (fonts, etc.)
RUN apt-get update && apt-get install -y \
    libgdiplus \
    libc6-dev \
    fonts-liberation \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /app
COPY --from=build /app/publish .
ENTRYPOINT ["dotnet", "MyApp.dll"]

Wenn diese Umgebungsvariablen gesetzt sind, können Sie RenderHtmlAsPdf ohne den Proxy-Parameter aufrufen – Chromium übernimmt die Konfiguration auf Systemebene automatisch:

// No proxy parameter needed — Chromium uses HTTP_PROXY env var
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(htmlContent);

// No proxy parameter needed — Chromium uses HTTP_PROXY env var
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(htmlContent);

' No proxy parameter needed — Chromium uses HTTP_PROXY env var
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)

RenderHtmlAsPdf() ist für interne Ressourcen wichtig. Ohne diese Funktion würden Anfragen an interne Dienste (wie einen lokalen CSS-Server oder ein Bild-CDN, das in Ihrem Kubernetes-Cluster läuft) unnötigerweise über den Proxy geleitet werden. Trennen Sie die Hostnamen und Domains, die den Proxy umgehen sollen, durch Kommas.

Wenn Sie sowohl einen Proxy auf Systemebene für den allgemeinen Datenverkehr als auch einen separaten Proxy für bestimmte Renderings benötigen, hat der Methodenparameter Vorrang vor der Variablen der Umgebung. Dies gibt Ihnen bei Bedarf Kontrolle über die Darstellung.

Wie gehen Sie mit Proxys in CI/CD-Pipelines um?

CI/CD-Runner in Unternehmensnetzwerken befinden sich häufig hinter Proxys. Übergeben Sie die Proxy-URL als Build-Variable oder Secret – hinterlegen Sie Anmeldedaten niemals fest in der Quellcodeverwaltung.

GitHub Actions:

jobs:
  generate-pdf:
    runs-on: ubuntu-latest
    env:
      HTTP_PROXY: ${{secrets.CORP_PROXY_URL}}
      HTTPS_PROXY: ${{secrets.CORP_PROXY_URL}}
    steps:
      - uses: actions/checkout@v4
      - run: dotnet build
      - run: dotnet test

jobs:
  generate-pdf:
    runs-on: ubuntu-latest
    env:
      HTTP_PROXY: ${{secrets.CORP_PROXY_URL}}
      HTTPS_PROXY: ${{secrets.CORP_PROXY_URL}}
    steps:
      - uses: actions/checkout@v4
      - run: dotnet build
      - run: dotnet test

Azure DevOps:

variables:
  - group: proxy-settings  # Contains PROXY_URL secret

steps:
  - script: |
      export HTTP_PROXY=$(PROXY_URL)
      export HTTPS_PROXY=$(PROXY_URL)
      dotnet run --project PdfGenerator
    displayName: 'Generate PDFs behind proxy'

variables:
  - group: proxy-settings  # Contains PROXY_URL secret

steps:
  - script: |
      export HTTP_PROXY=$(PROXY_URL)
      export HTTPS_PROXY=$(PROXY_URL)
      dotnet run --project PdfGenerator
    displayName: 'Generate PDFs behind proxy'

Jenkins (Deklarative Pipeline):

environment {
    HTTP_PROXY  = credentials('corp-proxy-url')
    HTTPS_PROXY = credentials('corp-proxy-url')
}

In allen drei Fällen liest Chromium die Variablen der Umgebung automatisch aus. Wenn Sie eine explizite Steuerung bevorzugen, lesen Sie die Proxy-URL aus der Umgebung aus und übergeben Sie sie als Methodenparameter:

string? proxy = Environment.GetEnvironmentVariable("HTTPS_PROXY");
var pdf = renderer.RenderHtmlAsPdf(html, baseUrlOrPath: null, proxy: proxy);

string? proxy = Environment.GetEnvironmentVariable("HTTPS_PROXY");
var pdf = renderer.RenderHtmlAsPdf(html, baseUrlOrPath: null, proxy: proxy);

Option Strict On



Dim proxy As String = Environment.GetEnvironmentVariable("HTTPS_PROXY")
Dim pdf = renderer.RenderHtmlAsPdf(html, baseUrlOrPath:=Nothing, proxy:=proxy)

Wie behebt man Probleme mit dem Proxy?

Timeout-Fehler: Unternehmensproxys verursachen Latenz. Erhöhen Sie das Render-Timeout von der Standardeinstellung von 60 Sekunden:

renderer.RenderingOptions.Timeout = 120; // seconds

renderer.RenderingOptions.Timeout = 120; // seconds

renderer.RenderingOptions.Timeout = 120 ' seconds

Dies ist die Eigenschaft RenderTimeout – sie steuert, wie lange Chromium insgesamt auf das Laden der Seite und das Abrufen von Ressourcen wartet. Wenn Ihr Proxy pro Anfrage eine Latenz von 5–10 Sekunden verursacht und die Seite mehr als 20 externe Ressourcen lädt, reichen 60 Sekunden möglicherweise nicht aus.

SSL-Abfang (MITM-Proxys): Viele Unternehmensproxys entschlüsseln und verschlüsseln HTTPS-Datenverkehr neu unter Verwendung eines unternehmensinternen Root-CA-Zertifikats. Chromium lehnt diese Verbindungen ab, da es der Unternehmens-Zertifizierungsstelle standardmäßig nicht vertraut. Zwei Lösungen:

1. Installieren Sie das Unternehmens-CA-Zertifikat im vertrauenswürdigen Stammzertifikatspeicher des Containers oder Hosts. Unter Linux: Kopieren Sie .crt nach /usr/local/share/ca-certificates/ und führen Sie update-ca-certificates aus.
2. Nur in der Entwicklungsumgebung können Sie die Zertifikatsvalidierung deaktivieren – tun Sie dies jedoch niemals in der Produktionsumgebung. Der sicherere Ansatz ist immer die Installation des richtigen Zertifikats.

NTLM-Authentifizierung: Das Inline-Format user:pass@host unterstützt die Basic- und Digest-Proxy-Authentifizierung. NTLM (üblich in Windows-orientierten Enterprise-Unternehmen) wird über die Proxy-URL-Zeichenkette nicht unterstützt. Die Abhilfe besteht darin, einen lokalen NTLM-zu-Basic-Weiterleitungs-Proxy wie CNTLM auf dem Host oder als Sidecar-Container auszuführen. Konfigurieren Sie CNTLM mit Ihren NTLM-Anmeldedaten und verweisen Sie IronPDF dann auf http://localhost:3128 (den Standardport von CNTLM).

Leeres PDF oder fehlende Assets: Wenn das PDF zwar angezeigt wird, aber Bilder/CSS fehlen, verweist Ihr HTML-Code auf Ressourcen, die vom Proxy blockiert werden oder einen anderen Proxy-Pfad erfordern. Stellen Sie sicher, dass der Parameter baseUrlOrPath korrekt über den Proxy aufgelöst wird, und überprüfen Sie die Zugriffsprotokolle des Proxys auf 403- oder 407-Antworten.

Proxy-Umgehung für lokale Assets: Wenn Ihr HTML-Code sowohl auf lokale Assets (gebündelte Bilder, Inline-CSS) als auch auf Remote-Ressourcen (CDN-Schriftarten, externe Skripte) verweist, muss der Proxy nur die Remote-Anfragen bearbeiten. Setzen Sie baseUrlOrPath auf ein lokales Verzeichnis für Dateisystem-Assets und lassen Sie den Proxy nur die Netzwerkanfragen bearbeiten. Dadurch wird vermieden, dass das Lesen lokaler Dateien unnötigerweise über den Proxy geleitet wird.

Überprüfung der Verbindung: Um sicherzustellen, dass Ihre Proxy-Zeichenfolge korrekt ist, bevor Sie sie mit IronPDF verwenden, testen Sie sie zunächst mit einer einfachen HttpClient-Anfrage:

var proxy = new WebProxy("http://proxy.co/rp.local:8080");
var handler = new HttpClientHandler { Proxy = proxy, UseProxy = true };
using var client = new HttpClient(handler);

var response = await client.GetAsync("https://httpbin.org/ip");
Console.WriteLine(await response.Co/ntent.ReadAsStringAsync());
// Should return the proxy's external IP, not your machine's IP

var proxy = new WebProxy("http://proxy.co/rp.local:8080");
var handler = new HttpClientHandler { Proxy = proxy, UseProxy = true };
using var client = new HttpClient(handler);

var response = await client.GetAsync("https://httpbin.org/ip");
Console.WriteLine(await response.Co/ntent.ReadAsStringAsync());
// Should return the proxy's external IP, not your machine's IP

Imports System.Net.Http
Imports System.Net

Dim proxy As New WebProxy("http://proxy.co/rp.local:8080")
Dim handler As New HttpClientHandler With {.Proxy = proxy, .UseProxy = True}
Using client As New HttpClient(handler)
    Dim response = Await client.GetAsync("https://httpbin.org/ip")
    Console.WriteLine(Await response.Content.ReadAsStringAsync())
    ' Should return the proxy's external IP, not your machine's IP
End Using

Wenn dies gelingt, IronPDF aber immer noch fehlschlägt, liegt das Problem wahrscheinlich an einer SSL-Abfangung oder einer Protokollinkompatibilität zwischen Ihrem Proxy und dem CONNECT-Tunneling von Chromium. Überprüfen Sie, ob der Proxy HTTP CONNECT für HTTPS-Ressourcen unterstützt – einige Proxys erfordern eine explizite Konfiguration, um Tunneling zu ermöglichen.

Nächste Schritte