A Biblioteca PDF do Node.js

Explore IronPDF for Node.js Comece seu teste gratuito

HTML para PDF

Online Demo Veja todos os exemplos de código %s

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

(async () => {
    // Create a PDF from an HTML string
    const pdf = await PdfDocument.fromHtml("<h1>Hello World</h1>");

    // Export the PDF to a file
    await pdf.saveAs("output.pdf");

    // Advanced Example with HTML Assets
    // Load external HTML assets: Images, CSS, and JavaScript.
    const htmlContentWithAssets = "<img src='icons/iron.png'>";
    const advancedPdf = await PdfDocument.fromHtml(htmlContentWithAssets);

    // Save the PDF with loaded assets
    await advancedPdf.saveAs("html-with-assets.pdf");
})();

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

(async () => {
    // Create a PDF from an HTML string
    const pdf = await PdfDocument.fromHtml("<h1>Hello World</h1>");

    // Export the PDF to a file
    await pdf.saveAs("output.pdf");

    // Advanced Example with HTML Assets
    // Load external HTML assets: Images, CSS, and JavaScript.
    const htmlContentWithAssets = "<img src='icons/iron.png'>";
    const advancedPdf = await PdfDocument.fromHtml(htmlContentWithAssets);

    // Save the PDF with loaded assets
    await advancedPdf.saveAs("html-with-assets.pdf");
})();

AJUDA DO NODE

Node.js Fetch (Como funciona para desenvolvedores)

Curtis Chau

Updated: 21 de abril de 2026

O Node Fetch é um módulo leve e popular no ecossistema Node.js , projetado para tornar as requisições HTTP simples e intuitivas. Ele oferece uma maneira leve e familiar de interagir com APIs da web, inspirada na API Fetch disponível no ambiente do navegador. O Node-fetch oferece suporte à API Fetch no Node.js, permitindo que os service workers manipulem cabeçalhos HTTP e realizem solicitações HTTPS de forma eficiente.

Este artigo ajudará você a explorar os principais recursos e usos do Node-fetch , oferecendo um guia completo para desenvolvedores que desejam otimizar o tratamento de requisições HTTP em Node.js Também utilizaremos o IronPDF , uma biblioteca PDF for Node.js que permite aos programadores criar e editar PDFs, converter conteúdo HTML em PDF e muito mais.

O que é o fetch do Node.js ?

Node fetch é um módulo que traz a API Fetch para o Node.js A API Fetch é uma interface moderna para fazer requisições HTTP, comumente usada em navegadores web. O fetch do Node.js replica essa funcionalidade, permitindo que aplicativos Node.js realizem requisições HTTP com a mesma facilidade e simplicidade. Isso a torna uma excelente opção para desenvolvedores que já estão familiarizados com a API Fetch ou para aqueles que buscam uma maneira simples de lidar com solicitações HTTP em seus aplicativos Node.js

Node.js Fetch (Como Funciona Para Desenvolvedores): Figura 1 - Node.js Fetch

Principais funcionalidades do Fetch em Node.js

1. Simplicidade e Familiaridade

O fetch do Node.js imita a API Fetch encontrada nos navegadores, fornecendo uma interface simples e familiar para os desenvolvedores.

2. Baseado em promessas

Assim como a API Fetch, o fetch do Node.js é baseado em promessas, permitindo que os desenvolvedores escrevam código assíncrono de uma maneira mais legível e gerenciável.

3. Leve

A biblioteca fetch do Node.js é minimalista, o que a torna rápida e eficiente. Não acarreta a sobrecarga de bibliotecas HTTP maiores, mantendo sua aplicação enxuta.

4. Compatibilidade

O fetch do Node.js suporta uma ampla gama de métodos HTTP, cabeçalhos e tipos de resposta, tornando-o altamente versátil.

5. Transmissão

Ele suporta respostas em fluxo contínuo, o que é útil para lidar com grandes volumes de dados de forma eficiente.

Instalando o Fetch do Node.js

Para começar a usar o Node-fetch , você precisa instalá-lo via npm (Node Package Manager). Execute o seguinte comando no diretório do seu projeto:

npm install node-fetch

npm install node-fetch

SHELL

Uso básico

Aqui está um exemplo básico de como usar o fetch do Node.js para fazer uma requisição GET:

