Cómo configurar servidores proxy para la representación de PDF en C

Flujo de trabajo mínimo (3 pasos)

1. Instale IronPDF a través de NuGet: Install-Package IronPdf
2. Pase la cadena de proxy como el tercer parámetro a RenderHtmlAsPdf()
3. Formato: http(s)://host:port o http(s)://user:pass@host:port para proxies autenticados

¿Cómo se pasa un proxy a RenderHtmlAsPdf?

El parámetro Proxy es un string opcional en cuatro firmas de método:

// 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

Cuando este parámetro es null (el predeterminado), el motor Chromium de IronPDF se conecta directamente a recursos externos: hojas de estilo, imágenes, fuentes y archivos JavaScript referenciados en su HTML. Cuando proporcionas una cadena de proxy, todas las solicitudes HTTP/HTTPS del motor de representación se enrutan a través de ese proxy.

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.corp.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.corp.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.corp.local:8443"
)

La cadena de proxy es compatible con los esquemas http:// y https://. Use https:// cuando el propio proxy requiera cifrado TLS para la conexión entre su aplicación y el servidor proxy. El esquema aquí se refiere a la conexión proxy, no al recurso final: un proxy http:// todavía puede obtener recursos https:// a través de túneles CONNECT.

Las variantes de método estático aceptan el mismo parámetro de proxy, lo cual es útil para renderizaciones únicas en aplicaciones de consola o pruebas unitarias:

// Static render with proxy — no renderer instance needed
var pdf = ChromePdfRenderer.StaticRenderHtmlAsPdf(
    "<h1>Static render through proxy</h1>",
    options: null,
    proxy: "http://proxy.corp.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.corp.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.corp.local:8080"
)

Importante: No existe una propiedad ProxyAddress en ChromePdfRenderOptions. No la busque allí. El proxy es estrictamente un parámetro de método en las sobrecargas de RenderHtmlAsPdf y StaticRenderHtmlAsPdf.

¿Cómo autenticarse con un proxy corporativo?

La mayoría de los proxies empresariales requieren credenciales. Insértelas directamente en la URL del proxy usando el formato http(s)://username:password@host:port:

using IronPdf;

var renderer = new ChromePdfRenderer();

string proxyWithAuth = "http://svc-account:P%40ssw0rd%21@proxy.corp.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.corp.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.corp.local:8080"

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

Codifique en URL los caracteres especiales en las contraseñas. Si su contraseña contiene @, #, :, /, u otros caracteres reservados de URI, deben ir codificados por porcentaje. Codificaciones comunes:

Use Uri.EscapeDataString() para codificar la contraseña programáticamente:

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

string rawPassword = "P@ssw0rd!";
string encoded = Uri.EscapeDataString(rawPassword); // "P%40ssw0rd%21"
string proxy = $"http://svc-account:{encoded}@proxy.corp.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.corp.local:8080"

No confundas la autenticación del proxy con la autenticación de la página web. Las propiedades ChromeHttpLoginCredentials.NetworkUsername y NetworkPassword autentican contra la página web que se está representando (NTLM/Negotiate con un sitio web), no contra un servidor proxy. Para la autenticación del proxy, las credenciales van en la cadena de URL del proxy como se muestra arriba.

¿Cómo representar URLs detrás de un proxy?

RenderUrlAsPdf() no acepta un parámetro de proxy. Esto es una elección deliberada de diseño de API — RenderUrlAsPdf navega Chromium a una URL, y la configuración del proxy para esa navegación se maneja de manera diferente que para la carga de recursos durante la representación de HTML.

El método alternativo recomendado: obtenga el HTML usted mismo usando HttpClient configurado con un WebProxy, luego pase la cadena HTML a RenderHtmlAsPdf() con el parámetro de proxy (para que los activos referenciados — imágenes, CSS, fuentes — también se enruten a través del proxy).

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

// Step 1: Configure HttpClient with the corporate proxy
var proxy = new WebProxy("http://proxy.corp.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.corp/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.corp.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.corp.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.corp/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.corp.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.corp.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.corp/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.corp.local:8080"
    )
    pdf.SaveAs("quarterly-report.pdf")
End Using

El parámetro baseUrlOrPath se establece en la URL de destino original para que las rutas relativas en el HTML obtenido ( <img src="/images/logo.png">, <link href="/css/styles.css">) se resuelvan correctamente. El parámetro proxy asegura que esas solicitudes de activos se enruten a través del proxy durante la representación.

