IRONSOFTWAREHOME
IRONSUITETodos os 10 pelo preço de 2.
EDIÇÃO DE DOCUMENTOS
IMAGEM E RECONHECIMENTO
CONTATO DE VENDAS
FERRAMENTAS GRATUITAS
JUNTE-SE À NOSSA REDE DE ESPECIALISTAS

Invoice Processing in C#: Generate, Extract, and Automate PDF Invoices with .NET

Curtis Chau
Curtis Chau
Updated: 21 de janeiro de 2026

O processamento de faturas em C# .NET com IronPDF abrange todo o ciclo de vida do documento: geração de faturas em PDF profissionais a partir de modelos HTML, conformidade com os padrões de faturamento eletrônico ZUGFeRD e Factur-X , extração de dados estruturados de faturas recebidas usando análise de texto e processamento com inteligência artificial , e criação de fluxos de automação em lote que se integram a sistemas de contabilidade como QuickBooks, Xero e SAP.

Resumo: Guia de Início Rápido

Este tutorial aborda a geração, extração e automatização de faturas em PDF em C# .NET, incluindo conformidade com faturamento eletrônico, análise sintática com inteligência artificial e integração com sistemas de contabilidade.

  • Para quem é este produto: Desenvolvedores .NET que criam módulos de faturamento, automação de contas a pagar ou conformidade com faturamento eletrônico.
  • O que você vai desenvolver: geração de faturas com modelos HTML, incluindo itens e cálculos de impostos, códigos QR para links de pagamento, saída em PDF/A3 compatível com ZUGFeRD/Factur-X, extração de texto com expressões regulares, análise de faturas com inteligência artificial e processamento em lote com integração ao sistema de contabilidade.
  • Onde funciona: .NET 10, .NET 8 LTS, .NET Framework 4.6.2+ e .NET Standard 2.0. Sem dependências de serviços externos.
  • Quando usar esta abordagem: Quando você precisa gerar PDFs de faturas , cumprir as exigências de faturamento eletrônico da UE ou extrair dados de faturas de fornecedores para contas a pagar.
  • Por que isso é importante tecnicamente: o IronPDF renderiza HTML para PDF com precisão perfeita em nível de pixel, oferece suporte a PDF/A-3 para XML incorporado e fornece APIs de extração de texto que se combinam com expressões regulares ou IA para transformar faturas não estruturadas em dados estruturados.

Gere sua primeira fatura em PDF com apenas algumas linhas de código:

  1. 1Install IronPDF with NuGet Package Manager

    PM > Install-Package IronPdf

  2. 2Copie e execute este trecho de código.

    var renderer = new IronPdf.ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Invoice #1001</h1><p>Total: $500.00</p>");
pdf.SaveAs("invoice.pdf");

  3. 3Implante para testar em seu ambiente de produção.

    Comece a usar IronPDF em seu projeto hoje com uma avaliação gratuita
    arrow pointer

Após adquirir ou se inscrever para um período de avaliação de 30 dias do IronPDF, adicione sua chave de licença no início do seu aplicativo.

IronPdf.License.LicenseKey = "KEY";

Start using IronPDF in your project today with a free trial.

Primeiro passo:
arrow pointer
NuGetInstalar com NuGet

PM > Install-Package IronPdf

Install IronPDF by running the command above in the NuGet Package Manager Console, or search for the package in the NuGet Package Manager.
Índice
NuGetInstalar com NuGet

PM > Install-Package IronPdf

Install IronPDF by running the command above in the NuGet Package Manager Console, or search for the package in the NuGet Package Manager.

Qual é o ciclo de vida de uma fatura e por que o PDF continua sendo o padrão?

Antes de mergulhar no código, é útil entender todo o percurso que uma fatura faz em um sistema empresarial moderno. O ciclo de vida da fatura consiste em cinco fases distintas: geração, distribuição, recebimento, extração de dados e integração contábil.

O processo de faturamento começa com a geração da fatura. Uma empresa cria uma fatura que inclui itens discriminados, preços, cálculos de impostos, condições de pagamento e identidade visual da marca. A fatura precisa ter uma aparência profissional e atender a todos os requisitos legais. Em seguida, vem a distribuição, onde a fatura é enviada ao cliente por e-mail, através de um portal do cliente ou pelo correio tradicional. Quando o cliente recebe o documento, a equipe de contas a pagar o captura e o prepara para processamento. A extração de dados coleta informações importantes da fatura, como detalhes do fornecedor, itens de linha, totais e datas de vencimento, para que possam ser verificadas e comparadas com as ordens de compra. Por fim, a integração contábil transfere esses dados para sistemas financeiros como QuickBooks, Xero ou SAP para fins de pagamento e registro.

Por que o PDF ainda é o formato mais utilizado depois de tantos anos? Tudo se resume a uma combinação única de vantagens. Os arquivos PDF mantêm a formatação da sua fatura consistente, independentemente do dispositivo ou sistema operacional que você utilize. Independentemente de a pessoa abrir a sua fatura no Windows, no Mac ou no telemóvel, ela terá exatamente a aparência que você projetou. Os PDFs também são difíceis de alterar por engano, protegendo assim a integridade dos seus documentos melhor do que formatos como Word ou Excel. Você pode adicionar assinaturas digitais para autenticidade e usar criptografia para segurança. Mais importante ainda, os PDFs se tornaram um padrão universal que todos os sistemas empresariais reconhecem e suportam.

É claro que existe um desafio. Os PDFs são feitos para serem fáceis de ler para as pessoas, não para os computadores processarem. Em vez de armazenar informações em dados estruturados, um PDF salva texto, linhas, formas e imagens com base em onde eles aparecem na página. É por isso que ferramentas como o IronPDF são tão úteis: elas possibilitam transformar documentos legíveis para humanos em dados que o software consegue processar.

How to Generate Professional PDF Invoices in C#

A geração programática de faturas requer a transformação de dados estruturados, como informações do cliente, itens de linha e cálculos, em um documento PDF bem formatado. O IronPDF torna isso notavelmente simples, aproveitando HTML e CSS, tecnologias que a maioria dos desenvolvedores já conhece bem.

Neste tutorial, vamos analisar cenários prováveis que você encontrará no mundo real. Você também pode baixar o projeto mostrado abaixo aqui .

Como criar um modelo de fatura em HTML

A base da geração de faturas com o IronPDF é o HTML. Em vez de se debater com comandos de desenho de PDF de baixo nível, você cria sua fatura usando HTML e CSS padrão e, em seguida, deixa que o mecanismo de renderização baseado no Chrome do IronPDF a converta em um PDF com qualidade de imagem perfeita.

Aqui está um modelo básico de fatura que demonstra a abordagem:

using IronPdf;