import fetch from 'node-fetch';

const url = 'https://jsonplaceholder.typicode.com/posts';

// Make a GET request to fetch data
fetch(url)
    .then(response => {
        // Check if the response status is OK
        if (!response.ok) {
            throw new Error('Network response was not ok');
        }
        // Parse the response as JSON
        return response.json();
    })
    .then(data => {
        // Process the JSON data
        console.log(data);
    })
    .catch(error => {
        // Handle any errors that occur during the fetch
        console.error('There has been a problem with your fetch operation:', error);
    });

import fetch from 'node-fetch';

const url = 'https://jsonplaceholder.typicode.com/posts';

// Make a GET request to fetch data
fetch(url)
    .then(response => {
        // Check if the response status is OK
        if (!response.ok) {
            throw new Error('Network response was not ok');
        }
        // Parse the response as JSON
        return response.json();
    })
    .then(data => {
        // Process the JSON data
        console.log(data);
    })
    .catch(error => {
        // Handle any errors that occur during the fetch
        console.error('There has been a problem with your fetch operation:', error);
    });

JavaScript

Este trecho de código demonstra uma solicitação GET simples para obter dados JSON de uma API. A função fetch retorna uma promessa que se resolve com o objeto de resposta. Em seguida, você pode chamar métodos que retornam respostas, como json(), para analisar o corpo da resposta.

Saída do console

Node.js Fetch (Como Funciona Para Desenvolvedores): Figura 2 - Saída do console para uma solicitação GET simples para buscar dados JSON de uma URL de API "https://jsonplaceholder.typicode.com/posts" usando Node.js fetch.

Uso avançado

O fetch do Node.js também oferece suporte a recursos mais avançados, como fazer solicitações POST, definir cabeçalhos de solicitação personalizados e lidar com diferentes tipos de resposta.

Como fazer uma solicitação POST

import fetch from 'node-fetch';

const url = 'https://jsonplaceholder.typicode.com/posts';
const data = { key: 'value' };

// Make a POST request with JSON payload
fetch(url, {
    method: 'POST',
    headers: {
        // Specify content type as JSON
        'Content-Type': 'application/json'
    },
    body: JSON.stringify(data)
})
    .then(response => {
        // Check if the response status is OK
        if (!response.ok) {
            throw new Error('Network response was not ok');
        }
        // Parse the response as JSON
        return response.json();
    })
    .then(data => {
        // Process the JSON data
        console.log(data);
    })
    .catch(error => {
        // Handle any errors that occur during the fetch
        console.error('There has been a problem with your fetch operation:', error);
    });

import fetch from 'node-fetch';

const url = 'https://jsonplaceholder.typicode.com/posts';
const data = { key: 'value' };

// Make a POST request with JSON payload
fetch(url, {
    method: 'POST',
    headers: {
        // Specify content type as JSON
        'Content-Type': 'application/json'
    },
    body: JSON.stringify(data)
})
    .then(response => {
        // Check if the response status is OK
        if (!response.ok) {
            throw new Error('Network response was not ok');
        }
        // Parse the response as JSON
        return response.json();
    })
    .then(data => {
        // Process the JSON data
        console.log(data);
    })
    .catch(error => {
        // Handle any errors that occur during the fetch
        console.error('There has been a problem with your fetch operation:', error);
    });

JavaScript

Este exemplo mostra como enviar uma solicitação POST com uma carga útil JSON. A opção headers é usada para especificar o tipo de conteúdo da resposta, e a opção body contém os dados JSON serializados.

Saída do console

Node.js Fetch (Como Funciona Para Desenvolvedores): Figura 3 - Saída do console para um objeto de solicitação POST enviado para URL "https://jsonplaceholder.typicode.com/posts" usando Node.js fetch

Lidando com respostas de streaming

import fetch from 'node-fetch';
import fs from 'fs';

const url = 'https://jsonplaceholder.typicode.com/posts';

// Make a GET request to fetch data and stream it to a file
fetch(url)
    .then(response => {
        // Check if the response status is OK
        if (!response.ok) {
            throw new Error('Network response was not ok');
        }
        // Pipe the response body as a file stream to 'large-data.json'
        const dest = fs.createWriteStream('./large-data.json');
        response.body.pipe(dest);
    })
    .catch(error => {
        // Handle any errors that occur during the fetch
        console.error('There has been a problem with your fetch operation:', error);
    });

