Como ler dados de arquivos PDF no ASP.NET Core

Como configurar o IronPDF em um projeto ASP.NET Core ?

Começar é muito simples. Instale o pacote NuGet IronPDF a partir do Console do Gerenciador de Pacotes NuGet ou da CLI do .NET usando um destes comandos:

Install-Package IronPdf
dotnet add package IronPdf

Install-Package IronPdf
dotnet add package IronPdf

Após a instalação do pacote, adicione o namespace IronPDF no início de qualquer arquivo que trabalhe com documentos PDF:

using IronPdf;

using IronPdf;

Imports IronPdf

Essa é toda a configuração necessária para a maioria dos projetos. O IronPDF não depende de processos de renderização externos nem de dependências nativas adicionais do Windows. Para ambientes Linux ou Docker, consulte a documentação do IronPDF para obter orientações específicas da plataforma.

Uma licença de avaliação gratuita permite que você teste o conjunto completo de recursos antes de se comprometer com o uso em produção. Você pode obter uma licença de avaliação diretamente do site da IronPDF e aplicá-la com uma única linha de código antes da sua primeira operação com um PDF.

Como extrair texto de um arquivo PDF?

A extração de texto é a tarefa mais comum na leitura de PDFs. O IronPDF fornece ExtractAllText para extrair todo o texto legível de um documento e ExtractTextFromPage para acesso em nível de página. Ambos os métodos preservam a ordem de leitura e são compatíveis com codificações de texto padrão.

// Load a PDF document from disk
var pdf = PdfDocument.FromFile("document.pdf");

// Extract all text from every page
string allText = pdf.ExtractAllText();

// Extract text from a specific page (zero-based index)
string pageOneText = pdf.ExtractTextFromPage(0);

Console.WriteLine(allText);

// Load a PDF document from disk
var pdf = PdfDocument.FromFile("document.pdf");

// Extract all text from every page
string allText = pdf.ExtractAllText();

// Extract text from a specific page (zero-based index)
string pageOneText = pdf.ExtractTextFromPage(0);

Console.WriteLine(allText);

Imports System

' Load a PDF document from disk
Dim pdf = PdfDocument.FromFile("document.pdf")

' Extract all text from every page
Dim allText As String = pdf.ExtractAllText()

' Extract text from a specific page (zero-based index)
Dim pageOneText As String = pdf.ExtractTextFromPage(0)

Console.WriteLine(allText)

ExtractAllText retorna todo o conteúdo do texto como uma única string, preservando as quebras de linha. ExtractTextFromPage tem como alvo uma única página usando um índice baseado em zero, o que é útil quando você precisa apenas do conteúdo de uma seção específica de um documento com várias páginas.

Para uma análise detalhada das opções de extração de texto e imagem, o guia de extração de texto de PDF aborda cenários avançados, incluindo extração baseada em região.

using IronPdf;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using System.IO;

[ApiController]
[Route("api/[controller]")]
public class PdfController : ControllerBase
{
    [HttpPost("extract-text")]
    public IActionResult ExtractText(IFormFile pdfFile)
    {
        if (pdfFile == null || pdfFile.Length == 0)
            return BadRequest("No PDF file uploaded.");

        using var stream = new MemoryStream();
        pdfFile.CopyTo(stream);

        var pdf = new PdfDocument(stream.ToArray());
        string extractedText = pdf.ExtractAllText();

        return Ok(new { text = extractedText });
    }
}

using IronPdf;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using System.IO;

[ApiController]
[Route("api/[controller]")]
public class PdfController : ControllerBase
{
    [HttpPost("extract-text")]
    public IActionResult ExtractText(IFormFile pdfFile)
    {
        if (pdfFile == null || pdfFile.Length == 0)
            return BadRequest("No PDF file uploaded.");

        using var stream = new MemoryStream();
        pdfFile.CopyTo(stream);

        var pdf = new PdfDocument(stream.ToArray());
        string extractedText = pdf.ExtractAllText();

        return Ok(new { text = extractedText });
    }
}

Imports IronPdf
Imports Microsoft.AspNetCore.Http
Imports Microsoft.AspNetCore.Mvc
Imports System.IO

<ApiController>
<Route("api/[controller]")>
Public Class PdfController
    Inherits ControllerBase

    <HttpPost("extract-text")>
    Public Function ExtractText(pdfFile As IFormFile) As IActionResult
        If pdfFile Is Nothing OrElse pdfFile.Length = 0 Then
            Return BadRequest("No PDF file uploaded.")
        End If

        Using stream As New MemoryStream()
            pdfFile.CopyTo(stream)

            Dim pdf As New PdfDocument(stream.ToArray())
            Dim extractedText As String = pdf.ExtractAllText()

            Return Ok(New With {.text = extractedText})
        End Using
    End Function