Este patrón también funciona con páginas detrás de autenticación — configura el HttpClient con las cookies o encabezados apropiados antes de obtener, y luego pasa el HTML autenticado a IronPDF. El cómo para el encabezado de solicitud HTTP cubre la configuración de encabezados para solicitudes autenticadas.

Si la página depende de JavaScript para la representación (SPA, paneles React, aplicaciones Angular), el HTML obtenido solo contendrá la estructura inicial — la representación del lado del cliente no se ejecutará durante la obtención HttpClient. Para esos casos, tiene dos opciones: establezca variables de entorno HTTPS_PROXY a nivel de sistema (cubiertas en la próxima sección) para que RenderUrlAsPdf() se enrute a través del proxy a nivel del sistema operativo, o usa un navegador sin cabeza para obtener el HTML completamente renderizado antes de pasarlo a RenderHtmlAsPdf().

¿Cómo configurar un proxy en contenedores Docker?

En entornos containerizados, puede preferir la configuración de proxy a nivel de sistema sobre los parámetros por método. El motor Chromium de IronPDF respeta las variables de entorno estándar HTTP_PROXY y HTTPS_PROXY que los contenedores Linux usan para el enrutamiento del tráfico saliente.

Establezca estos en su Dockerfile:

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

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

# 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"]

Con estas variables de entorno configuradas, puedes llamar a RenderHtmlAsPdf() sin el parámetro de proxy — Chromium recoge la configuración a nivel de sistema automáticamente:

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

NO_PROXY es importante para los recursos internos. Sin él, las solicitudes a servicios internos (como un servidor CSS local o un CDN de imágenes en ejecución dentro de su clúster de Kubernetes) se enrutarían innecesariamente a través del proxy. Separa con comas los nombres de host y dominios que deberían omitir el proxy.

Si necesita tanto un proxy a nivel de sistema para el tráfico general como un proxy diferente para renderizaciones específicas, el parámetro de método tiene precedencia sobre la variable de entorno. Esto le da control por renderización cuando sea necesario.

Para implementaciones en Kubernetes, inyecta la configuración de proxy a través de ConfigMaps o variables de entorno en la especificación del pod en lugar de codificarlas en el Dockerfile. Esto permite que la misma imagen de contenedor funcione en diversos entornos con diferentes configuraciones de proxy:

# Kubernetes pod spec
spec:
  containers:
    - name: pdf-generator
      image: myregistry/pdf-service:latest
      env:
        - name: HTTP_PROXY
          valueFrom:
            configMapKeyRef:
              name: proxy-config
              key: http-proxy
        - name: HTTPS_PROXY
          valueFrom:
            configMapKeyRef:
              name: proxy-config
              key: https-proxy
        - name: NO_PROXY
          value: "localhost,127.0.0.1,.internal.corp"

# Kubernetes pod spec
spec:
  containers:
    - name: pdf-generator
      image: myregistry/pdf-service:latest
      env:
        - name: HTTP_PROXY
          valueFrom:
            configMapKeyRef:
              name: proxy-config
              key: http-proxy
        - name: HTTPS_PROXY
          valueFrom:
            configMapKeyRef:
              name: proxy-config
              key: https-proxy
        - name: NO_PROXY
          value: "localhost,127.0.0.1,.internal.corp"

Cuando tanto la variable de entorno como el parámetro de método están presentes, el parámetro de método tiene precedencia. Esto le proporciona un modelo de configuración por capas: establezca el proxy predeterminado a nivel de infraestructura y anúlelo por renderización cuando solicitudes específicas necesiten una ruta diferente.

¿Cómo manejar un proxy en tuberías CI/CD?

Los corredores CI/CD en redes corporativas frecuentemente se encuentran detrás de proxies. Pase la URL del proxy como una variable de construcción o secreto — nunca codifique credenciales en el control de código fuente.

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 (Pipeline Declarativo):

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

En los tres casos, Chromium lee automáticamente las variables de entorno. Si prefiere un control explícito, lea la URL del proxy del entorno y pásela como el parámetro de método:

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)

¿Cómo solucionar problemas de proxy?

Errores de tiempo de espera: Los proxies corporativos añaden latencia. Aumente el tiempo de espera de renderización desde el predeterminado de 60 segundos:

renderer.RenderingOptions.Timeout = 120; // seconds

renderer.RenderingOptions.Timeout = 120; // seconds

renderer.RenderingOptions.Timeout = 120 ' seconds

Esta es la propiedad de ChromePdfRenderOptions.Timeout — controla cuánto tiempo espera Chromium para la carga de página y la obtención de recursos combinadas. Si tu proxy añade 5 a 10 segundos de latencia por solicitud, y la página carga más de 20 recursos externos, 60 segundos podrían no ser suficientes.

Intercepción SSL (proxies MITM): Muchos proxies corporativos descifran y vuelven a cifrar el tráfico HTTPS usando un certificado CA raíz corporativo. Chromium rechaza estas conexiones porque no confía en la CA corporativa por defecto. Dos soluciones:

1. Instala el certificado CA corporativo en la tienda raíz de confianza del contenedor o del host. En Linux: copia el .crt a /usr/local/share/ca-certificates/ y ejecuta update-ca-certificates.
2. Solo en desarrollo, puedes desactivar la validación de certificados — pero nunca hagas esto en producción. El enfoque más seguro es siempre instalar el certificado adecuado.

Autenticación NTLM: El formato incrustado user:pass@host admite autenticación básica y digest en proxy. NTLM (común en empresas centradas en Windows) no es compatible a través de la cadena de URL del proxy. El método alternativo es ejecutar un proxy de reenvío local NTLM-a-Básico como CNTLM en el host o como un contenedor acompañante. Configura CNTLM con tus credenciales NTLM, luego apunta IronPDF a http://localhost:3128 (el puerto predeterminado de CNTLM).

PDF en blanco o activos perdidos: Si el PDF se representa pero faltan imágenes/CSS, tu HTML hace referencia a recursos que el proxy bloquea o que requieren una ruta de proxy diferente. Verifica que el parámetro baseUrlOrPath se resuelva correctamente a través del proxy, y revisa los registros de acceso del proxy para respuestas 403 o 407.

Exclusión de proxy para activos locales: Si tu HTML hace referencia a una mezcla de activos locales (imágenes empaquetadas, CSS en línea) y recursos remotos (fuentes CDN, scripts externos), el proxy solo necesita manejar las solicitudes remotas. Establece baseUrlOrPath en un directorio local para los activos del sistema de archivos, y deja que el proxy maneje solo las solicitudes de red. Esto evita enrutar lecturas de archivos locales a través del proxy innecesariamente.

Diagnóstico de conectividad: Para verificar que su cadena de proxy sea correcta antes de usarla con IronPDF, pruébela con una simple solicitud HttpClient primero:

var proxy = new WebProxy("http://proxy.corp.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.Content.ReadAsStringAsync());
// Should return the proxy's external IP, not your machine's IP

var proxy = new WebProxy("http://proxy.corp.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.Content.ReadAsStringAsync());
// Should return the proxy's external IP, not your machine's IP

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

Dim proxy As New WebProxy("http://proxy.corp.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

Si esto tiene éxito pero IronPDF aún falla, es probable que el problema sea la interceptación SSL o un desajuste de protocolo entre tu proxy y el túnel CONNECT de Chromium. Verifique si el proxy admite CONNECT HTTP para recursos HTTPS — algunos proxies requieren configuración explícita para permitir el túnel.

Próximos pasos

El soporte de proxy en IronPDF es un parámetro de método en RenderHtmlAsPdf() — pase la cadena de proxy, y el motor de Chromium enruta todo el tráfico HTTP a través de él. Para los escenarios RenderUrlAsPdf(), obtenga el HTML con HttpClient y un WebProxy primero. Para contenedores y CI/CD, las variables de entorno HTTPS_PROXY a nivel de sistema le brindan control a nivel de infraestructura sin cambios de código.

Explora la guía de inicios de sesión y autenticación para la autenticación de páginas web (distinta de la autenticación del proxy), la guía de encabezados de solicitud HTTP para encabezados personalizados, y la referencia de opciones de renderización para la afinación de tiempos de espera y rendimiento.

Ver opciones de licencia desde $749. La referencia API de ChromePdfRenderer documenta cada sobrecarga de método y la referencia de ChromePdfRenderOptions cubre todas las propiedades configurables.