HTML a PDF NodeJS

Darrius Serrant
Darrius Serrant
28 de diciembre, 2022
Actualizado 16 de enero, 2025
Compartir:
This article was translated from English: Does it need improvement?
Translated
View the article in English

La capacidad de crear PDF de alta fidelidad a partir de HTML, CSS y JavaScript sin procesar es la función más potente y popular de IronPDF. Este tutorial es un manual completo para ayudar a los desarrolladores de Node a aprovechar IronPDF para incorporar la generación de HTML a PDF en sus propios proyectos._

_IronPDF es una biblioteca API de alto nivel que ayuda a los desarrolladores a implementar potentes y sólidas funciones de procesamiento de PDF en aplicaciones de software de forma rápida y sencilla. IronPDF está disponible en múltiples lenguajes de programación. Para obtener una cobertura detallada sobre cómo crear PDFs en .NET, Java y Python, consulte las páginas oficiales de documentación. Este tutorial cubre su uso en proyectos Node.js.



Primeros pasos

Comience a usar IronPDF en su proyecto hoy con una prueba gratuita.

Primer Paso:
green arrow pointer

Instalar la biblioteca IronPDF for Node.js

Instale el paquete IronPDF Node.js ejecutando el comando NPM que se indica a continuación en el proyecto Node que haya elegido:

npm install @ironsoftware/ironpdf

También puedes descargar e instalar el paquete de IronPDF manualmente.

Instalación manual del motor IronPDF (opcional)

IronPDF for Node.js actualmente requiere un binario del IronPDF Engine para funcionar correctamente.

Instale el binario de IronPDF Engine instalando el paquete adecuado para su sistema operativo:

Atención
Instalar el motor de IronPDF es opcional, ya que @ironpdf descargará e instalará automáticamente el binario adecuado para su navegador y sistema operativo desde NPM en su primera ejecución. Sin embargo, instalar este binario explícitamente será vital en situaciones donde el acceso a internet sea limitado, reducido o no deseado.

Aplicar una clave de licencia (opcional)

Por defecto, IronPDF marcará todos los documentos que genere o modifique con una marca de agua de fondo titulada.

Figura 1

Obtenga una clave de licencia en ironpdf.com/nodejs/licensing/ para generar documentos PDF sin marcas de agua.

Para usar IronPDF sin la marca de agua adicional, debes establecer la propiedad licenseKey en el objeto global IronPdfGlobalconfig con una clave de licencia válida. A continuación se muestra el código fuente para conseguirlo:

import {IronPdfGlobalConfig} from "@ironsoftware/ironpdf";

var config = IronPdfGlobalConfig.getConfig();
config.licenseKey = "{YOUR-LICENSE-KEY-HERE}";
NODE.JS

Compre una clave de licencia desde nuestra página de licencias, o contáctenos para obtener una clave de licencia de prueba gratuita.