End Class

Como ler dados de formulário PDF no ASP.NET Core?

Os formulários em PDF -- também chamados de AcroForms -- contêm campos interativos que os usuários preenchem. O IronPDF expõe os campos do formulário através da propriedade Form de PdfDocument, fornecendo o nome e o valor de cada campo no documento.

O seguinte endpoint lê um formulário PDF carregado e retorna todos os valores dos campos como um dicionário JSON:

[HttpPost("extract-form")]
public IActionResult ExtractForm([FromForm] IFormFile pdfFile)
{
    if (pdfFile == null || pdfFile.Length == 0)
        return BadRequest("No PDF file uploaded.");

    using var stream = new MemoryStream();
    pdfFile.CopyTo(stream);

    var pdf = new PdfDocument(stream.ToArray());
    var formData = new Dictionary<string, string>();

    if (pdf.Form != null)
    {
        foreach (var field in pdf.Form)
        {
            formData[field.Name] = field.Value;
        }
    }

    return Ok(new { formFields = formData });
}

[HttpPost("extract-form")]
public IActionResult ExtractForm([FromForm] IFormFile pdfFile)
{
    if (pdfFile == null || pdfFile.Length == 0)
        return BadRequest("No PDF file uploaded.");

    using var stream = new MemoryStream();
    pdfFile.CopyTo(stream);

    var pdf = new PdfDocument(stream.ToArray());
    var formData = new Dictionary<string, string>();

    if (pdf.Form != null)
    {
        foreach (var field in pdf.Form)
        {
            formData[field.Name] = field.Value;
        }
    }

    return Ok(new { formFields = formData });
}

Imports Microsoft.AspNetCore.Mvc
Imports System.IO

<HttpPost("extract-form")>
Public Function ExtractForm(<FromForm> pdfFile As IFormFile) As IActionResult
    If pdfFile Is Nothing OrElse pdfFile.Length = 0 Then
        Return BadRequest("No PDF file uploaded.")
    End If

    Using stream As New MemoryStream()
        pdfFile.CopyTo(stream)

        Dim pdf = New PdfDocument(stream.ToArray())
        Dim formData As New Dictionary(Of String, String)()

        If pdf.Form IsNot Nothing Then
            For Each field In pdf.Form
                formData(field.Name) = field.Value
            Next
        End If

        Return Ok(New With {.formFields = formData})
    End Using
End Function

Cada campo em pdf.Form possui uma propriedade Name (o identificador do campo definido na ferramenta de autoria de PDF) e uma propriedade Value (o texto ou seleção inserida pelo usuário). Caixas de texto, caixas de seleção, botões de opção e listas suspensas estão presentes nesta coleção.

A resposta em JSON facilita o encaminhamento de formulários enviados para um banco de dados, uma API de terceiros ou uma fila de mensagens, sem qualquer análise adicional. Para fluxos de trabalho que envolvem a criação ou edição programática de formulários PDF, o guia de formulários PDF mostra como adicionar campos e preencher valores previamente.

Como extrair dados de tabela de um PDF?

As tabelas em arquivos PDF são armazenadas como texto posicionado — não existe uma estrutura de dados de tabela nativa no formato PDF. Extrair dados tabulares significa, portanto, extrair o texto bruto e, em seguida, aplicar lógica de análise sintática para reconstruir linhas e colunas.

O recurso ExtractAllText do IronPDF preserva espaços em branco e caracteres de tabulação, o que possibilita dividir linhas em colunas programaticamente. A seguinte ação do controlador demonstra essa abordagem:

[HttpPost("extract-table")]
public IActionResult ExtractTable([FromForm] IFormFile pdfFile)
{
    if (pdfFile == null || pdfFile.Length == 0)
        return BadRequest("No PDF file uploaded.");

    using var memoryStream = new MemoryStream();
    pdfFile.CopyTo(memoryStream);

    var pdf = new PdfDocument(memoryStream.ToArray());
    string text = pdf.ExtractAllText();

    // Split into lines, then split each line into columns
    string[] lines = text.Split(
        new[] { '\r', '\n' },
        StringSplitOptions.RemoveEmptyEntries
    );

    var tableData = new List<string[]>();
    foreach (string line in lines)
    {
        string[] columns = line
            .Split('\t')
            .Where(c => !string.IsNullOrWhiteSpace(c))
            .ToArray();

        if (columns.Length > 0)
            tableData.Add(columns);
    }

    var table = tableData.Select(r => string.Join(" | ", r)).ToList();
    return Ok(new { Table = table });
}