import fetch from 'node-fetch';
import fs from 'fs';

const url = 'https://jsonplaceholder.typicode.com/posts';

// Make a GET request to fetch data and stream it to a file
fetch(url)
    .then(response => {
        // Check if the response status is OK
        if (!response.ok) {
            throw new Error('Network response was not ok');
        }
        // Pipe the response body as a file stream to 'large-data.json'
        const dest = fs.createWriteStream('./large-data.json');
        response.body.pipe(dest);
    })
    .catch(error => {
        // Handle any errors that occur during the fetch
        console.error('There has been a problem with your fetch operation:', error);
    });

JavaScript

Neste exemplo, o corpo da resposta é enviado ao servidor como um fluxo de arquivo, demonstrando como lidar com respostas grandes de forma eficiente.

SAÍDA

Node.js Fetch (Como Funciona Para Desenvolvedores): Figura 4 - Arquivo de saída: large-data.json

Tratamento de erros

O tratamento adequado de erros é crucial ao trabalhar com requisições HTTP. O fetch do Node.js oferece uma maneira simples de capturar e lidar com erros usando promises.

fetch(url)
    .then(response => {
        // Check if the response status is OK
        if (!response.ok) {
            throw new Error(`HTTP error! status: ${response.status}`);
        }
        // Parse the response as JSON
        return response.json();
    })
    .then(data => {
        // Process the JSON data
        console.log(data);
    })
    .catch(error => {
        // Handle any errors that occur during the fetch
        console.error('Fetch error:', error);
    });

fetch(url)
    .then(response => {
        // Check if the response status is OK
        if (!response.ok) {
            throw new Error(`HTTP error! status: ${response.status}`);
        }
        // Parse the response as JSON
        return response.json();
    })
    .then(data => {
        // Process the JSON data
        console.log(data);
    })
    .catch(error => {
        // Handle any errors that occur during the fetch
        console.error('Fetch error:', error);
    });

JavaScript

Neste caso, um erro é lançado se o status da resposta não estiver no intervalo de 200 a 299, e o bloco catch trata quaisquer erros que ocorram durante a requisição. Caso contrário, a resposta JSON válida é retornada.

Utilizando o método `fetch` do Node.js com o IronPDF para gerar PDFs em Node.js

Node fetch é uma biblioteca popular no ecossistema Node.js para fazer requisições HTTP fetch. Quando combinado com o IronPDF , uma poderosa biblioteca de geração de PDFs, ele se torna uma ferramenta versátil para criar PDFs a partir de diversos recursos da web.

O que é o IronPDF?

IronPDF é uma biblioteca robusta que permite aos desenvolvedores criar, editar e extrair conteúdo de PDFs de maneira simples e eficiente. Disponível para C#, Python, Java e Node.js, o IronPDF simplifica a manipulação de PDFs com sua API intuitiva.

Node.js Fetch (Como Funciona Para Desenvolvedores): Figura 5 - IronPDF for Node.js: A Biblioteca PDF do Node.js

Instalando a biblioteca IronPDF

Primeiro, você precisa instalar o IronPDF em seu projeto. Utilize o seguinte comando npm para instalar a biblioteca:

> npm i @ironsoftware/ironpdf

npm i @ironsoftware/ironpdf

Vamos explorar como usar o fetch do Node.js com o IronPDF para gerar PDFs a partir de fontes de conteúdo da web.

Combinando o fetch do Node.js com o IronPDF

Você pode aproveitar o poder do fetch do Node.js e do IronPDF para buscar conteúdo da web dinamicamente e gerar PDFs. Por exemplo, você pode buscar os dados de um endpoint de API, gerar HTML dinâmico e convertê-lo em um PDF . O exemplo a seguir demonstra como você pode realizar essa tarefa:

import fetch from 'node-fetch';
import { PdfDocument } from '@ironsoftware/ironpdf';