// Define the HTML template for a basic invoice
// Uses inline CSS for styling headers, tables, and totals
string invoiceHtml = @"
<!DOCTYPE html>
<html>
<head>
<style>
body { font-family: Arial, sans-serif; padding: 40px; }
.header { text-align: right; margin-bottom: 40px; }
.company-name { font-size: 24px; font-weight: bold; color: #333; }
.invoice-title { font-size: 32px; margin: 20px 0; }
.bill-to { margin: 20px 0; }
table { width: 100%; border-collapse: collapse; margin: 20px 0; }
th { background-color: #2A95D5; color: white; padding: 10px; text-align: left; }
td { padding: 10px; border-bottom: 1px solid #ddd; }
.total { text-align: right; font-size: 20px; font-weight: bold; margin-top: 20px; }
</style>
</head>
<body>
<div class='header'>
<div class='company-name'>Your Company Name</div>
<div>123 Business Street</div>
<div>City, State 12345</div>
</div>

<div class='invoice-title'>INVOICE</div>

<div class='bill-to'>
<strong>Bill To:</strong><br>
Customer Name<br>
456 Customer Avenue<br>
City, State 67890
</div>

<table>
<tr>
    <th>Description</th>
    <th>Quantity</th>
    <th>Price</th>
    <th>Total</th>
</tr>
<tr>
    <td>Web Development Services</td>
    <td>10 hours</td>
    <td>$100.00</td>
    <td>$1,000.00</td>
</tr>
<tr>
    <td>Consulting</td>
    <td>5 hours</td>
    <td>$150.00</td>
    <td>$750.00</td>
</tr>
</table>

<div class='total'>Total: $1,750.00</div>
</body>
</html>";

// Initialize the Chrome-based PDF renderer
var renderer = new ChromePdfRenderer();

// Convert the HTML string to a PDF document
var pdf = renderer.RenderHtmlAsPdf(invoiceHtml);

// Save the generated PDF to disk
pdf.SaveAs("basic-invoice.pdf");

Exemplo de saída

Essa abordagem oferece uma flexibilidade enorme. Qualquer CSS que funcione no Chrome funcionará no seu PDF, incluindo recursos modernos como flexbox, layouts em grade e fontes personalizadas. Você pode até usar folhas de estilo e imagens externas, referenciando URLs ou caminhos de arquivos locais.

Como adicionar itens de linha dinâmicos e calcular totais

Faturas reais raramente têm conteúdo estático. Você precisa preencher itens de linha a partir de um banco de dados, calcular subtotais, aplicar taxas de impostos e formatar valores monetários. O exemplo a seguir demonstra um padrão pronto para produção para geração dinâmica de faturas:

using IronPdf;
using System;
using System.Collections.Generic;
using System.Linq;

// Represents a single line item on an invoice
public class InvoiceLineItem
{
    public string Description { get; set; }
    public decimal Quantity { get; set; }
    public decimal UnitPrice { get; set; }

    // Auto-calculates line total from quantity and unit price
    public decimal Total => Quantity * UnitPrice;
}

// Represents a complete invoice with customer details and line items
public class Invoice
{
    public string InvoiceNumber { get; set; }
    public DateTime InvoiceDate { get; set; }
    public string CustomerName { get; set; }
    public string CustomerAddress { get; set; }
    public List<InvoiceLineItem> LineItems { get; set; }

    // Computed properties for invoice totals
    public decimal Subtotal => LineItems.Sum(item => item.Total);
    public decimal TaxRate { get; set; } = 0.08m;  // Default 8% tax rate
    public decimal Tax => Subtotal * TaxRate;
    public decimal Total => Subtotal + Tax;
}

// Generates PDF invoices from Invoice objects using HTML templates
public class InvoiceGenerator
{
    public PdfDocument GenerateInvoice(Invoice invoice)
    {
        // Build HTML table rows dynamically from line items
        string lineItemsHtml = string.Join("", invoice.LineItems.Select(item => $@"
            <tr>
                <td>{item.Description}</td>
                <td>{item.Quantity}</td>
                <td>${item.UnitPrice:F2}</td>
                <td>${item.Total:F2}</td>
            </tr>
        "));

        // Build the complete HTML invoice using string interpolation
        // All invoice data is injected into the template dynamically
        string invoiceHtml = $@"
<!DOCTYPE html>
<html>
<head>
    <style>
        body {{font-family: Arial, sans-serif; padding: 40px;}}
        .header {{text-align: right; margin-bottom: 40px;}}
        .company-name {{font-size: 24px; font-weight: bold; color: #333;}}
        .invoice-details {{margin: 20px 0;}}
        table {{width: 100%; border-collapse: collapse; margin: 20px 0;}}
        th {{background-color: #2A95D5; color: white; padding: 10px; text-align: left;}}
        td {{padding: 10px; border-bottom: 1px solid #ddd;}}
        .totals {{text-align: right; margin-top: 20px;}}
        .totals div {{margin: 5px 0;}}
        .grand-total {{font-size: 20px; font-weight: bold; color: #2A95D5;}}
    </style>
</head>
<body>
    <div class='header'>
        <div class='company-name'>Your Company Name</div>
    </div>

    <h1>INVOICE</h1>

    <div class='invoice-details'>
        <strong>Invoice Number:</strong> {invoice.InvoiceNumber}<br>
        <strong>Date:</strong> {invoice.InvoiceDate:MMM dd, yyyy}<br>
        <strong>Bill To:</strong> {invoice.CustomerName}<br>
        {invoice.CustomerAddress}
    </div>

    <table>
        <tr>
            <th>Description</th>
            <th>Quantity</th>
            <th>Unit Price</th>
            <th>Total</th>
        </tr>
        {lineItemsHtml}
    </table>

    <div class='totals'>
        <div>Subtotal: ${invoice.Subtotal:F2}</div>
        <div>Tax ({invoice.TaxRate:P0}): ${invoice.Tax:F2}</div>
        <div class='grand-total'>Total: ${invoice.Total:F2}</div>
    </div>
</body>
</html>";

        // Render HTML to PDF and return the document
        var renderer = new ChromePdfRenderer();
        return renderer.RenderHtmlAsPdf(invoiceHtml);
    }
}

Exemplo de saída

A classe Invoice encapsula todos os dados da fatura com propriedades calculadas para subtotal, imposto e total. O gerador transforma esses dados em HTML usando interpolação de strings e, em seguida, os renderiza em PDF. Essa separação de responsabilidades torna o código mais fácil de manter e testar.

Como adicionar a identidade visual da empresa e marcas d'água às faturas

Faturas profissionais precisam de elementos de marca, como logotipos e, em alguns casos, marcas d'água para indicar o status do pagamento. O IronPDF suporta tanto imagens incorporadas em HTML quanto marcas d'água programáticas após a renderização.

using IronPdf;

var renderer = new ChromePdfRenderer();

// Invoice HTML template with company logo embedded via URL
// Logo can also be Base64-encoded or a local file path
string htmlWithLogo = @"
<!DOCTYPE html>
<html>
<head>
<style>
body { font-family: Arial, sans-serif; padding: 40px; }
.logo { width: 200px; margin-bottom: 20px; }
</style>
</head>
<body>
<div style='text-align: center;'>
<img src='https://yourcompany.com/logo.png' alt='Company Logo' class='logo' />
</div>
<h1>INVOICE</h1>
<p><strong>Invoice Number:</strong> INV-2024-001</p>
<p><strong>Total:</strong> $1,250.00</p>
</body>
</html>";

// Render the HTML to PDF
var pdf = renderer.RenderHtmlAsPdf(htmlWithLogo);

// Apply a diagonal "UNPAID" watermark to mark invoice status
// 30% opacity keeps the content readable while the watermark is visible
pdf.ApplyWatermark("<h1 style='color: red;'>UNPAID</h1>",
    opacity: 30,
    rotation: 45,
    verticalAlignment: IronPdf.Editing.VerticalAlignment.Middle);

pdf.SaveAs("invoice-with-watermark.pdf");

Exemplo de saída

O método ApplyWatermark aceita conteúdo HTML, dando a você controle total sobre a aparência da marca d'água. Você pode ajustar a opacidade, a rotação e o posicionamento para obter exatamente a aparência desejada. Isso é particularmente útil para marcar faturas como "PAGAS", "RASCUNHADAS" ou "CANCELADAS" sem precisar gerar novamente o documento inteiro.

As faturas modernas geralmente incluem códigos QR que os clientes podem escanear para efetuar pagamentos rapidamente. Embora o IronPDF seja focado na geração de PDFs, ele funciona perfeitamente com o IronQR para a criação de códigos de barras:

using IronPdf;
using IronQr;
using IronSoftware.Drawing;

string invoiceNumber = "INV-2026-002";
decimal amount = 1500.00m;

// Create a payment URL with invoice details as query parameters
string paymentUrl = $"https://yourcompany.com/pay?invoice={invoiceNumber}&amount={amount}";

// Generate QR code from the payment URL using IronQR
QrCode qrCode = QrWriter.Write(paymentUrl);
AnyBitmap qrImage = qrCode.Save();
qrImage.SaveAs("payment-qr.png", AnyBitmap.ImageFormat.Png);

// Build invoice HTML with the QR code image embedded
// Customers can scan the QR to pay directly from their phone
string invoiceHtml = $@"
<!DOCTYPE html>
<html>
<head>
<style>
body {{ font-family: Arial, sans-serif; padding: 40px; }}
.payment-section {{ margin-top: 40px; text-align: center;
                   border-top: 2px solid #eee; padding-top: 20px; }}
.qr-code {{ width: 150px; height: 150px; }}
</style>
</head>
<body>
<h1>INVOICE {invoiceNumber}</h1>
<p><strong>Amount Due:</strong> ${amount:F2}</p>

<div class='payment-section'>
<p><strong>Scan to Pay Instantly:</strong></p>
<img src='payment-qr.png' alt='Payment QR Code' class='qr-code' />
<p style='font-size: 12px; color: #666;'>
    Or visit: {paymentUrl}
</p>
</div>
</body>
</html>";

// Convert HTML to PDF and save
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(invoiceHtml);
pdf.SaveAs($"invoice-{invoiceNumber}.pdf");

Exemplo de saída

O código QR direciona diretamente para uma página de pagamento, reduzindo o atrito para os clientes e acelerando seu fluxo de caixa. Esse padrão funciona com qualquer provedor de pagamento que suporte iniciação de pagamento baseada em URL.

How to Comply with ZUGFeRD and Factur-X E-Invoicing Standards in C#

A faturação eletrónica está a tornar-se rapidamente obrigatória em toda a Europa. A Alemanha saiu na frente com o ZUGFeRD, e a França veio em seguida com o Factur-X. Esses padrões incorporam dados XML legíveis por máquina em faturas em PDF, permitindo o processamento automatizado e, ao mesmo tempo, mantendo a legibilidade dos documentos para humanos. Compreender e implementar essas normas é cada vez mais essencial para as empresas que operam nos mercados europeus.

O que é ZUGFeRD e como funciona?

ZUGFeRD (Zentraler User Guide des Forums elektronische Rechnung Deutschland) é um padrão alemão de faturamento eletrônico que incorpora dados de fatura como um anexo de arquivo XML em um documento compatível com PDF/A-3. O XML incorporado permite a extração automatizada de dados sem OCR ou análise sintática.

A norma define três níveis de conformidade, cada um oferecendo dados progressivamente mais estruturados:

  • Básico: Contém os dados essenciais da fatura, adequados para processamento automatizado simples.
  • Conforto: Adiciona informações detalhadas que permitem o processamento totalmente automatizado de faturas.
  • Ampliado: Inclui dados abrangentes para cenários de negócios complexos em diversos setores.

O XML segue o esquema de Fatura Intersetorial (CII) da UN/CEFACT, que se tornou a base para a padronização da faturação eletrónica na Europa.

O que é Factur-X e como ele difere do ZUGFeRD?

Factur-X é a implementação francesa da mesma norma subjacente. ZUGFeRD 2.0 e Factur-X são tecnicamente idênticos. Eles compartilham o mesmo esquema XML e perfis de conformidade baseados na norma europeia EN 16931. A diferença reside puramente na nomenclatura regional: uma fatura criada segundo as especificações ZUGFeRD será válida segundo o Factur-X, e vice-versa.

Como incorporar dados XML em faturas PDF/A-3

O IronPDF oferece os recursos de anexos necessários para criar faturas eletrônicas em conformidade com as normas. O processo envolve gerar o PDF da sua fatura, criar os dados XML de acordo com o esquema CII e incorporar o XML como um anexo com as convenções de nomenclatura corretas:

using System;
using System.Xml.Linq;

// Generates ZUGFeRD-compliant invoices by embedding structured XML data
// ZUGFeRD allows automated processing while keeping a human-readable PDF
public class ZUGFeRDInvoiceGenerator
{
    public void GenerateZUGFeRDInvoice(Invoice invoice)
    {
        // First, create the visual PDF that humans will read
        var renderer = new ChromePdfRenderer();
        string invoiceHtml = BuildInvoiceHtml(invoice);
        var pdf = renderer.RenderHtmlAsPdf(invoiceHtml);

        // Define the UN/CEFACT namespaces required by the ZUGFeRD standard
        // These are mandatory for compliance with European e-invoicing regulations
        XNamespace rsm = "urn:un:unece:uncefact:data:standard:CrossIndustryInvoice:100";
        XNamespace ram = "urn:un:unece:uncefact:data:standard:ReusableAggregateBusinessInformationEntity:100";
        XNamespace udt = "urn:un:unece:uncefact:data:standard:UnqualifiedDataType:100";

        // Build the ZUGFeRD XML structure following the Cross-Industry Invoice schema
        var zugferdXml = new XDocument(
            new XDeclaration("1.0", "UTF-8", null),
            new XElement(rsm + "CrossIndustryInvoice",
                new XAttribute(XNamespace.Xmlns + "rsm", rsm.NamespaceName),
                new XAttribute(XNamespace.Xmlns + "ram", ram.NamespaceName),
                new XAttribute(XNamespace.Xmlns + "udt", udt.NamespaceName),

                // Document context identifies which e-invoicing guideline is being followed
                new XElement(rsm + "ExchangedDocumentContext",
                    new XElement(ram + "GuidelineSpecifiedDocumentContextParameter",
                        new XElement(ram + "ID", "urn:cen.eu:en16931:2017")
                    )
                ),

                // Core document identification: invoice number, type, and date
                new XElement(rsm + "ExchangedDocument",
                    new XElement(ram + "ID", invoice.InvoiceNumber),
                    new XElement(ram + "TypeCode", "380"), // 380 = Commercial Invoice per UN/CEFACT
                    new XElement(ram + "IssueDateTime",
                        new XElement(udt + "DateTimeString",
                            new XAttribute("format", "102"),
                            invoice.InvoiceDate.ToString("yyyyMMdd")
                        )
                    )
                ),

                // A complete implementation would include additional sections:
                // - Seller information (ram:SellerTradeParty)
                // - Buyer information (ram:BuyerTradeParty)
                // - Line items (ram:IncludedSupplyChainTradeLineItem)
                // - Payment terms (ram:SpecifiedTradePaymentTerms)
                // - Tax summaries (ram:ApplicableTradeTax)

                // Financial summary with all monetary totals
                new XElement(rsm + "SupplyChainTradeTransaction",
                    new XElement(ram + "ApplicableHeaderTradeSettlement",
                        new XElement(ram + "InvoiceCurrencyCode", "EUR"),
                        new XElement(ram + "SpecifiedTradeSettlementHeaderMonetarySummation",
                            new XElement(ram + "TaxBasisTotalAmount", invoice.Subtotal),
                            new XElement(ram + "TaxTotalAmount",
                                new XAttribute("currencyID", "EUR"),
                                invoice.Tax),
                            new XElement(ram + "GrandTotalAmount", invoice.Total),
                            new XElement(ram + "DuePayableAmount", invoice.Total)
                        )
                    )
                )
            )
        );

        // Save the XML to a temp file for embedding
        string xmlPath = $"zugferd-{invoice.InvoiceNumber}.xml";
        zugferdXml.Save(xmlPath);

        // Attach the XML to the PDF - filename must follow ZUGFeRD conventions
        pdf.Attachments.AddFile(xmlPath, "zugferd-invoice.xml", "ZUGFeRD Invoice Data");

        // Final PDF contains both visual invoice and machine-readable XML
        pdf.SaveAs($"invoice-{invoice.InvoiceNumber}-zugferd.pdf");
    }

    // Generates simple HTML for the visual portion of the invoice
    private string BuildInvoiceHtml(Invoice invoice)
    {
        return $@"
<!DOCTYPE html>
<html>
<head>
    <style>
        body {{font-family: Arial, sans-serif; padding: 40px;}}
        h1 {{color: #333;}}
        .zugferd-notice {{margin-top: 30px; padding: 10px; 
            background: #f0f0f0; font-size: 11px;}}
    </style>
</head>
<body>
    <h1>RECHNUNG / INVOICE</h1>
    <p><strong>Rechnungsnummer:</strong> {invoice.InvoiceNumber}</p>
    <p><strong>Datum:</strong> {invoice.InvoiceDate:dd.MM.yyyy}</p>
    <p><strong>Betrag:</strong> €{invoice.Total:F2}</p>
    
    <div class='zugferd-notice'>
        This invoice contains embedded ZUGFeRD data for automated processing.
    </div>
</body>
</html>";
    }
}

Exemplo de saída

Os principais aspectos de conformidade são o uso dos namespaces XML corretos, o cumprimento da estrutura do esquema CII e a incorporação do XML com um nome de arquivo apropriado. O código de tipo "380" identifica especificamente o documento como uma fatura comercial de acordo com o padrão UN/CEFACT.

Como preparar as faturas para o futuro em relação aos mandatos da UE

A União Europeia está progressivamente a tornar obrigatória a faturação eletrónica em todos os Estados-Membros. A Itália já exige para transações B2B, a França está implementando os requisitos gradualmente até 2026 e a Alemanha anunciou a obrigatoriedade da faturação eletrónica B2B a partir de 2025. A implementação do suporte ao ZUGFeRD/Factur-X agora prepara o seu sistema para estes requisitos regulamentares.

Aqui está um modelo para um gerador de faturas compatível com normas que pode ser direcionado a diferentes padrões:

using IronPdf;
using System;

// Enum representing supported European e-invoicing standards
public enum InvoiceStandard
{
    None,
    ZUGFeRD,    // German standard - uses CII XML format
    FacturX,    // French standard - technically identical to ZUGFeRD 2.0
    Peppol      // Pan-European standard - uses UBL XML format
}

// Factory class that generates invoices compliant with different e-invoicing standards
// Allows switching between standards without changing core invoice generation logic
public class CompliantInvoiceGenerator
{
    public PdfDocument GenerateCompliantInvoice(Invoice invoice, InvoiceStandard standard)
    {
        // Generate the base PDF from HTML
        var renderer = new ChromePdfRenderer();
        string html = BuildInvoiceHtml(invoice);
        var pdf = renderer.RenderHtmlAsPdf(html);

        // Attach the appropriate XML format based on target market/regulation
        switch (standard)
        {
            case InvoiceStandard.ZUGFeRD:
            case InvoiceStandard.FacturX:
                // Both use Cross-Industry Invoice format, just different filenames
                EmbedCIIXmlData(pdf, invoice, standard);
                break;
            case InvoiceStandard.Peppol:
                // Peppol uses Universal Business Language format
                EmbedUBLXmlData(pdf, invoice);
                break;
        }

        return pdf;
    }

    // Creates and embeds CII-format XML (used by ZUGFeRD and Factur-X)
    private void EmbedCIIXmlData(PdfDocument pdf, Invoice invoice, InvoiceStandard standard)
    {
        string xml = GenerateCIIXml(invoice);

        // Filename convention differs between German and French standards
        string filename = standard == InvoiceStandard.ZUGFeRD
            ? "zugferd-invoice.xml"
            : "factur-x.xml";

        System.IO.File.WriteAllText("temp-invoice.xml", xml);
        pdf.Attachments.AddFile("temp-invoice.xml", filename, $"{standard} Invoice Data");
    }

    // Creates and embeds UBL-format XML for Peppol network compliance
    private void EmbedUBLXmlData(PdfDocument pdf, Invoice invoice)
    {
        // UBL (Universal Business Language) is the Peppol standard format
        string xml = $@"<?xml version='1.0' encoding='UTF-8'?>
<Invoice xmlns='urn:oasis:names:specification:ubl:schema:xsd:Invoice-2'>
    <id>{invoice.InvoiceNumber}</id>
    <IssueDate>{invoice.InvoiceDate:yyyy-MM-dd}</IssueDate>
    <DocumentCurrencyCode>EUR</DocumentCurrencyCode>
    <LegalMonetaryTotal>
        <PayableAmount currencyID='EUR'>{invoice.Total}</PayableAmount>
    </LegalMonetaryTotal>
</Invoice>";

        System.IO.File.WriteAllText("peppol-invoice.xml", xml);
        pdf.Attachments.AddFile("peppol-invoice.xml", "invoice.xml", "Peppol UBL Invoice");
    }

    // Generates minimal CII XML structure for demonstration
    private string GenerateCIIXml(Invoice invoice)
    {
        return $@"<?xml version='1.0' encoding='UTF-8'?>
<rsm:CrossIndustryInvoice
    xmlns:rsm='urn:un:unece:uncefact:data:standard:CrossIndustryInvoice:100'
    xmlns:ram='urn:un:unece:uncefact:data:standard:ReusableAggregateBusinessInformationEntity:100'>
    <rsm:ExchangedDocument>
        <ram:ID>{invoice.InvoiceNumber}</ram:ID>
        <ram:TypeCode>380</ram:TypeCode>
    </rsm:ExchangedDocument>
</rsm:CrossIndustryInvoice>";
    }

    private string BuildInvoiceHtml(Invoice invoice)
    {
        return $"<html><body><h1>Invoice {invoice.InvoiceNumber}</h1></body></html>";
    }
}

Essa arquitetura permite adicionar novos padrões à medida que surgem, sem reestruturar a lógica principal de geração de faturas. A abordagem baseada em enumeração facilita permitir que usuários ou configurações determinem qual modo de conformidade usar.

Minha biblioteca favorita desse tipo é o IronPDF. Ele permite a manipulação rápida e eficiente de arquivos PDF. Além disso, possui muitos recursos valiosos, como a exportação para o formato PDF/A e a assinatura digital de documentos PDF.

Milan Jovanovic

Microsoft MVP

Veja o estudo de caso

Com o IronOCR, podemos economizar US$ 40.000 por ano em processamento manual, ao mesmo tempo que aumentamos a produtividade e liberamos recursos para tarefas de alto impacto. Eu o recomendo fortemente.

Brent Matzelle

Diretor de Tecnologia, OPYN

Veja o estudo de caso

How to Extract Data from PDF Invoices in C#

Gerar faturas é apenas metade da equação. A maioria das empresas também recebe faturas de fornecedores e precisa extrair dados para processamento. O IronPDF oferece recursos avançados de extração de texto que formam a base da captura de dados de faturas.

Como extrair texto de uma fatura em PDF

A operação de extração mais fundamental recupera todo o conteúdo de texto de um PDF. O método ExtractAllText do IronPDF lida com a complexidade da codificação de texto e posicionamento do PDF:

using IronPdf;
using System;

// Extracts raw text content from PDF invoices for further processing
public class InvoiceTextExtractor
{
    // Extracts all text from a PDF in one operation
    // Best for single-page invoices or when you need the complete content
    public string ExtractInvoiceText(string pdfPath)
    {
        var pdf = PdfDocument.FromFile(pdfPath);

        // IronPDF handles the complexity of PDF text encoding and positioning
        string allText = pdf.ExtractAllText();
        Console.WriteLine("Full invoice text:");
        Console.WriteLine(allText);

        return allText;
    }

    // Extracts text page by page - useful for multi-page invoices
    // Allows you to process header info separately from line items
    public void ExtractTextByPage(string pdfPath)
    {
        var pdf = PdfDocument.FromFile(pdfPath);

        // Iterate through each page (0-indexed)
        for (int i = 0; i < pdf.PageCount; i++)
        {
            string pageText = pdf.ExtractTextFromPage(i);
            Console.WriteLine($"\n--- Page {i + 1} ---");
            Console.WriteLine(pageText);
        }
    }
}

A extração página por página é particularmente útil para faturas com várias páginas, onde é necessário localizar seções específicas, como encontrar itens que se estendem por várias páginas, enquanto as informações do cabeçalho aparecem apenas na primeira página.

Como extrair dados de tabela para itens de linha

Os itens da fatura geralmente aparecem em formato tabular. Os PDFs não possuem uma estrutura de tabela nativa, mas você pode extrair o texto e analisá-lo para reconstruir os dados da tabela:

using IronPdf;
using System;
using System.Collections.Generic;

// Data model for a single invoice line item
public class InvoiceLineItem
{
    public string Description { get; set; }
    public decimal Quantity { get; set; }
    public decimal UnitPrice { get; set; }
    public decimal Total { get; set; }
}

// Extracts tabular line item data from PDF invoices
// Note: PDFs don't have native table structure, so this uses text parsing
public class InvoiceTableExtractor
{
    public List<InvoiceLineItem> ExtractLineItems(string pdfPath)
    {
        var pdf = PdfDocument.FromFile(pdfPath);
        string text = pdf.ExtractAllText();

        var lineItems = new List<InvoiceLineItem>();
        string[] lines = text.Split('\n');

        foreach (string line in lines)
        {
            // Currency symbols indicate potential line items with amounts
            if (line.Contains("$") || line.Contains("€"))
            {
                Console.WriteLine($"Potential line item: {line.Trim()}");

                // Split on whitespace to separate columns
                // Actual parsing logic depends on your invoice format
                string[] parts = line.Split(new[] { '\t', ' ' },
                    StringSplitOptions.RemoveEmptyEntries);

                // Try to find numeric values that could be amounts
                foreach (string part in parts)
                {
                    string cleaned = part.Replace("$", "").Replace("€", "").Replace(",", "");
                    if (decimal.TryParse(cleaned, out decimal amount))
                    {
                        Console.WriteLine($"  Found amount: {amount:C}");
                    }
                }
            }
        }

        return lineItems;
    }
}

A lógica de análise varia de acordo com o formato da sua fatura. Para faturas com layouts consistentes de fornecedores conhecidos, você pode criar analisadores específicos para cada formato. Para formatos variados, considere a extração com inteligência artificial abordada mais adiante neste artigo.

Como usar a correspondência de padrões para números de faturas, datas e totais

Expressões regulares são ferramentas valiosas para extrair dados específicos do texto de faturas. Campos-chave como números de faturas, datas e totais geralmente seguem padrões reconhecíveis:

using IronPdf;
using System;
using System.Text.RegularExpressions;

// Data model for extracted invoice information
public class InvoiceData
{
    public string InvoiceNumber { get; set; }
    public string InvoiceDate { get; set; }
    public decimal TotalAmount { get; set; }
    public string VendorName { get; set; }
}

// Extracts key invoice fields using regex pattern matching
// Multiple patterns handle variations across different vendors
public class InvoiceParser
{
    public InvoiceData ParseInvoice(string pdfPath)
    {
        var pdf = PdfDocument.FromFile(pdfPath);
        string text = pdf.ExtractAllText();

        var invoiceData = new InvoiceData();

        // Try multiple patterns to find invoice number
        // Handles: "Invoice #123", "INV-123", "Invoice Number: 123", German "Rechnungsnummer"
        string[] invoiceNumberPatterns = new[]
        {
            @"Invoice\s*#?\s*:?\s*([A-Z0-9-]+)",
            @"INV[-\s]?(\d+)",
            @"Invoice\s+Number\s*:?\s*([A-Z0-9-]+)",
            @"Rechnungsnummer\s*:?\s*([A-Z0-9-]+)"
        };

        foreach (string pattern in invoiceNumberPatterns)
        {
            var match = Regex.Match(text, pattern, RegexOptions.IgnoreCase);
            if (match.Success)
            {
                invoiceData.InvoiceNumber = match.Groups[1].Value;
                Console.WriteLine($"Found Invoice Number: {invoiceData.InvoiceNumber}");
                break;
            }
        }

        // Date patterns for US, European, and written formats
        string[] datePatterns = new[]
        {
            @"Date\s*:?\s*(\d{1,2}[/-]\d{1,2}[/-]\d{2,4})",
            @"Invoice\s+Date\s*:?\s*(\d{1,2}[/-]\d{1,2}[/-]\d{2,4})",
            @"(\d{1,2}\.\d{1,2}\.\d{4})",  // European: DD.MM.YYYY
            @"(\w+\s+\d{1,2},?\s+\d{4})"   // Written: January 15, 2024
        };

        foreach (string pattern in datePatterns)
        {
            var match = Regex.Match(text, pattern, RegexOptions.IgnoreCase);
            if (match.Success)
            {
                invoiceData.InvoiceDate = match.Groups[1].Value;
                Console.WriteLine($"Found Date: {invoiceData.InvoiceDate}");
                break;
            }
        }

        // Look for total amount with various labels
        string[] totalPatterns = new[]
        {
            @"Total\s*:?\s*[\$€]?\s*([\d,]+\.\d{2})",
            @"Amount\s+Due\s*:?\s*[\$€]?\s*([\d,]+\.\d{2})",
            @"Grand\s+Total\s*:?\s*[\$€]?\s*([\d,]+\.\d{2})",
            @"Balance\s+Due\s*:?\s*[\$€]?\s*([\d,]+\.\d{2})"
        };

        foreach (string pattern in totalPatterns)
        {
            var match = Regex.Match(text, pattern, RegexOptions.IgnoreCase);
            if (match.Success)
            {
                // Remove commas before parsing
                string amountStr = match.Groups[1].Value.Replace(",", "");
                if (decimal.TryParse(amountStr, out decimal amount))
                {
                    invoiceData.TotalAmount = amount;
                    Console.WriteLine($"Found Total: ${invoiceData.TotalAmount:F2}");
                    break;
                }
            }
        }

        return invoiceData;
    }
}

Essa abordagem baseada em padrões funciona bem para faturas com formatos previsíveis. As múltiplas variações de padrão lidam com diferenças comuns de formatação entre fornecedores, como "Fatura #" e "Número da Fatura:"

E quanto às faturas digitalizadas ou baseadas em imagens?

Os métodos de extração de texto mostrados acima funcionam com PDFs que contêm texto incorporado. No entanto, documentos digitalizados e PDFs baseados em imagens não possuem texto extraível. São basicamente fotos de faturas.

Observe: Para processar faturas digitalizadas, você precisará de recursos de OCR (Reconhecimento Óptico de Caracteres). O IronOCR, parte do Iron Suite, integra-se perfeitamente ao IronPDF para esses cenários. Visite https://ironsoftware.com/csharp/ocr/ para saber mais sobre como extrair texto de documentos e imagens digitalizados.

Como usar IA para processar faturas em .NET

A correspondência de padrões tradicional funciona bem para faturas padronizadas, mas os departamentos de contas a pagar do mundo real recebem documentos em inúmeros formatos. É aqui que a extração com inteligência artificial se destaca. Grandes modelos de linguagem conseguem compreender a semântica das faturas e extrair dados estruturados mesmo de layouts desconhecidos.

Como integrar IA para análise de faturas

O modelo para processamento de faturas com inteligência artificial combina a extração de texto do IronPDF com chamadas à API LLM. Aqui está uma implementação genérica que funciona com qualquer API compatível com OpenAI:

using IronPdf;
using System;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

// Data model for extracted invoice information
public class InvoiceData
{
    public string InvoiceNumber { get; set; }
    public string InvoiceDate { get; set; }
    public string VendorName { get; set; }
    public decimal TotalAmount { get; set; }
}

// Leverages AI/LLM APIs to extract structured data from any invoice format
// Works with OpenAI or any compatible API endpoint
public class AIInvoiceParser
{
    private readonly HttpClient _httpClient;
    private readonly string _apiKey;
    private readonly string _apiUrl;

    public AIInvoiceParser(string apiKey, string apiUrl = "https://api.openai.com/v1/chat/completions")
    {
        _apiKey = apiKey;
        _apiUrl = apiUrl;
        _httpClient = new HttpClient();
        _httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {_apiKey}");
    }

    public async Task<InvoiceData> ParseInvoiceWithAI(string pdfPath)
    {
        // First extract raw text from the PDF using IronPDF
        var pdf = PdfDocument.FromFile(pdfPath);
        string invoiceText = pdf.ExtractAllText();

        // Construct a prompt that instructs the AI to return structured JSON
        // Being explicit about the format reduces parsing errors
        string prompt = $@"Extract the following information from this invoice text.
Return ONLY valid JSON with no additional text or markdown formatting.

Required fields:
- InvoiceNumber: The invoice or document number
- InvoiceDate: The invoice date in YYYY-MM-DD format
- VendorName: The company or person who sent the invoice
- TotalAmount: The total amount due as a number (no currency symbols)

Invoice text:
{invoiceText}

JSON response:";

        // Build the API request with a system prompt for context
        var requestBody = new
        {
            model = "gpt-4",
            messages = new[]
            {
                new {
                    role = "system",
                    content = "You are an invoice data extraction assistant. Extract structured data from invoices and return valid JSON only."
                },
                new { role = "user", content = prompt }
            },
            temperature = 0.1  // Low temperature ensures consistent, deterministic results
        };

        var json = JsonSerializer.Serialize(requestBody);
        var content = new StringContent(json, Encoding.UTF8, "application/json");

        var response = await _httpClient.PostAsync(_apiUrl, content);
        var responseJson = await response.Content.ReadAsStringAsync();

        // Navigate the API response structure to get the extracted content
        using var doc = JsonDocument.Parse(responseJson);
        var messageContent = doc.RootElement
            .GetProperty("choices")[0]
            .GetProperty("message")
            .GetProperty("content")
            .GetString();

        Console.WriteLine("AI Extracted Data:");
        Console.WriteLine(messageContent);

        // Deserialize the AI's JSON response into our data class
        var invoiceData = JsonSerializer.Deserialize<InvoiceData>(messageContent,
            new JsonSerializerOptions { PropertyNameCaseInsensitive = true });

        return invoiceData;
    }
}

A configuração de baixa temperatura (0,1) favorece resultados determinísticos, o que é importante para tarefas de extração de dados em que se deseja resultados consistentes para a mesma entrada.

Como extrair dados JSON estruturados de faturas

Para faturas mais complexas com itens de linha, detalhes do fornecedor e informações do cliente, você pode solicitar uma estrutura JSON mais rica:

using IronPdf;
using System;
using System.Collections.Generic;
using System.Text.Json;
using System.Threading.Tasks;

// Comprehensive invoice data model with all details
public class DetailedInvoiceData
{
    public string InvoiceNumber { get; set; }
    public DateTime InvoiceDate { get; set; }
    public DateTime DueDate { get; set; }
    public VendorInfo Vendor { get; set; }
    public CustomerInfo Customer { get; set; }
    public List<LineItem> LineItems { get; set; }
    public decimal Subtotal { get; set; }
    public decimal Tax { get; set; }
    public decimal Total { get; set; }
}

public class VendorInfo
{
    public string Name { get; set; }
    public string Address { get; set; }
    public string TaxId { get; set; }
}

public class CustomerInfo
{
    public string Name { get; set; }
    public string Address { get; set; }
}

public class LineItem
{
    public string Description { get; set; }
    public decimal Quantity { get; set; }
    public decimal UnitPrice { get; set; }
    public decimal Total { get; set; }
}

// Extracts comprehensive invoice data including line items and party details
public class StructuredInvoiceExtractor
{
    private readonly AIInvoiceParser _aiParser;

    public StructuredInvoiceExtractor(string apiKey)
    {
        _aiParser = new AIInvoiceParser(apiKey);
    }

    public async Task<DetailedInvoiceData> ExtractDetailedData(string pdfPath)
    {
        var pdf = PdfDocument.FromFile(pdfPath);
        string text = pdf.ExtractAllText();

        // Define the exact JSON structure we want the AI to return
        // This schema guides the AI to extract all relevant fields
        string jsonSchema = @"{
  ""InvoiceNumber"": ""string"",
  ""InvoiceDate"": ""YYYY-MM-DD"",
  ""DueDate"": ""YYYY-MM-DD"",
  ""Vendor"": {
    ""Name"": ""string"",
    ""Address"": ""string"",
    ""TaxId"": ""string or null""
  },
  ""Customer"": {
    ""Name"": ""string"",
    ""Address"": ""string""
  },
  ""LineItems"": [
    {
      ""Description"": ""string"",
      ""Quantity"": 0.0,
      ""UnitPrice"": 0.00,
      ""Total"": 0.00
    }
  ],
  ""Subtotal"": 0.00,
  ""Tax"": 0.00,
  ""Total"": 0.00
}";

        // Prompt includes both the schema and the extracted text
        string prompt = $@"Extract all invoice data and return it in this exact JSON structure:
{jsonSchema}

Invoice text:
{text}

Return only valid JSON, no markdown formatting or additional text.";

        // Call AI API and parse response (implementation as shown above)
        // Return deserialized DetailedInvoiceData

        return new DetailedInvoiceData(); // Placeholder
    }
}

Como lidar com formatos de faturas inconsistentes

O verdadeiro poder da extração por IA surge ao processar faturas de vários fornecedores, cada um com formatos únicos. Um processador inteligente pode tentar primeiro a extração baseada em padrões (mais rápida e gratuita) e recorrer à IA somente quando necessário:

using IronPdf;
using System.Threading.Tasks;

// Hybrid processor that optimizes for cost and capability
// Tries fast regex patterns first, uses AI only when patterns fail
public class SmartInvoiceProcessor
{
    private readonly AIInvoiceParser _aiParser;

    public SmartInvoiceProcessor(string aiApiKey)
    {
        _aiParser = new AIInvoiceParser(aiApiKey);
    }

    public async Task<InvoiceData> ProcessAnyInvoice(string pdfPath)
    {
        var pdf = PdfDocument.FromFile(pdfPath);
        string text = pdf.ExtractAllText();

        // First attempt: regex patterns (fast and free)
        var patternParser = new InvoiceParser();
        var standardResult = patternParser.ParseInvoiceFromText(text);

        // If pattern matching found all required fields, use that result
        if (IsComplete(standardResult))
        {
            Console.WriteLine("Pattern extraction successful");
            return standardResult;
        }

        // Fallback: use AI for complex or unusual invoice formats
        // This costs money but handles any layout
        Console.WriteLine("Using AI extraction for complex invoice format");
        var aiResult = await _aiParser.ParseInvoiceWithAI(pdfPath);

        return aiResult;
    }

    // Validates that we have the minimum required fields
    private bool IsComplete(InvoiceData data)
    {
        return !string.IsNullOrEmpty(data.InvoiceNumber) &&
               !string.IsNullOrEmpty(data.InvoiceDate) &&
               data.TotalAmount > 0;
    }
}

Como criar um pipeline de automação de contas a pagar

Reunindo todas essas peças, aqui está um fluxo de automação completo que processa faturas recebidas, extrai dados, valida-os e os prepara para o seu sistema de contabilidade:

using IronPdf;
using System;
using System.IO;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Linq;

// Tracks the outcome of processing each invoice
public class ProcessingResult
{
    public string FileName { get; set; }
    public bool Success { get; set; }
    public string InvoiceNumber { get; set; }
    public string ErrorMessage { get; set; }
}

// Complete automation pipeline for accounts payable
// Watches a folder, extracts data, validates, and routes to accounting system
public class InvoiceAutomationPipeline
{
    private readonly SmartInvoiceProcessor _processor;
    private readonly string _inputFolder;
    private readonly string _processedFolder;
    private readonly string _errorFolder;

    public InvoiceAutomationPipeline(string apiKey, string inputFolder)
    {
        _processor = new SmartInvoiceProcessor(apiKey);
        _inputFolder = inputFolder;
        _processedFolder = Path.Combine(inputFolder, "processed");
        _errorFolder = Path.Combine(inputFolder, "errors");

        // Create output directories if they don't exist
        Directory.CreateDirectory(_processedFolder);
        Directory.CreateDirectory(_errorFolder);
    }

    // Main entry point - processes all PDFs in the input folder
    public async Task<List<ProcessingResult>> ProcessInvoiceBatch()
    {
        string[] invoiceFiles = Directory.GetFiles(_inputFolder, "*.pdf");
        Console.WriteLine($"Found {invoiceFiles.Length} invoices to process");

        var results = new List<ProcessingResult>();

        foreach (string invoicePath in invoiceFiles)
        {
            string fileName = Path.GetFileName(invoicePath);

            try
            {
                Console.WriteLine($"Processing: {fileName}");

                // Extract data using smart processor (patterns first, then AI)
                var invoiceData = await _processor.ProcessAnyInvoice(invoicePath);

                // Ensure we have minimum required fields before proceeding
                if (ValidateInvoiceData(invoiceData))
                {
                    // Send to accounting system (QuickBooks, Xero, etc.)
                    await SaveToAccountingSystem(invoiceData);

                    // Archive successful invoices
                    string destPath = Path.Combine(_processedFolder, fileName);
                    File.Move(invoicePath, destPath, overwrite: true);

                    results.Add(new ProcessingResult
                    {
                        FileName = fileName,
                        Success = true,
                        InvoiceNumber = invoiceData.InvoiceNumber
                    });

                    Console.WriteLine($"✓ Processed: {invoiceData.InvoiceNumber}");
                }
                else
                {
                    throw new Exception("Validation failed - missing required fields");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"✗ Failed: {fileName} - {ex.Message}");

                // Quarantine failed invoices for manual review
                string destPath = Path.Combine(_errorFolder, fileName);
                File.Move(invoicePath, destPath, overwrite: true);

                results.Add(new ProcessingResult
                {
                    FileName = fileName,
                    Success = false,
                    ErrorMessage = ex.Message
                });
            }
        }

        GenerateReport(results);
        return results;
    }

    // Checks for minimum required fields
    private bool ValidateInvoiceData(InvoiceData data)
    {
        return !string.IsNullOrEmpty(data.InvoiceNumber) &&
               !string.IsNullOrEmpty(data.VendorName) &&
               data.TotalAmount > 0;
    }

    // Placeholder for accounting system integration
    private async Task SaveToAccountingSystem(InvoiceData data)
    {
        // Integrate with your accounting system here
        // Examples: QuickBooks API, Xero API, SAP, or database storage
        Console.WriteLine($"  Saved invoice {data.InvoiceNumber} to accounting system");
        await Task.CompletedTask;
    }

    // Outputs a summary of the batch processing results
    private void GenerateReport(List<ProcessingResult> results)
    {
        int successful = results.Count(r => r.Success);
        int failed = results.Count(r => !r.Success);

        Console.WriteLine($"\n========== Processing Complete ==========");
        Console.WriteLine($"Total Processed: {results.Count}");
        Console.WriteLine($"Successful: {successful}");
        Console.WriteLine($"Failed: {failed}");

        if (failed > 0)
        {
            Console.WriteLine("\nFailed invoices requiring review:");
            foreach (var failure in results.Where(r => !r.Success))
            {
                Console.WriteLine($"  • {failure.FileName}: {failure.ErrorMessage}");
            }
        }
    }
}

Este pipeline implementa um fluxo de trabalho completo: ele escaneia uma pasta em busca de PDFs, processa cada um deles, valida os dados extraídos, encaminha as extrações bem-sucedidas para o seu sistema de contabilidade e coloca as falhas em quarentena para revisão manual. O relatório resumido oferece visibilidade dos resultados do processamento.

How to Integrate C# Invoice Processing with Accounting Systems

Os dados extraídos das faturas precisam, em última instância, ser inseridos nos sistemas de contabilidade para fins de pagamento e registro. Os detalhes variam conforme a plataforma, mas os padrões de integração são consistentes.

Quais são os padrões de integração comuns para QuickBooks, Xero e SAP?

A maioria das plataformas de contabilidade oferece APIs REST para a criação programática de faturas ou notas fiscais. Aqui está um padrão geral que você pode adaptar para sua plataforma específica:

using System;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

// Generic integration layer for pushing invoice data to accounting systems
// Adapt the API calls based on your specific platform
public class AccountingSystemIntegration
{
    private readonly HttpClient _httpClient;
    private readonly string _apiKey;
    private readonly string _baseUrl;

    public AccountingSystemIntegration(string apiKey, string baseUrl)
    {
        _apiKey = apiKey;
        _baseUrl = baseUrl;
        _httpClient = new HttpClient();
        _httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {_apiKey}");
    }

    // Creates a Bill in QuickBooks (vendor invoices are called "Bills")
    public async Task SendToQuickBooks(InvoiceData invoice)
    {
        // QuickBooks Bill structure - see their API docs for full schema
        var bill = new
        {
            VendorRef = new { name = invoice.VendorName },
            TxnDate = invoice.InvoiceDate,
            DocNumber = invoice.InvoiceNumber,
            TotalAmt = invoice.TotalAmount,
            Line = new[]
            {
                new
                {
                    Amount = invoice.TotalAmount,
                    DetailType = "AccountBasedExpenseLineDetail",
                    AccountBasedExpenseLineDetail = new
                    {
                        AccountRef = new { name = "Accounts Payable" }
                    }
                }
            }
        };

        await PostToApi("/v3/company/{companyId}/bill", bill);
    }

    // Creates an accounts payable invoice in Xero
    public async Task SendToXero(InvoiceData invoice)
    {
        // ACCPAY type indicates this is a bill to pay (not a sales invoice)
        var bill = new
        {
            Type = "ACCPAY",
            Contact = new { Name = invoice.VendorName },
            Date = invoice.InvoiceDate,
            InvoiceNumber = invoice.InvoiceNumber,
            Total = invoice.TotalAmount
        };

        await PostToApi("/api.xro/2.0/Invoices", bill);
    }

    // Generic POST helper with error handling
    private async Task PostToApi(string endpoint, object payload)
    {
        string json = JsonSerializer.Serialize(payload);
        var content = new StringContent(json, Encoding.UTF8, "application/json");

        var response = await _httpClient.PostAsync($"{_baseUrl}{endpoint}", content);

        if (!response.IsSuccessStatusCode)
        {
            string error = await response.Content.ReadAsStringAsync();
            throw new Exception($"API Error: {response.StatusCode} - {error}");
        }

        Console.WriteLine($"Successfully posted to {endpoint}");
    }
}

Cada plataforma possui seu próprio mecanismo de autenticação (OAuth para QuickBooks e Xero, vários métodos para SAP), campos obrigatórios e convenções de API. Consulte a documentação da plataforma escolhida para obter detalhes específicos, mas o padrão de transformação dos dados extraídos da fatura em payloads de API permanece o mesmo.

Como processar centenas de faturas em lote

O processamento de um grande volume de faturas exige atenção cuidadosa à simultaneidade e à gestão de recursos. Eis um padrão que utiliza processamento paralelo com concorrência controlada:

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

// Tracks the result of processing a single invoice in a batch
public class BatchResult
{
    public string FilePath { get; set; }
    public bool Success { get; set; }
    public string InvoiceNumber { get; set; }
    public string Error { get; set; }
}

// High-volume invoice processor with controlled parallelism
// Prevents overwhelming APIs while maximizing throughput
public class BatchInvoiceProcessor
{
    private readonly SmartInvoiceProcessor _invoiceProcessor;
    private readonly AccountingSystemIntegration _accountingIntegration;
    private readonly int _maxConcurrency;

    public BatchInvoiceProcessor(string aiApiKey, string accountingApiKey,
        string accountingUrl, int maxConcurrency = 5)
    {
        _invoiceProcessor = new SmartInvoiceProcessor(aiApiKey);
        _accountingIntegration = new AccountingSystemIntegration(accountingApiKey, accountingUrl);
        _maxConcurrency = maxConcurrency;  // Adjust based on API rate limits
    }

    // Processes multiple invoices in parallel with controlled concurrency
    public async Task<List<BatchResult>> ProcessInvoiceBatch(List<string> invoicePaths)
    {
        // Thread-safe collection for gathering results from parallel tasks
        var results = new ConcurrentBag<BatchResult>();

        // Semaphore limits how many invoices process simultaneously
        var semaphore = new SemaphoreSlim(_maxConcurrency);

        // Create a task for each invoice
        var tasks = invoicePaths.Select(async path =>
        {
            // Wait for a slot to become available
            await semaphore.WaitAsync();
            try
            {
                var result = await ProcessSingleInvoice(path);
                results.Add(result);
            }
            finally
            {
                // Release slot for next invoice
                semaphore.Release();
            }
        });

        // Wait for all invoices to complete
        await Task.WhenAll(tasks);

        // Output summary statistics
        var resultList = results.ToList();
        int successful = resultList.Count(r => r.Success);
        int failed = resultList.Count(r => !r.Success);

        Console.WriteLine($"\nBatch Processing Complete:");
        Console.WriteLine($"  Total: {resultList.Count}");
        Console.WriteLine($"  Successful: {successful}");
        Console.WriteLine($"  Failed: {failed}");

        return resultList;
    }

    // Processes one invoice: extract data and send to accounting system
    private async Task<BatchResult> ProcessSingleInvoice(string pdfPath)
    {
        try
        {
            Console.WriteLine($"Processing: {pdfPath}");

            var invoiceData = await _invoiceProcessor.ProcessAnyInvoice(pdfPath);
            await _accountingIntegration.SendToQuickBooks(invoiceData);

            Console.WriteLine($"✓ Completed: {invoiceData.InvoiceNumber}");

            return new BatchResult
            {
                FilePath = pdfPath,
                Success = true,
                InvoiceNumber = invoiceData.InvoiceNumber
            };
        }
        catch (Exception ex)
        {
            Console.WriteLine($"✗ Failed: {pdfPath}");

            return new BatchResult
            {
                FilePath = pdfPath,
                Success = false,
                Error = ex.Message
            };
        }
    }
}

O SemaphoreSlim garante que você não sobrecarregue APIs externas ou esgote os recursos do sistema. Ajuste _maxConcurrency com base nos limites de taxa de sua API e capacidade do servidor. O ConcurrentBag coleta com segurança os resultados das operações paralelas.

Próximos passos

A automatização da faturação representa uma oportunidade significativa para reduzir o trabalho manual, minimizar erros e acelerar os processos de negócio. Este guia apresentou todo o ciclo de vida: geração de faturas profissionais a partir de modelos HTML , conformidade com os padrões de faturamento eletrônico ZUGFeRD e Factur-X , extração de dados de faturas recebidas usando correspondência de padrões e processamento com inteligência artificial , e construção de fluxos de automação escaláveis.

O IronPDF serve como base para essas funcionalidades, fornecendo renderização robusta de HTML para PDF, extração de texto confiável e os recursos de anexos necessários para a conformidade com a faturação eletrónica em PDF/A-3 . Seu mecanismo de renderização baseado no Chrome garante que suas faturas tenham a aparência exata que foram projetadas, enquanto seus métodos de extração lidam automaticamente com a complexidade da codificação de texto em PDF.

Os padrões mostrados aqui são pontos de partida. As implementações reais precisarão de adaptações para seus formatos de fatura, sistemas de contabilidade e regras de negócio específicos. Para cenários de alto volume, o tutorial de processamento em lote aborda a execução paralela com concorrência controlada e recuperação de erros.

Pronto para começar a construir? Baixe o IronPDF e experimente com um teste gratuito. A biblioteca inclui uma licença de desenvolvimento gratuita, para que você possa avaliar completamente os recursos de geração de faturas, extração de dados e relatórios em PDF antes de adquirir uma licença de produção. Se você tiver dúvidas sobre automação de faturas ou integração com sistemas de contabilidade, entre em contato com nossa equipe de suporte técnico .

Perguntas frequentes

Para que serve o IronPDF no processamento de faturas em C#?

O IronPDF é usado no processamento de faturas em C# para gerar faturas em PDF profissionais, extrair dados estruturados e automatizar fluxos de trabalho de faturas, garantindo a conformidade com padrões como ZUGFeRD e Factur-X.

Como posso gerar uma fatura em PDF usando o IronPDF em C#?

Você pode gerar uma fatura em PDF usando o IronPDF em C# aproveitando sua API para criar e personalizar documentos PDF programaticamente. Isso inclui adicionar elementos como texto, tabelas e imagens que compõem uma fatura.

O que são ZUGFeRD e Factur-X, e como o IronPDF os suporta?

ZUGFeRD e Factur-X são padrões de faturamento eletrônico que garantem que as faturas sejam legíveis tanto por humanos quanto por máquinas. O IronPDF oferece suporte a esses padrões, permitindo que você gere faturas em PDF que estejam em conformidade com essas especificações.

Como o IronPDF pode ajudar na automatização dos processos de contas a pagar?

O IronPDF pode automatizar os processos de contas a pagar, extraindo dados estruturados de faturas e integrando-se a fluxos de automação, reduzindo a entrada manual de dados e aumentando a eficiência.

O IronPDF consegue extrair dados de faturas em PDF já existentes?

Sim, o IronPDF consegue extrair dados estruturados de faturas em PDF existentes, facilitando o processamento e a análise automática das informações da fatura.

Quais são os benefícios de usar o IronPDF para processamento de faturas em C#?

As vantagens de usar o IronPDF para processamento de faturas em C# incluem geração simplificada de faturas, conformidade com padrões internacionais de faturamento, extração eficiente de dados e recursos aprimorados de automação.

É possível personalizar a aparência de uma fatura em PDF com o IronPDF?

Sim, o IronPDF permite personalizar a aparência de uma fatura em PDF adicionando diversos elementos de design, como logotipos, formatação de texto e ajustes de layout para atender aos requisitos de identidade visual da marca.

Quais são os passos típicos para automatizar o processamento de faturas usando o IronPDF?

Para automatizar o processamento de faturas usando o IronPDF, normalmente você gera a fatura, extrai os dados necessários e integra-se a outros sistemas ou ferramentas de automação para otimizar os fluxos de trabalho.

Como o IronPDF lida com diferentes formatos de fatura?

O IronPDF consegue lidar com diversos formatos de faturas, fornecendo ferramentas para gerar, manipular e ler documentos PDF, garantindo a compatibilidade com os padrões comuns de faturamento eletrônico.

What is a recommended technology stack for invoice processing in .NET?

A recommended technology stack for invoice processing in .NET includes IronPDF for PDF manipulation, IronQR for embedding QR codes, and integration with AI models for advanced data parsing.

Curtis Chau
Curtis Chau
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.

...
Leia mais

Pronto para começar?

Nuget Downloads 21,253,952Versão:2026.10recém-lançado

Download gratuito do NuGet
Total de downloads: 21,253,952
Obtenha sua chave de avaliação gratuita de 30 dias instantaneamente.
Não é necessário cartão de crédito nem criação de conta.
Biblioteca NuGet C# para PDF
Instalar com NuGet

Versão: 2026.10

PM > Install-Package IronPdf
nuget.org/packages/IronPdf/
  1. No Solution Explorer, clique com o botão direito do mouse em Referências e selecione Gerenciar Pacotes NuGet.
  2. Selecione Procurar e pesquise "IronPDF".
  3. Selecione o pacote e instale.
DLL de PDF em C#
Baixar DLL

Versão: 2026.10

ou faça o download do Windows Installer aqui .

  1. Baixe e descompacte o IronPDF em um local como ~/Libs dentro do diretório da sua solução.
  2. No Solution Explorer do Visual Studio, clique com o botão direito do mouse em Referências. Selecione Procurar e digite "IronPDF.dll".

Licenças a partir de US$ 999

Key in blue circle

Obtenha sua chave de avaliação gratuita de 30 dias instantaneamente.

Your trial license will be sent to your email address

Sem limitações. 100% desbloqueado. Sem cartão de crédito.

bullet_checkedNão é necessário cartão de crédito nem criação de conta.Sem limitações. 100% desbloqueado. Sem cartão de crédito.
  • Logo Aetna
  • Logo NASA
  • Logo GE
  • Logo Porsche
  • Logo USDA
  • Logo Qatar
Join Millions of Engineers who’ve tried IronPDF
Agende sua demonstração ao vivo gratuita.
Booking Badge

Aprovado por milhões de engenheiros em todo o mundo.

Logotipos dos clientes da Iron Software
Agende sua consulta sem compromisso.
Os seus dados serão sempre mantidos em sigilo.
  • Logo Aetna
  • Logo NASA
  • Logo GE
  • Logo Porsche
  • Logo USDA
  • Logo Qatar
Aprovado por milhões de engenheiros em todo o mundo.
Obtenha sua chave de avaliação gratuita de 30 dias instantaneamente.
Não é necessário cartão de crédito nem criação de conta.
Biblioteca NuGet C# para PDF
Instalar com NuGet

Versão: 2026.10

PM > Install-Package IronPdf
nuget.org/packages/IronPdf/
  1. No Solution Explorer, clique com o botão direito do mouse em Referências e selecione Gerenciar Pacotes NuGet.
  2. Selecione Procurar e pesquise "IronPDF".
  3. Selecione o pacote e instale.
DLL de PDF em C#
Baixar DLL

Versão: 2026.10

ou faça o download do Windows Installer aqui .

  1. Baixe e descompacte o IronPDF em um local como ~/Libs dentro do diretório da sua solução.
  2. No Solution Explorer do Visual Studio, clique com o botão direito do mouse em Referências. Selecione Procurar e digite "IronPDF.dll".

Licenças a partir de US$ 999