[HttpPost("extract-table")]
public IActionResult ExtractTable([FromForm] IFormFile pdfFile)
{
    if (pdfFile == null || pdfFile.Length == 0)
        return BadRequest("No PDF file uploaded.");

    using var memoryStream = new MemoryStream();
    pdfFile.CopyTo(memoryStream);

    var pdf = new PdfDocument(memoryStream.ToArray());
    string text = pdf.ExtractAllText();

    // Split into lines, then split each line into columns
    string[] lines = text.Split(
        new[] { '\r', '\n' },
        StringSplitOptions.RemoveEmptyEntries
    );

    var tableData = new List<string[]>();
    foreach (string line in lines)
    {
        string[] columns = line
            .Split('\t')
            .Where(c => !string.IsNullOrWhiteSpace(c))
            .ToArray();

        if (columns.Length > 0)
            tableData.Add(columns);
    }

    var table = tableData.Select(r => string.Join(" | ", r)).ToList();
    return Ok(new { Table = table });
}

Imports Microsoft.AspNetCore.Mvc
Imports System.IO
Imports System.Linq

<HttpPost("extract-table")>
Public Function ExtractTable(<FromForm> pdfFile As IFormFile) As IActionResult
    If pdfFile Is Nothing OrElse pdfFile.Length = 0 Then
        Return BadRequest("No PDF file uploaded.")
    End If

    Using memoryStream As New MemoryStream()
        pdfFile.CopyTo(memoryStream)

        Dim pdf As New PdfDocument(memoryStream.ToArray())
        Dim text As String = pdf.ExtractAllText()

        ' Split into lines, then split each line into columns
        Dim lines As String() = text.Split(New Char() {ControlChars.Cr, ControlChars.Lf}, StringSplitOptions.RemoveEmptyEntries)

        Dim tableData As New List(Of String())()
        For Each line As String In lines
            Dim columns As String() = line.Split(ControlChars.Tab).Where(Function(c) Not String.IsNullOrWhiteSpace(c)).ToArray()

            If columns.Length > 0 Then
                tableData.Add(columns)
            End If
        Next

        Dim table = tableData.Select(Function(r) String.Join(" | ", r)).ToList()
        Return Ok(New With {.Table = table})
    End Using
End Function

Essa abordagem funciona bem para PDFs cujas tabelas usam colunas consistentes separadas por tabulação. Para documentos em que as colunas são separadas por espaços em branco variáveis, pode ser necessário aplicar uma heurística de espaçamento mínimo ou inspecionar as posições dos caracteres. O guia de mesclagem ou divisão de PDFs é útil quando você precisa isolar páginas específicas que contêm tabelas antes da extração.

Como lidar com o envio assíncrono de arquivos PDF?

Aplicações ASP.NET Core em produção devem lidar com uploads de arquivos de forma assíncrona para evitar o bloqueio do pool de threads. O método IFormFile.CopyToAsync combinado com async/await mantém o controlador não bloqueante:

[HttpPost("process-upload")]
public async Task<IActionResult> ProcessPdf([FromForm] IFormFile file)
{
    if (file == null || file.Length == 0)
        return BadRequest("No PDF file uploaded.");

    using var ms = new MemoryStream();
    await file.CopyToAsync(ms);

    var pdf = new PdfDocument(ms.ToArray());
    string text = pdf.ExtractAllText();
    int pageCount = pdf.PageCount;

    return Ok(new
    {
        text,
        pages = pageCount
    });
}

[HttpPost("process-upload")]
public async Task<IActionResult> ProcessPdf([FromForm] IFormFile file)
{
    if (file == null || file.Length == 0)
        return BadRequest("No PDF file uploaded.");

    using var ms = new MemoryStream();
    await file.CopyToAsync(ms);

    var pdf = new PdfDocument(ms.ToArray());
    string text = pdf.ExtractAllText();
    int pageCount = pdf.PageCount;

    return Ok(new
    {
        text,
        pages = pageCount
    });
}

Imports System.IO
Imports Microsoft.AspNetCore.Mvc