(async () => {
    // Replace the apiUrl with the actual URL
    const apiUrl = "https://jsonplaceholder.typicode.com/posts";

    // Fetch data from API
    const response = await fetch(apiUrl);
    const data = await response.json();

    // Create dynamic HTML content with a table
    const htmlContent = `
        <!DOCTYPE html>
        <html>
        <head>
            <title>Data Report</title>
            <style>
                body {
                    font-family: Arial, sans-serif;
                    margin: 40px;
                }
                table {
                    width: 100%;
                    border-collapse: collapse;
                }
                table, th, td {
                    border: 1px solid black;
                }
                th, td {
                    padding: 10px;
                    text-align: left;
                }
                th {
                    background-color: #f2f2f2;
                }
                h1 {
                    text-align: center;
                }
            </style>
        </head>
        <body>
            <h1>Data Report</h1>
            <table>
                <tr>
                    <th>User ID</th>
                    <th>ID</th>
                    <th>Title</th>
                    <th>Body</th>
                </tr>
                ${data.map(item => `
                    <tr>
                        <td>${item.userId}</td>
                        <td>${item.id}</td>
                        <td>${item.title}</td>
                        <td>${item.body}</td>
                    </tr>
                `).join('')}
            </table>
        </body>
        </html>
    `;

    // Generate PDF from the HTML string
    const pdfFromHtmlString = await PdfDocument.fromHtml(htmlContent);
    await pdfFromHtmlString.saveAs("dynamic_report.pdf");
    console.log("PDF generated from API data successfully!");
})();

import fetch from 'node-fetch';
import { PdfDocument } from '@ironsoftware/ironpdf';

(async () => {
    // Replace the apiUrl with the actual URL
    const apiUrl = "https://jsonplaceholder.typicode.com/posts";

    // Fetch data from API
    const response = await fetch(apiUrl);
    const data = await response.json();

    // Create dynamic HTML content with a table
    const htmlContent = `
        <!DOCTYPE html>
        <html>
        <head>
            <title>Data Report</title>
            <style>
                body {
                    font-family: Arial, sans-serif;
                    margin: 40px;
                }
                table {
                    width: 100%;
                    border-collapse: collapse;
                }
                table, th, td {
                    border: 1px solid black;
                }
                th, td {
                    padding: 10px;
                    text-align: left;
                }
                th {
                    background-color: #f2f2f2;
                }
                h1 {
                    text-align: center;
                }
            </style>
        </head>
        <body>
            <h1>Data Report</h1>
            <table>
                <tr>
                    <th>User ID</th>
                    <th>ID</th>
                    <th>Title</th>
                    <th>Body</th>
                </tr>
                ${data.map(item => `
                    <tr>
                        <td>${item.userId}</td>
                        <td>${item.id}</td>
                        <td>${item.title}</td>
                        <td>${item.body}</td>
                    </tr>
                `).join('')}
            </table>
        </body>
        </html>
    `;

    // Generate PDF from the HTML string
    const pdfFromHtmlString = await PdfDocument.fromHtml(htmlContent);
    await pdfFromHtmlString.saveAs("dynamic_report.pdf");
    console.log("PDF generated from API data successfully!");
})();

JavaScript

PDF de saída

A resposta em JSON é elegantemente mapeada para a tabela HTML e o IronPDF a converte com precisão, preservando toda a sua formatação.

Node.js Fetch (Como Funciona Para Desenvolvedores): Figura 6 - String HTML convertida para PDF usando IronPDF com precisão.

Para obter mais detalhes sobre o IronPDF e suas funcionalidades, consulte esta página de documentação .

Conclusão

Node fetch é uma ferramenta poderosa e simples para fazer requisições HTTP em Node.js Sua API familiar, abordagem baseada em promessas e natureza leve a tornam uma excelente escolha tanto para iniciantes quanto para desenvolvedores experientes. Quer você esteja realizando solicitações GET básicas ou lidando com solicitações POST complexas com cabeçalhos personalizados, o Node fetch oferece uma maneira simples e eficiente de interagir com APIs da web.

A combinação do Node fetch com o IronPDF oferece uma maneira poderosa e flexível de gerar PDFs a partir de diversas fontes de conteúdo da web em Node.js Ao integrar essas duas bibliotecas, você pode criar aplicativos robustos que aproveitam dados da web e geram PDFs profissionais com facilidade.

IronPDF starting at $999. Experimente seus poderosos recursos de geração de PDF sem riscos. Experimente hoje mesmo e veja a diferença por si próprio!

Curtis Chau

Converse agora mesmo com a equipe de engenharia.

Redator Técnico

Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.

...