[{i:(La clave de licencia y otras configuraciones globales, deben establecerse antes de utilizar otras funciones de la biblioteca para garantizar el mejor rendimiento y la funcionalidad adecuada.

Las secciones siguientes de este tutorial asumirán que tenemos una clave de licencia y que la hemos establecido en un archivo JavaScript separado llamado config.js. Importamos este script siempre que vayamos a hacer uso de la funcionalidad de IronPDF:

import {PdfDocument} from "@ironsoftware/ironpdf";
import('./config.js');
// ...
NODE.JS

Convertir HTML a PDF

La versión Node de la librería IronPDF ofrece tres enfoques para crear archivos PDF a partir de contenido HTML:

  1. A partir de una cadena de código HTML

  2. Desde un archivo HTML local

  3. En un sitio web

    En esta sección se explican detalladamente los tres métodos.

Crear un archivo PDF a partir de una cadena HTML

PdfDocument.fromHtml es un método que te permite generar PDFs a partir de cadenas de marcado de páginas web en bruto.

Este método es el más flexible de los tres. Esto se debe a que los datos de la cadena HTML pueden proceder prácticamente de cualquier lugar: archivos de texto, flujos de datos, una plantilla HTML, datos HTML generados, etc.

El siguiente ejemplo de código demuestra cómo utilizar el método PdfDocument.fromHtml en la práctica:

import {PdfDocument} from "@ironsoftware/ironpdf";
import('./config.js');

// Create a PDF from the HTML String "Hello world!"
const pdf = await PdfDocument.fromHtml("<h1>Hello from IronPDF!</h1>");

// Save the PDF document to the file system.
await pdf.saveAs("html-string-to-pdf.pdf");
NODE.JS

Como se muestra arriba, llamamos al método PdfDocument.fromHtml con una cadena de texto que contiene el código de marcado para un elemento de encabezado de nivel uno.

PdfDocument.fromHtml devuelve una Promesa que resuelve a una instancia de la clase PdfDocument. Un PdfDocument representa un archivo PDF que la biblioteca ha producido a partir de algún contenido fuente. Esta clase constituye la piedra angular de la mayoría de las funciones principales de IronPDF, impulsando importantes casos de uso de creación y edición de PDF.

Finalmente, usamos el método saveAs en el PdfDocument para guardar el archivo en el disco. A continuación se muestra el archivo PDF guardado.

Figura 2

El PDF generado a partir de la cadena HTML "<h1>Hello from IronPDF!</h1>". Los archivos PDF que genera PdfDocument.fromHtml aparecen tal como aparecería el contenido de una página web.**

Crear un archivo PDF a partir de un archivo HTML

PdfDocument.fromHtml no solo funciona con cadenas de HTML. El método también acepta una ruta a un documento HTML local.

En nuestro próximo ejemplo, trabajaremos con esta página web de muestra.

Figura 3

Our sample HTML page as it appears in Google Chrome. Descarga esta página y otras similares del sitio web de File Samples: https://filesamples.com/samples/code/html/sample2.html

Las siguientes líneas de código convierten todo el documento de muestra en un PDF. En lugar de una cadena HTML, llamamos a PdfDocument.fromHtml con una ruta de archivo válida a nuestro archivo de muestra:

import {PdfDocument} from "@websiteironsoftware/ironpdf";
import('./config.js');

// Render a PDF from an HTML File
const pdf = await PdfDocument.fromHtml("./sample2.html");

// Save the PDF document to the same folder as our project.
await pdf.saveAs("html-file-to-pdf-1.pdf");
NODE.JS

A continuación incluimos el contenido del PDF resultante. Observe que IronPDF no sólo conserva la apariencia del documento HTML original, sino también la funcionalidad de los enlaces, formularios y otros elementos interactivos comunes.

Figura 4

Este PDF se generó a partir del ejemplo de código anterior. ¡Compare su apariencia con la imagen anterior y note la notable semejanza!

Si ha examinado el código fuente de la página de muestra, observará que es más complejo. Utiliza más tipos de elementos HTML (párrafos, listas desordenadas, saltos de línea, reglas horizontales, hipervínculos, imágenes, etc.) y también incluye una cierta cantidad de scripts (utilizados para configurar cookies).

IronPDF es capaz de renderizar contenidos web mucho más complejos que los que hemos estado utilizando hasta ahora. Para demostrarlo, veamos la siguiente página:

Figura 5

Un artículo escrito sobre Puppeteer, una biblioteca de Node popularizada por su capacidad para controlar Chrome programáticamente utilizando una instancia de navegador sin cabeza

La página representada arriba es de un artículo escrito sobre la biblioteca Puppeteer Node. Puppeteer ejecuta sesiones de navegador sin cabeza que los desarrolladores de Node utilizan para automatizar numerosas tareas de navegador en el lado del servidor o en el lado del cliente (una de las cuales incluye la generación de PDF HTML del lado del servidor).

La nueva página utiliza numerosos recursos (archivos CSS, imágenes, archivos de script, etc.) y emplea un diseño aún más complejo. Para este siguiente ejemplo, convertiremos una copia guardada de esta página (junto con sus recursos de origen) en un PDF de precisión píxel a píxel.

El siguiente fragmento de código asume que la página se guarda en el mismo directorio que nuestro proyecto como "sample4.html":

// Render a from even more complex HTML code.
PdfDocument.fromHtml("./sample4.html").then((pdf) async {
    return await pdf.saveAs("html-file-to-pdf-2.pdf");
});
NODE.JS

La siguiente imagen muestra los resultados del fragmento de código anterior.

Figura 6

**Si se ve bien en Google Chrome, entonces se verá bien cuando se convierta en un PDF. Esto incluye diseños de página con mucho CSS y JavaScript.

Crear un archivo PDF a partir de una URL

IronPDF puede convertir cadenas HTML y archivos HTML de cualquier tamaño y complejidad. Sin embargo, no está limitado al uso de marcas sin procesar de cadenas y archivos. IronPDF también puede solicitar HTML desde una URL.

Considere el artículo de Wikipedia ubicado en https://en.wikipedia.org/wiki/PDF.

Figura 7

El artículo de Wikipedia sobre el formato PDF, tal como aparece en un navegador web compatible con los estándares.

Utiliza este código fuente para convertir este artículo de Wikipedia en un PDF:

import {PdfDocument} from "@ironsoftware/ironpdf";
import('./config.js');

// Convert the Web Page to a pixel-perfect PDF file.
const pdf = await PdfDocument.fromUrl("https://en.wikipedia.org/wiki/PDF");

// Save the document.
await pdf.saveAs("url-to-pdf.pdf");
NODE.JS

Arriba, usamos PdfDocument.fromUrl para convertir la página web en un PDF en unas pocas líneas de código. IronPDF obtendrá el código HTML de la dirección web por usted y lo renderizará sin problemas. ¡No se requieren archivos HTML ni cadenas de texto!

Figura 8

El PDF generado al llamar a PdfDocument.fromUrl en un artículo de Wikipedia. Observe sus similitudes con la página web original.**

Crear un archivo PDF a partir de un archivo Zip

Utilice PdfDocument.fromZip para convertir un archivo HTML específico ubicado en un archivo comprimido (zip) en un PDF.

Por ejemplo, supongamos que tenemos un archivo Zip en el directorio del proyecto con la siguiente estructura interna:

html-zip.zip
├─ index.html
├─ style.css
├─ logo.png

El archivo index.html contiene el código:

<!DOCTYPE html>

<html lang="en">
  <head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Hello world!</title>
    <link rel="stylesheet" href="style.css">
  </head>
  <body>
    <h1>Hello from IronPDF!</h1>
    <a href="https://ironpdf.com/nodejs/">
      <img src="logo.png" alt="IronPDF for Node.js">
    </a>
  </body>
</html>
<!DOCTYPE html>

<html lang="en">
  <head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Hello world!</title>
    <link rel="stylesheet" href="style.css">
  </head>
  <body>
    <h1>Hello from IronPDF!</h1>
    <a href="https://ironpdf.com/nodejs/">
      <img src="logo.png" alt="IronPDF for Node.js">
    </a>
  </body>
</html>
HTML

style.css declara cinco reglas CSS:

@font-face {
font-family: 'Gotham-Black';
src: url('gotham-black-webfont.eot?') format('embedded-opentype'), url('gotham-black-webfont.woff2') format('woff2'), url('gotham-black-webfont.woff') format('woff'), url('gotham-black-webfont.ttf') format('truetype'), url('gotham-black-webfont.svg') format('svg');
font-weight: normal;
font-style: normal;
font-display: swap;
}

body {
    display: flex;
    flex-direction: column;
    justify-content: center;
    margin-left: auto;
    margin-right: auto;
    margin-top: 200px;
    margin-bottom: auto;
    color: white;
    background-color: black;
    text-align: center;
    font-family: "Helvetica"
}

h1 {
    font-family: "Gotham-Black";
    margin-bottom: 70px;
    font-size: 32pt;
}

img {
    width: 400px;
    height: auto;
}

p {
    text-decoration: underline;
    font-size: smaller;
}

Por último, logo.png representa el logotipo de nuestro producto:

Figura 9

La imagen de muestra dentro de un archivo zip HTML hipotético.

Al llamar al método fromZip, especifique una ruta válida al archivo zip en el primer argumento, junto con un objeto JSON que establezca la propiedad mainHtmlFile con el nombre del archivo HTML del zip que queremos convertir.

Convertimos el archivo index.html dentro de la carpeta zip de la misma manera:

import {PdfDocument} from "@ironsoftware/ironpdf";
import('./config.js');

// Render the HTML string
PdfDocument.fromZip("./html-zip.zip", {
    mainHtmlFile: "index.html"
}).then(async (pdf) => {
    return await pdf.saveAs("html-zip-to-pdf.pdf");
});
JAVASCRIPT

Figura 10

Creación de PDF utilizando la función PdfDocument.fromZip. Esta función renderiza con éxito el código HTML contenido en el archivo ZIP, con sus activos contenidos.

Opciones avanzadas de generación de HTML a PDF

La interfaz ChromePdfRenderOptions permite a los desarrolladores de Node modificar el comportamiento de renderizado HTML de la biblioteca. Las propiedades allí expuestas permiten una personalización granular de la apariencia de los PDF antes de su renderización. Además, permiten tratar casos extremos específicos de conversión HTML-PDF.

IronPDF genera nuevos PDFs inicialmente utilizando algunos valores predeterminados de ChromePdfRenderOptions. Puedes consultar estos valores preestablecidos por ti mismo llamando a la función defaultChromePdfRenderOptions:

// Retrieve a ChromePdfRenderOptions object with default settings.
var options = defaultChromePdfRenderOptions();
NODE.JS

Esta sección repasará rápidamente los casos de uso más populares de renderizado de HTML a PDF que requieren el uso de la interfaz ChromePdfRenderOptions.

Cada subsección comenzará con los valores preestablecidos y los modificará según sea necesario para lograr el resultado deseado.

Personalizar la salida de generación de PDF

Añadir encabezados y pies de página personalizados

Con las propiedades textHeader y textFooter, puede añadir contenido de encabezado y/o pie de página personalizado a los PDFs recién renderizados.

El siguiente ejemplo crea una versión en PDF de la página de inicio de la búsqueda de Google con un encabezado y un pie de página personalizados a partir de contenido de texto. Utilizamos líneas divisorias para separar este contenido del cuerpo de la página. También utilizamos fuentes distintas en la cabecera y el pie de página para que las distinciones sean más claras.

import {PdfDocument, defaultChromePdfRenderOptions, AffixFonts} from "@ironsoftware/ironpdf";
import('./config.js');

var options = defaultChromePdfRenderOptions();

// Build a Custom Text-Based Header
options.textHeader = {
    centerText: "https://www.adobe.com",
    dividerLine: true,
    font: AffixFonts.CourierNew,
    fontSize: 12,
    leftText: "URL to PDF"
};

// Build a custom Text-Based Footer
options.textFooter = {
    centerText: "IronPDF for Node.js",
    dividerLine: true,
    fontSize: 14,
    font: AffixFonts.Helvetica,
    rightText: "HTML to PDF in Node.js"
};

// Render a PDF from an HTML File
PdfDocument.fromUrl("https://www.google.com/", {renderOptions: options}).then(async (pdf) => {
    return await pdf.saveAs("add-custom-headers-footers-1.pdf");
});
NODE.JS

El código fuente produce este PDF:

Figura 11

**Se creó una nueva página en formato PDF, generada desde la página principal de Google. Observe la inclusión de encabezados y pies de página adicionales.

Para controlar aún más el diseño, la posición y el contenido de la cabecera y el pie de página, también puede definirlos utilizando HTML sin formato en lugar de texto.

En el bloque de código siguiente, utilizamos HTML para incorporar contenido enriquecido en la cabecera y el pie de página. En la cabecera, ponemos en negrita y centramos la URL de la página; en el pie de página, incrustamos y centramos un logotipo.

import {PdfDocument, defaultChromePdfRenderOptions} from "@ironsoftware/ironpdf";
import('./config.js');

var options = defaultChromePdfRenderOptions();
options.htmlHeader = {
    htmlFragment: "<strong>https://www.google.com/</strong>",
    dividerLine: true,
    dividerLineColor: "blue",
    loadStylesAndCSSFromMainHtmlDocument: true,
};
options.htmlFooter = {
    htmlFragment: "<img src='logo.png' alt='IronPDF for Node.js' style='display: block; width: 150px; height: auto; margin-left: auto; margin-right: auto;'>",
    dividerLine: true,
    loadStylesAndCSSFromMainHtmlDocument: true
};

// Render a PDF from an HTML File
await PdfDocument.fromUrl("https://www.google.com/", {renderOptions: options}).then(async (pdf) => {
    return await pdf.saveAs("add-html-headers-footers.pdf");
});
NODE.JS

La imagen siguiente muestra el resultado de estos cambios.

Figura 12

IronPDF for Node.js puede aplicar personalizaciones a tus páginas HTML al convertirlas en PDFs.

Establecer márgenes, tamaños de página, orientación de página y color

IronPDF admite configuraciones adicionales para definir márgenes de página personalizados, tamaños de página y orientaciones de página para los PDF recién convertidos.

import {PdfDocument, defaultChromePdfRenderOptions, PaperSize, FitToPaperModes, PdfPaperOrientation} from "@ironsoftware/ironpdf";
import('./config.js');

var options = defaultChromePdfRenderOptions();

// Set top, left, right, and bottom page margins in millimeters. 
options.margin = {
    top: 50,
    bottom: 50,
    left: 60,
    right: 60
};
options.paperSize = PaperSize.A5;
options.fitToPaperMode = FitToPaperModes.FitToPage;
options.paperOrientation = PdfPaperOrientation.Landscape;
options.grayScale = true;

// Create a PDF from the Google.com Home Page
PdfDocument.fromUrl("https://www.google.com/", {renderOptions: options}).then(async (pdf) => {
    return await pdf.saveAs("set-margins-and-page-size.pdf");
});
NODE.JS

En el bloque de código anterior, configuramos IronPDF para generar nuestro PDF de la página de inicio de Google en escala de grises con orientación horizontal y con al menos 50 milímetros de espacio de margen. También ajustamos el contenido al tamaño de papel A5.

Generar PDF a partir de páginas web dinámicas

En el caso de las páginas web que contienen contenidos que no están disponibles inmediatamente y que no se renderizan al cargar la página, puede ser necesario pausar la renderización del contenido de esa página hasta que se cumplan determinadas condiciones.

Por ejemplo, el desarrollador puede querer generar un PDF con contenido que sólo aparezca 15 segundos después de que se cargue la página. En otro caso, puede que este mismo contenido sólo aparezca una vez que se ejecute algún código complejo del lado del cliente.

Para manejar ambos casos extremos (y muchos más), la versión de Node de IronPDF define el mecanismo WaitFor. Los desarrolladores pueden incluir esta propiedad en sus configuraciones de ChromePdfRenderOptions para instruir al motor de renderizado de Chrome de IronPDF a convertir el contenido de una página cuando ocurren ciertos eventos.

El siguiente bloque de código configura IronPDF para que espere a que transcurran 20 segundos antes de capturar el contenido de nuestra página de inicio como PDF:

import {PdfDocument, defaultChromePdfRenderOptions, WaitForType} from "@ironsoftware/ironpdf";
import('./config.js');

// Configure the Chrome Renderer to wait until 20 seconds has passed
// before rendering the web page as a PDF.
var options = defaultChromePdfRenderOptions();
options.waitFor = {
    type: WaitForType.RenderDelay,
    delay: 20000
}
PdfDocument.fromUrl("https://ironpdf.com/nodejs/", {renderOptions: options}).then(async (pdf) => {
    return await pdf.saveAs("waitfor-renderdelay.pdf");
});
NODE.JS

El siguiente bloque de código configura IronPDF para esperar hasta que un elemento en un editor de texto SEO popular pueda ser seleccionado con éxito.

import {PdfDocument, defaultChromePdfRenderOptions, WaitForType} from "@ironsoftware/ironpdf";
import('./config.js');

// Configure the Chrome Renderer to wait up to 20 seconds for a specific element to appear
options.waitFor = {
    type: WaitForType.HtmlElement,
    htmlQueryStr: "div.ProseMirror",
    maxWaitTime: 20000,
}
PdfDocument.fromUrl("https://app.surferseo.com/drafts/s/V7VkcdfgFz-dpkldsfHDGFFYf4jjSvvjsdf", {renderOptions: options}).then(async (pdf) => {
    return await pdf.saveAs("waitfor-htmlelement.pdf");
});
NODE.JS

Generar PDF a partir de una plantilla HTML

En la sección final de este tutorial, aplicaremos todos los conocimientos introducidos en las secciones anteriores para realizar una automatización muy práctica: generar uno o varios PDF utilizando una plantilla HTML.

La plantilla que utilizaremos para esta sección se muestra a continuación. Se adaptó de esta plantilla de factura de acceso público para incluir etiquetas de marcador de posición (por ejemplo, {COMPANY-NAME}, {FULL-NAME}, {INVOICE-NUMBER}, etc.) para contenido reemplazable.

Figura 13

**Una plantilla de factura de muestra. Escribiremos código JavaScript adicional que añadirá datos dinámicos a esta plantilla antes de generarla en PDFs.

Antes de continuar, puedes descargar esta plantilla HTML y examinarla en tu IDE preferido.

En el siguiente bloque de código fuente, cargaremos la plantilla HTML en un nuevo objeto PdfDocument, reemplazaremos los marcadores de posición que definimos con algunos datos de prueba ficticios y luego guardaremos el objeto PdfDocument en el sistema de archivos.

import {PdfDocument} from "@ironsoftware/ironpdf";
import('./config.js');

/**
 * Loads an HTML template from the file system.
 */
async function getTemplateHtml(fileLocation) {
    // Return promise for loading template file
    return PdfDocument.fromFile(fileLocation);
}

/**
 * Save the PDF document at a given location.
 */
async function generatePdf(pdf, location) {
    return pdf.saveAs(location);
}

/**
 * Use the PdfDocument.replaceText method to replace 
 * a specified placeholder with a provided value.
 */
async function addTemplateData(pdf, key, value) {
    return pdf.replaceText(key, value);
}

const template = "./sample-invoice.html";
getTemplateHtml(template).then(async (doc) => { // load HTML template from file
    await addTemplateData(doc, "{FULL-NAME}", "Lizbeth Presland");
    await addTemplateData(doc, "{ADDRESS}", "678 Manitowish Alley, Portland, OG");
    await addTemplateData(doc, "{PHONE-NUMBER}", "(763) 894-4345");
    await addTemplateData(doc, "{INVOICE-NUMBER}", "787");
    await addTemplateData(doc, "{INVOICE-DATE}", "August 28, 2023");
    await addTemplateData(doc, "{AMOUNT-DUE}", "13,760.13");
    await addTemplateData(doc, "{RECIPIENT}", "Celestyna Farmar"),
    await addTemplateData(doc, "{COMPANY-NAME}", "BrainBook");
    await addTemplateData(doc, "{TOTAL}", "13,760.13");
    await addTemplateData(doc, "{AMOUNT-PAID}", "0.00");
    await addTemplateData(doc, "{BALANCE-DUE}", "13,760.13");
    await addTemplateData(doc, "{ITEM}", "Training Sessions");
    await addTemplateData(doc, "{DESCRIPTION}", "60 Minute instruction");
    await addTemplateData(doc, "{RATE}", "3,440.03");
    await addTemplateData(doc, "{QUANTITY}", "4");
    await addTemplateData(doc, "{PRICE}", "13,760.13");
    return doc;
}).then(async (doc) => await generatePdf(doc, "html-template-to-pdf.pdf"));
NODE.JS

El código fuente anterior define tres funciones de ayuda asíncronas:

  • getTemplateHtml: utiliza el método PdfDocument.fromHtml para cargar una plantilla HTML en un nuevo objeto PdfDocument.
  • addTemplateData: utiliza el método PdfDocument.replaceText para sustituir un marcador de posición proporcionado (denominado como clave), por su valor de datos de reemplazo.
  • generatePdf: guarda un PdfDocument en una ubicación de archivo dada.

    Además, declaramos una variable const template para mantener la ubicación de nuestro archivo de plantilla HTML. El PDF generado a partir del código fuente anterior se muestra a continuación.

    Figura 14

    El nuevo documento PDF creado a partir de sustituir marcadores definidos en una plantilla HTML con datos reales. Este documento conserva los estilos CSS y el diseño que esperaríamos si no se hubieran realizado tales reemplazos.

Lecturas complementarias

Este tutorial sólo ha arañado la superficie de lo que es posible con las funciones de alto nivel de la API de IronPDF. Considere la posibilidad de estudiar estos temas relacionados para ampliar sus conocimientos y comprensión.

  1. La clase PdfGenerator: esta es una clase de utilidad dedicada para crear objetos PdfDocument a partir de HTML, URLs, archivos Zip y otros medios de origen. Esta clase ofrece una alternativa viable al uso de las funciones de renderizado PDF definidas en la clase PdfDocument.

  2. HttpLoginCredentials: si alguna vez necesitas generar PDFs a partir de páginas web que requieren cookies específicas o están protegidas con contraseña, entonces esta referencia será extremadamente útil.
Darrius Serrant
Ingeniero de Software Full Stack (WebOps)

Darrius Serrant tiene una licenciatura en Informática de la Universidad de Miami y trabaja como Ingeniero de Marketing WebOps Full Stack en Iron Software. Atraído por la programación desde una edad temprana, veía la computación como algo misterioso y accesible, lo que la convertía en el medio perfecto para la creatividad y la resolución de problemas.

En Iron Software, Darrius disfruta creando cosas nuevas y simplificando conceptos complejos para hacerlos más comprensibles. Como uno de nuestros desarrolladores residentes, también se ha ofrecido como voluntario para enseñar a los estudiantes, compartiendo su experiencia con la próxima generación.

Para Darrius, su trabajo es gratificante porque es valorado y tiene un impacto real.