<HttpPost("process-upload")>
Public Async Function ProcessPdf(<FromForm> file As IFormFile) As Task(Of IActionResult)
    If file Is Nothing OrElse file.Length = 0 Then
        Return BadRequest("No PDF file uploaded.")
    End If

    Using ms As New MemoryStream()
        Await file.CopyToAsync(ms)

        Dim pdf As New PdfDocument(ms.ToArray())
        Dim text As String = pdf.ExtractAllText()
        Dim pageCount As Integer = pdf.PageCount

        Return Ok(New With {
            .text = text,
            .pages = pageCount
        })
    End Using
End Function

O construtor PdfDocument é síncrono, mas a etapa de upload -- geralmente a parte mais lenta do pipeline -- é executada de forma assíncrona. Esse padrão se adapta bem a cargas simultâneas e é compatível com endpoints de API mínimos, manipuladores de Razor Pages e serviços gRPC.

builder.Services.Configure<FormOptions>(options =>
{
    options.MultipartBodyLengthLimit = 100 * 1024 * 1024; // 100 MB
});

builder.Services.Configure<FormOptions>(options =>
{
    options.MultipartBodyLengthLimit = 100 * 1024 * 1024; // 100 MB
});

Imports Microsoft.Extensions.DependencyInjection
Imports Microsoft.AspNetCore.Http

builder.Services.Configure(Of FormOptions)(Sub(options)
    options.MultipartBodyLengthLimit = 100 * 1024 * 1024 ' 100 MB
End Sub)

builder.WebHost.ConfigureKestrel(options =>
{
    options.Limits.MaxRequestBodySize = 100 * 1024 * 1024;
});

builder.WebHost.ConfigureKestrel(options =>
{
    options.Limits.MaxRequestBodySize = 100 * 1024 * 1024;
});

builder.WebHost.ConfigureKestrel(Sub(options)
    options.Limits.MaxRequestBodySize = 100 * 1024 * 1024
End Sub)

Como converter o conteúdo extraído de um PDF para outros formatos?

Depois de obter dados de texto ou formulário, você pode encaminhá-los para qualquer processo subsequente que seu aplicativo exija — gravações em banco de dados, indexação de pesquisa, geração de relatórios ou chamadas de API. O IronPDF também suporta a conversão na direção oposta: renderização de HTML para PDF.

Para os casos em que você deseja exibir visualmente o conteúdo extraído, pode renderizar o PDF original como imagens usando o guia de conversão de PDF para imagem . Isso é útil para recursos de visualização de documentos, onde você deseja exibir miniaturas das páginas sem carregar o PDF completo no navegador.

Se você precisar proteger os documentos de saída antes de entregá-los aos usuários, o IronPDF oferece suporte a assinaturas digitais e marcas d'água como etapas de pós-processamento. Adicionar cabeçalhos e rodapés — explicado no guia de cabeçalhos e rodapés — é igualmente simples.

Quais são os próximos passos após configurar a extração de dados de PDF?

Agora você possui padrões funcionais para extração de texto, leitura de dados de formulários, análise de tabelas e uploads assíncronos. Aqui estão algumas direções que você pode explorar a seguir, com base nos requisitos da sua candidatura.

Se você precisar gerar relatórios em PDF juntamente com seu fluxo de trabalho de extração, a visão geral dos recursos do IronPDF abrange a renderização de HTML para PDF, sobreposições de carimbo e manipulação de páginas. Para aplicações que combinam relatórios de múltiplas fontes, o guia de mesclagem ou divisão de PDFs explica como combinar e dividir documentos.

Para garantir a entrega segura de documentos, as assinaturas digitais permitem certificar PDFs antes de enviá-los aos clientes. As marcas d'água personalizadas adicionam identidade visual ou rótulos de rascunho aos documentos gerados.

Se o seu projeto extrai dados de PDFs digitalizados (imagens em vez de texto pesquisável), você precisará de uma etapa de OCR antes de chamar ExtractAllText. O IronOCR da Iron Software integra-se ao IronPDF para gerenciar fluxos de trabalho com documentos digitalizados.

O IronPDF está disponível com opções de licenciamento flexíveis para desenvolvedores individuais e equipes. Comece com um teste gratuito para experimentar todos os recursos sem restrições. A documentação completa inclui referência da API, guias de primeiros passos e notas de implantação para ambientes Windows, Linux, Docker e nuvem.

A leitura de dados de arquivos PDF no ASP.NET Core não exige mais código de análise de baixo nível nem dependências complexas. Com o IronPDF, o caminho do arquivo carregado ao conteúdo extraído se resume a algumas poucas linhas que se integram naturalmente a qualquer controlador ou camada de serviço.