O IronPDF simplifica a extração de dados de PDFs no ASP.NET Core , fornecendo métodos para ler texto, dados de formulário e tabelas de arquivos PDF usando código C# direto, sem dependências complexas ou análise manual.

Trabalhar com arquivos PDF em aplicações .NET pode ser mais desafiador do que parece à primeira vista. Você pode precisar extrair texto de faturas enviadas, recuperar dados de formulários de pesquisas ou analisar tabelas para seu banco de dados. Muitos projetos ficam mais lentos porque os desenvolvedores recorrem a bibliotecas excessivamente complexas que exigem extenso código de análise sintática personalizado. O IronPDF oferece uma alternativa simples, permitindo que você leia e processe documentos PDF com configuração mínima.

Quer você esteja lidando com texto simples, campos de formulário interativos ou dados tabulares estruturados, a API do IronPDF oferece acesso direto ao conteúdo do PDF sem a necessidade de análise sintática de baixo nível. Este guia explica como ler dados de arquivos PDF no ASP.NET Core, abordando extração de texto, recuperação de dados de formulários, análise de tabelas e tratamento de uploads assíncronos de arquivos — tudo com código C# que você pode inserir em seu projeto.

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

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

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. IronPDF fornece ExtractAllText para extrair todo o texto legível de um documento e ExtractTextFromPage para acesso a 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)

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 o conteúdo de texto completo como uma única string, preservando as quebras de linha. ExtractTextFromPage direciona uma página única 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 de 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.

Como integrar a extração de texto em um controlador ASP.NET Core ?

A ação do controlador a seguir aceita um PDF enviado via IFormFile, lê ele em um MemoryStream e retorna o texto extraído como JSON:

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

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

Este endpoint converte o arquivo enviado em um array de bytes e passa ele diretamente para PdfDocument. Nenhum arquivo temporário é gravado em disco, o que mantém o código limpo e evita sobrecarga desnecessária de armazenamento. A interface IFormFile funciona naturalmente tanto com submissões de formulário multipart quanto com clientes de API como Postman.

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. IronPDF expõe campos de 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

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 criação de PDF) e uma propriedade Value (o texto ou seleção que o usuário inseriu). 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 de formulários PDF programaticamente, o guia de formulários PDF mostra como adicionar campos e pré-preencher valores.

Qual é a aparência típica de uma resposta de extração de formulário?

A resposta acima mostra um resultado 200 OK contendo os nomes e valores dos campos de um formulário de contato de exemplo em PDF. A estrutura é um mapa simples de chave-valor, que se adapta facilmente à maioria dos esquemas de banco de dados ou payloads REST.

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 ExtractAllText do IronPDF preserva espaços em branco e caracteres de tabulação, o que torna possível 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

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.

Quando você deve analisar tabelas manualmente?

A análise manual é a opção correta quando o PDF não foi gerado a partir de HTML ou de uma fonte de dados estruturada — por exemplo, faturas digitalizadas ou documentos criados em ferramentas de editoração eletrônica. A abordagem de divisão por tabulação lida de forma confiável com muitos PDFs padrão. Quando os limites das colunas são irregulares, você pode refinar a lógica inspecionando as coordenadas brutas dos caracteres por meio da API de acesso ao DOM do IronPDF.

Para documentos gerados a partir de HTML, considere a possibilidade de usar um intermediário HTML para o processo de ida e volta. Gerar seu PDF a partir de um modelo HTML orientado a dados (abordado no guia de string HTML para PDF ) significa que as posições do texto serão previsíveis e a extração será simples.

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

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 - frequentemente 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.

Como limitar o tamanho dos arquivos que você pode enviar?

O ASP.NET Core impõe um limite padrão de tamanho de corpo de requisição de 30 MB. Para PDFs maiores, aumente o limite em Program.cs:

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)

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

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

O falcão-peneireiro tem o seu próprio limite, que você também pode precisar aumentar:

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)

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

Defina esses valores com base no tamanho máximo realista dos PDFs que seu aplicativo processará. Sempre verifique o tipo MIME e a extensão do arquivo enviado antes de passá-lo para o IronPDF para evitar entradas inesperadas.

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 textos pesquisáveis), será necessário um passo 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.