IRONSOFTWAREHOME
IRONSUITEAll 10 for the Prices of 2
IMAGING & RECOGNITION
CONTACT SALES
BY COMPANY

PDF Redaction in C#: Remove Sensitive Data and Sanitize Documents with IronPDF

Curtis Chau
Curtis Chau
Updated: June 4, 2026

PDF redaction in C# .NET with IronPDF permanently removes sensitive content from a document's internal structure, not just visually covering it, so that no amount of copying, searching, or forensic analysis can recover the original data. This goes well beyond black rectangles over text: IronPDF provides text redaction with regex pattern matching, region-based redaction for signatures and images, metadata stripping, document sanitization to eliminate embedded scripts, and vulnerability scanning, giving .NET developers a complete toolkit for HIPAA, GDPR, and PCI DSS compliant document protection workflows.

TL;DR: Quickstart Guide

This tutorial covers permanently removing sensitive content from PDF documents in C# .NET, including text patterns, image regions, metadata, and embedded scripts.

  • Who this is for: .NET developers handling sensitive documents in healthcare, legal, financial, or government contexts.
  • What you'll build: Text redaction with regex pattern matching (SSNs, credit cards, emails), coordinate-based region redaction for signatures and photos, metadata cleanup, PDF sanitization to strip embedded scripts, and YARA-based vulnerability scanning.
  • Where it runs: .NET 10, .NET 8 LTS, .NET Framework 4.6.2+, and .NET Standard 2.0. All operations run locally with no external dependencies.
  • When to use this approach: When you need to share documents for legal discovery, FOIA requests, or external distribution while ensuring removed content is truly gone.
  • Why it matters technically: Visual overlays leave the original text recoverable in the PDF's content streams. IronPDF's redaction deletes character data from the document structure itself, making recovery impossible.

Redact sensitive text from a PDF with just a few lines of code:

  1. 1Install IronPDF with NuGet Package Manager

    PM > Install-Package IronPdf

  2. 2Copy and run this code snippet.

    using IronPdf;

PdfDocument pdf = PdfDocument.FromFile("confidential-report.pdf");
pdf.RedactTextOnAllPages("CONFIDENTIAL");
pdf.SaveAs("redacted-report.pdf");
    C#

  3. 3Deploy to test on your live environment

    Start using IronPDF in your project today with a free trial
    arrow pointer

After you've purchased or signed up for a 30-day trial of IronPDF, add your license key at the start of your application.

IronPdf.License.LicenseKey = "KEY";

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

First Step:
arrow pointer
NuGetInstall with 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.
Table of Contents

What is the Difference Between True Redaction and Visual Overlay?

Understanding the distinction between true redaction and visual overlay is critical for anyone handling sensitive documents. Many tools and manual methods create the appearance of redaction without actually removing the underlying data. This false sense of security has caused numerous high-profile data breaches and compliance failures.

Visual overlay approaches typically draw opaque shapes over sensitive content. The text remains fully intact within the PDF structure. Someone viewing the document sees a black rectangle, but the original characters still exist in the file's content streams. Selecting all text on the page, using accessibility tools, or examining the raw PDF data will reveal everything that was supposedly hidden. Court cases have been compromised when redacted filings were trivially unredacted by opposing counsel. Government agencies have accidentally released classified information that appeared censored but was completely recoverable.

True redaction works differently. When you use IronPDF's redaction methods, the library locates the specified text within the PDF's internal structure and removes it entirely. The character data is deleted from content streams. The visual representation is replaced with a redaction mark, typically a black rectangle, but the original content no longer exists anywhere in the file. No amount of selection, copying, or forensic analysis can recover what has been permanently erased.

IronPDF implements true redaction by modifying the PDF at a structural level. The RedactTextOnAllPages method and its variants search through page content, identify matching text, remove it from the document object model, and optionally draw a visual indicator where the content used to appear. This approach aligns with guidelines from organizations like NIST for secure document redaction.

The practical implications are significant. If you need to share documents externally, submit files for legal discovery, publish records under freedom of information requests, or distribute reports while protecting personally identifiable information, only true redaction provides adequate protection. Visual overlays might suffice for internal drafts where you simply want to draw attention away from certain sections, but they should never be trusted for actual data protection. For additional document security measures, see our guides on encrypting PDFs and digital signatures.

How do I Redact PDF Text in C# Across an Entire Document?

The most common redaction scenario involves removing all instances of specific text throughout a document. Perhaps you need to eliminate a person's name from a report, remove account numbers from financial statements, or strip internal reference codes before external distribution. IronPDF makes this straightforward with the RedactTextOnAllPages method.

Input

An employee records document containing personal information including names, Social Security numbers, and employee IDs.

using IronPdf;

// Load the source document
PdfDocument pdf = PdfDocument.FromFile("employee-records.pdf");

// Redact an employee name from the entire document
pdf.RedactTextOnAllPages("John Smith");

// Redact a Social Security Number
pdf.RedactTextOnAllPages("123-45-6789");

// Redact an internal employee ID
pdf.RedactTextOnAllPages("EMP-2024-0042");

// Save the cleaned document
pdf.SaveAs("employee-records-redacted.pdf");

This code loads a PDF containing employee information and removes three pieces of confidential data by calling RedactTextOnAllPages for each value. Each call searches through every page in the document and permanently removes all matching instances of the employee's name, Social Security number, and internal identifier.

Sample Output

The default behavior draws black rectangles where the redacted text appeared and replaces the actual characters with asterisks in the document structure. This provides both visual confirmation that redaction occurred and ensures the original content is completely gone.

When working with longer documents or multiple redaction targets, you can chain these calls efficiently:

using IronPdf;
using System.Collections.Generic;

// Load the document once
PdfDocument pdf = PdfDocument.FromFile("quarterly-report.pdf");

// Define all terms that need redaction
List<string> sensitiveTerms = new List<string>
{
    "Project Titan",
    "Sarah Johnson",
    "Budget: $4.2M",
    "Q3-INTERNAL-2024",
    "sarah.johnson@company.com"
};

// Redact each term
foreach (string term in sensitiveTerms)
{
    pdf.RedactTextOnAllPages(term);
}

// Save the result
pdf.SaveAs("quarterly-report-public.pdf");

This pattern works well when you have a known list of sensitive values to remove. The document is loaded once, all redactions are applied in memory, and the final result is saved. Each term is processed independently, so partial matches or formatting differences between terms do not affect other redactions.

How can I Redact Text on Specific Pages Only?

Sometimes you need more precise control over where redactions occur. A document might have a cover page with information that should remain intact, or you might know that confidential data only appears in certain sections. IronPDF offers RedactTextOnPage for single page redaction and RedactTextOnPages for targeting multiple specific pages.

Input

A multi-page contract bundle with client names on the signature page and financial terms appearing on specific pages throughout the document.

using IronPdf;

// Load the document
PdfDocument pdf = PdfDocument.FromFile("contract-bundle.pdf");

// Redact text only on page 1 (index 0)
pdf.RedactTextOnPage(0, "Client Name: Acme Corporation");

// Redact text on pages 3, 5, and 7 (indices 2, 4, 6)
int[] financialPages = { 2, 4, 6 };
pdf.RedactTextOnPages(financialPages, "Payment Terms: Net 30");

// Other pages remain untouched except for the specific redactions applied

pdf.SaveAs("contract-bundle-redacted.pdf");

This code demonstrates targeted redaction by using RedactTextOnPage for a single page and RedactTextOnPages for multiple specific pages. The client name is removed only from page 1 (index 0), while payment terms are redacted from pages 3, 5, and 7 (indices 2, 4, 6), leaving all other pages untouched.

Sample Output

Page indices in IronPDF are zero-based, meaning the first page is index 0, the second is index 1, and so forth. This matches standard programming conventions and aligns with how most developers think about array access.

Targeting specific pages improves performance when processing large documents. Rather than scanning hundreds of pages for text that only appears in a few locations, you can direct the redaction engine exactly where to look. This matters for batch processing scenarios where you might handle thousands of documents. For maximum throughput, consider using async and multithreading techniques.

using IronPdf;

// Process a large document efficiently
PdfDocument pdf = PdfDocument.FromFile("annual-report-500-pages.pdf");

// We know from document structure that:
// - Executive summary with names is on pages 1-3
// - Financial data is on pages 45-60
// - Appendix with employee info is on pages 480-495

// Redact executive names from summary section
for (int i = 0; i <= 2; i++)
{
    pdf.RedactTextOnPage(i, "CEO: Robert Williams");
    pdf.RedactTextOnPage(i, "CFO: Maria Garcia");
}

// Redact specific financial figures from the financial section
int[] financialSection = { 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59 };
pdf.RedactTextOnPages(financialSection, "Net Revenue: $847M");

// Redact employee identifiers from appendix
for (int i = 479; i <= 494; i++)
{
    pdf.RedactTextOnPage(i, "Employee ID:");
}

pdf.SaveAs("annual-report-public-release.pdf");

This targeted approach processes only the relevant sections of a 500-page document, significantly reducing execution time compared to scanning every page for each redaction term.

How do I Customize the Appearance of Redacted Content?

IronPDF offers several parameters to control how redactions appear in the final document. You can adjust case sensitivity, whole word matching, whether to draw visual rectangles, and what replacement text appears in place of the redacted content.

Input

A legal brief containing various sensitive terms including classification labels, passwords, and internal reference codes that require different redaction treatments.

using IronPdf;

// Load the document
PdfDocument pdf = PdfDocument.FromFile("legal-brief.pdf");

// Case-sensitive redaction: only matches exact case
// "CLASSIFIED" will be redacted but "classified" or "Classified" will not
pdf.RedactTextOnAllPages(
    "CLASSIFIED",
    CaseSensitive: true,
    OnlyMatchWholeWords: true,
    DrawRectangles: true,
    ReplacementText: "[REDACTED]"
);

// Case-insensitive redaction: matches regardless of case
// Will redact "Secret", "SECRET", "secret", etc.
pdf.RedactTextOnAllPages(
    "secret",
    CaseSensitive: false,
    OnlyMatchWholeWords: true,
    DrawRectangles: true,
    ReplacementText: "*****"
);

// Whole word disabled: matches partial strings too
// Will redact "password", "passwords", "mypassword123", etc.
pdf.RedactTextOnAllPages(
    "password",
    CaseSensitive: false,
    OnlyMatchWholeWords: false,
    DrawRectangles: true,
    ReplacementText: "XXXXX"
);

// No visual rectangle: text is removed but no black box appears
// Useful when you want seamless removal without obvious redaction marks
pdf.RedactTextOnAllPages(
    "internal-reference-code",
    CaseSensitive: true,
    OnlyMatchWholeWords: true,
    DrawRectangles: false,
    ReplacementText: ""
);

pdf.SaveAs("legal-brief-redacted.pdf");

This code demonstrates four different redaction configurations using the optional parameters of RedactTextOnAllPages. It shows case-sensitive exact matching with "[REDACTED]" replacement, case-insensitive matching with asterisks, partial word matching to catch variations like "passwords", and invisible removal without visual rectangles for smooth content elimination.

Sample Output

The parameters serve different purposes depending on your requirements:

CaseSensitive determines whether matching considers letter case. Legal documents often use specific capitalizations that carry meaning, so case-sensitive matching ensures you only remove exact matches. Processing general text where case varies may require case-insensitive matching to catch all instances.

OnlyMatchWholeWords controls whether the search matches complete words or partial strings. When redacting names, you typically want whole word matching so that "Smith" does not accidentally redact part of "Blacksmith" or "Smithfield". When redacting patterns like account number prefixes, partial matching may be necessary to catch variations.

DrawRectangles specifies whether black boxes appear where content was removed. Most regulatory and legal contexts require visible redaction marks as evidence that content was deliberately removed instead of accidentally omitted. Internal workflows may prefer invisible removal for cleaner output.

ReplacementText defines what characters appear in place of the redacted content. Common choices include asterisks, "REDACTED" labels, or empty strings. The replacement text appears in the document structure if someone attempts to select or copy from the redacted area.

How can I Use Regular Expressions to Find and Redact Sensitive Patterns?

Redacting known text strings works when you have specific values to remove, but many confidential data types follow predictable patterns rather than fixed values. Social Security numbers, credit card numbers, email addresses, phone numbers, and dates all have recognizable formats that can be matched with regular expressions. Building a pattern-based redaction system allows you to remove private information from PDF content without knowing every specific value in advance.

IronPDF's text extraction capabilities combined with redaction methods enable powerful pattern matching workflows. You extract the text, identify matches using .NET regular expressions, and then redact each discovered value.

using IronPdf;
using System.Text.RegularExpressions;
using System.Collections.Generic;

public class PatternRedactor
{
    // Common patterns for sensitive data
    private static readonly Dictionary<string, string> SensitivePatterns = new Dictionary<string, string>
    {
        // US Social Security Number: 123-45-6789
        { "SSN", @"\b\d{3}-\d{2}-\d{4}\b" },

        // Credit Card Numbers: various formats with 13-19 digits
        { "CreditCard", @"\b(?:\d{4}[-\s]?){3}\d{1,4}\b" },

        // Email Addresses
        { "Email", @"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b" },

        // US Phone Numbers: (123) 456-7890 or 123-456-7890
        { "Phone", @"\b(?:\(\d{3}\)\s?|\d{3}[-.])\d{3}[-.]?\d{4}\b" },

        // Dates: MM/DD/YYYY or MM-DD-YYYY
        { "Date", @"\b\d{1,2}[/-]\d{1,2}[/-]\d{2,4}\b" },

        // IP Addresses
        { "IPAddress", @"\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b" }
    };

    public void RedactPatterns(string inputPath, string outputPath, params string[] patternNames)
    {
        // Load the PDF
        PdfDocument pdf = PdfDocument.FromFile(inputPath);

        // Extract all text from the document
        string fullText = pdf.ExtractAllText();

        // Track unique matches to avoid duplicate redaction attempts
        HashSet<string> matchesToRedact = new HashSet<string>();

        // Find all matches for requested patterns
        foreach (string patternName in patternNames)
        {
            if (SensitivePatterns.TryGetValue(patternName, out string pattern))
            {
                Regex regex = new Regex(pattern, RegexOptions.IgnoreCase);
                MatchCollection matches = regex.Matches(fullText);

                foreach (Match match in matches)
                {
                    matchesToRedact.Add(match.Value);
                }
            }
        }

        // Redact each unique match
        foreach (string sensitiveValue in matchesToRedact)
        {
            pdf.RedactTextOnAllPages(sensitiveValue);
        }

        // Save the redacted document
        pdf.SaveAs(outputPath);
    }
}

// Usage example
class Program
{
    static void Main()
    {
        PatternRedactor redactor = new PatternRedactor();

        // Redact SSNs and credit cards from a financial document
        redactor.RedactPatterns(
            "customer-data.pdf",
            "customer-data-safe.pdf",
            "SSN", "CreditCard", "Email"
        );
    }
}

This pattern-based approach scales well because you define the patterns once and apply them to any document. Adding new data types only requires adding new regex patterns to the dictionary.

How do I Build a Reusable Sensitive Data Scanner?

For production environments, you often need to scan documents and report what confidential information exists before deciding whether to redact. This helps with compliance auditing and allows human review of redaction decisions. The following class offers scanning capabilities alongside redaction.

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

public class SensitiveDataMatch
{
    public string PatternType { get; set; }
    public string Value { get; set; }
    public int PageNumber { get; set; }
}

public class ScanResult
{
    public string FilePath { get; set; }
    public List<SensitiveDataMatch> Matches { get; set; } = new List<SensitiveDataMatch>();
    public bool ContainsSensitiveData => Matches.Count > 0;

    public Dictionary<string, int> GetSummary()
    {
        return Matches.GroupBy(m => m.PatternType)
                      .ToDictionary(g => g.Key, g => g.Count());
    }
}

public class DocumentScanner
{
    private readonly Dictionary<string, string> _patterns;

    public DocumentScanner()
    {
        _patterns = new Dictionary<string, string>
        {
            { "Social Security Number", @"\b\d{3}-\d{2}-\d{4}\b" },
            { "Credit Card", @"\b(?:\d{4}[-\s]?){3}\d{1,4}\b" },
            { "Email Address", @"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b" },
            { "Phone Number", @"\b(?:\(\d{3}\)\s?|\d{3}[-.])\d{3}[-.]?\d{4}\b" },
            { "Date of Birth Pattern", @"\b(?:DOB|Date of Birth|Birth Date)[:\s]+\d{1,2}[/-]\d{1,2}[/-]\d{2,4}\b" }
        };
    }

    public ScanResult ScanDocument(string filePath)
    {
        ScanResult result = new ScanResult { FilePath = filePath };
        PdfDocument pdf = PdfDocument.FromFile(filePath);

        // Scan each page individually to track location
        for (int pageIndex = 0; pageIndex < pdf.PageCount; pageIndex++)
        {
            string pageText = pdf.ExtractTextFromPage(pageIndex);

            foreach (var pattern in _patterns)
            {
                Regex regex = new Regex(pattern.Value, RegexOptions.IgnoreCase);
                MatchCollection matches = regex.Matches(pageText);

                foreach (Match match in matches)
                {
                    result.Matches.Add(new SensitiveDataMatch
                    {
                        PatternType = pattern.Key,
                        Value = MaskValue(match.Value, pattern.Key),
                        PageNumber = pageIndex + 1
                    });
                }
            }
        }

        return result;
    }

    // Partially mask values for safe storage
    private string MaskValue(string value, string patternType)
    {
        if (patternType == "Social Security Number" && value.Length >= 4)
        {
            return "XXX-XX-" + value.Substring(value.Length - 4);
        }
        if (patternType == "Credit Card" && value.Length >= 4)
        {
            return "****-****-****-" + value.Substring(value.Length - 4);
        }
        if (patternType == "Email Address")
        {
            int atIndex = value.IndexOf('@');
            if (atIndex > 2)
            {
                return value.Substring(0, 2) + "***" + value.Substring(atIndex);
            }
        }
        return value.Length > 4 ? value.Substring(0, 2) + "***" : "****";
    }

    public void ScanAndRedact(string inputPath, string outputPath)
    {
        // First scan to identify sensitive data
        ScanResult scanResult = ScanDocument(inputPath);

        if (!scanResult.ContainsSensitiveData)
        {
            return;
        }

        // Load document for redaction
        PdfDocument pdf = PdfDocument.FromFile(inputPath);

        // Extract unique actual values (not masked) for redaction
        string fullText = pdf.ExtractAllText();
        HashSet<string> valuesToRedact = new HashSet<string>();

        foreach (var pattern in _patterns)
        {
            Regex regex = new Regex(pattern.Value, RegexOptions.IgnoreCase);
            foreach (Match match in regex.Matches(fullText))
            {
                valuesToRedact.Add(match.Value);
            }
        }

        // Apply redactions
        foreach (string value in valuesToRedact)
        {
            pdf.RedactTextOnAllPages(value);
        }

        pdf.SaveAs(outputPath);
    }
}

// Usage
class Program
{
    static void Main()
    {
        DocumentScanner scanner = new DocumentScanner();

        // Scan only (for audit purposes)
        ScanResult result = scanner.ScanDocument("application-form.pdf");
        var summary = result.GetSummary();

        // Scan and redact in one operation
        scanner.ScanAndRedact("application-form.pdf", "application-form-redacted.pdf");
    }
}

The scanner offers visibility into what confidential information exists before any modifications occur. This supports compliance workflows where you need documentation of what was found and removed. The masking function ensures that log files and reports do not themselves become sources of data exposure.

How do I Redact Specific Regions or Areas in a PDF?

Text redaction handles character-based content effectively, but PDFs often contain sensitive information in forms that text matching cannot address. Signatures, photographs, handwritten annotations, stamps, and graphical elements require a different approach. Region-based redaction lets you specify rectangular areas by their coordinates and permanently obscure everything within those bounds.

IronPDF uses the RectangleF structure to define redaction regions. You specify the X and Y coordinates of the top left corner, then the width and height of the area. Coordinates are measured in points from the bottom left of the page, which matches the PDF specification's coordinate system.

Input

A signed agreement document containing handwritten signatures and a photo ID that need to be redacted using coordinate-based region targeting.

using IronPdf;
using IronSoftware.Drawing;

// Load a document with signature blocks and photos
PdfDocument pdf = PdfDocument.FromFile("signed-agreement.pdf");

// Define a region for a signature block
// Located 100 points from left, 650 points from bottom
// Width of 200 points, height of 50 points
RectangleF signatureRegion = new RectangleF(100, 650, 200, 50);

// Redact the signature region on all pages
pdf.RedactRegionsOnAllPages(signatureRegion);

// Define a region for a photo ID in the upper right
RectangleF photoRegion = new RectangleF(450, 700, 100, 120);
pdf.RedactRegionsOnAllPages(photoRegion);

// Save the document with regions redacted
pdf.SaveAs("signed-agreement-redacted.pdf");

This code uses RectangleF structures to define rectangular areas for redaction. The signature region is positioned at coordinates (100, 650) with a 200x50 pixel area, while the photo region is at (450, 700) with a 100x120 pixel area. The RedactRegionsOnAllPages method applies black rectangles over these regions across all pages.

Sample Output

Determining the correct coordinates often requires some experimentation or measurement. PDF pages typically use a coordinate system where one point equals 1/72 of an inch. A standard US Letter page is 612 points wide and 792 points tall. A4 pages are approximately 595 by 842 points. PDF viewing tools that display coordinates as you move the cursor can help, or you can extract page dimensions programmatically:

using IronPdf;
using IronSoftware.Drawing;

PdfDocument pdf = PdfDocument.FromFile("form-document.pdf");

// Get dimensions of the first page
var pageInfo = pdf.Pages[0];

// Calculate regions relative to page dimensions
// Redact the bottom quarter of the page where signatures appear
float signatureAreaHeight = (float)(pageInfo.Height / 4);
RectangleF bottomQuarter = new RectangleF(
    0,                              // Start at left edge
    0,                              // Start at bottom
    (float)pageInfo.Width,          // Full page width
    signatureAreaHeight             // Quarter of page height
);

pdf.RedactRegionsOnAllPages(bottomQuarter);

// Redact a header area at the top containing letterhead with address
float headerHeight = 100;
RectangleF headerArea = new RectangleF(
    0,
    (float)(pageInfo.Height - headerHeight), // Position from bottom
    (float)pageInfo.Width,
    headerHeight
);

pdf.RedactRegionsOnAllPages(headerArea);

pdf.SaveAs("form-document-redacted.pdf");

My favorite library of this kind is IronPDF. It allows for fast and efficient manipulation of PDF files. It also has many valuable features, like exporting to PDF/A format and digitally signing PDF documents.

Milan Jovanovic

Microsoft MVP

View case study

IronOCR means we can save $40,000 annually from manual processing, while enhancing productivity and freeing up resources for high-impact tasks. I would highly recommend it.

Brent Matzelle

Chief Technology Officer, OPYN

View case study

How can I Redact Multiple Regions Across Different Pages?

Complex documents often require different regions redacted on different pages. A multi-page form could have signature lines in varying positions, or different pages may contain photos, stamps, or other graphical elements at unique locations. IronPDF includes page-specific methods for targeted region redaction.

using IronPdf;
using IronSoftware.Drawing;

PdfDocument pdf = PdfDocument.FromFile("multi-page-application.pdf");

// Define page-specific redaction regions
// Page 1: Cover page with applicant photo
RectangleF page1Photo = new RectangleF(450, 600, 120, 150);
pdf.RedactRegionOnPage(0, page1Photo);

// Page 2: Personal information section
RectangleF page2InfoBlock = new RectangleF(50, 400, 250, 200);
pdf.RedactRegionOnPage(1, page2InfoBlock);

// Pages 3-5: Signature lines at the same position
RectangleF signatureLine = new RectangleF(100, 100, 200, 40);
int[] signaturePages = { 2, 3, 4 };
pdf.RedactRegionOnPages(signaturePages, signatureLine);

// Page 6: Multiple regions - notary stamp and witness signature
RectangleF notaryStamp = new RectangleF(400, 150, 150, 150);
RectangleF witnessSignature = new RectangleF(100, 150, 200, 40);
pdf.RedactRegionOnPage(5, notaryStamp);
pdf.RedactRegionOnPage(5, witnessSignature);

pdf.SaveAs("multi-page-application-redacted.pdf");

Documents with consistent layouts benefit from reusable region definitions:

using IronPdf;
using IronSoftware.Drawing;

public class FormRegions
{
    // Standard form regions based on common templates
    public static RectangleF HeaderLogo => new RectangleF(20, 720, 150, 60);
    public static RectangleF SignatureBlock => new RectangleF(72, 72, 200, 50);
    public static RectangleF DateField => new RectangleF(400, 72, 120, 20);
    public static RectangleF PhotoId => new RectangleF(480, 650, 100, 130);
    public static RectangleF AddressBlock => new RectangleF(72, 600, 250, 80);
}

class Program
{
    static void Main()
    {
        PdfDocument pdf = PdfDocument.FromFile("standard-form.pdf");
        
        // Apply standard redactions using predefined regions
        pdf.RedactRegionsOnAllPages(FormRegions.SignatureBlock);
        pdf.RedactRegionsOnAllPages(FormRegions.DateField);
        pdf.RedactRegionOnPage(0, FormRegions.PhotoId);
        
        pdf.SaveAs("standard-form-redacted.pdf");
    }
}
C#

How do I Remove Metadata that Could Expose Sensitive Information?

PDF metadata represents a frequently overlooked source of information leakage. Every PDF carries properties that can reveal sensitive details: the author's name and username, the software used to create the document, creation and modification timestamps, the original filename, revision history, and custom properties added by various applications. Before sharing documents externally, stripping or sanitizing this metadata is essential. For a comprehensive overview of metadata operations, see our metadata how-to guide.

IronPDF exposes document metadata through the MetaData property, allowing you to read existing values, modify them, or remove them entirely.

using IronPdf;
using System;

// Load a document containing sensitive metadata
PdfDocument pdf = PdfDocument.FromFile("internal-report.pdf");

// Access current metadata properties
string author = pdf.MetaData.Author;
string title = pdf.MetaData.Title;
string subject = pdf.MetaData.Subject;
string keywords = pdf.MetaData.Keywords;
string creator = pdf.MetaData.Creator;
string producer = pdf.MetaData.Producer;
DateTime? creationDate = pdf.MetaData.CreationDate;
DateTime? modifiedDate = pdf.MetaData.ModifiedDate;

// Get all metadata keys including custom properties
var allKeys = pdf.MetaData.Keys();

To remove sensitive metadata before distribution:

Input

An internal memo containing embedded metadata such as author names, creation timestamps, and custom properties that could reveal sensitive organizational information.

using IronPdf;
using System;

PdfDocument pdf = PdfDocument.FromFile("confidential-memo.pdf");

// Replace identifying metadata with generic values
pdf.MetaData.Author = "Organization Name";
pdf.MetaData.Creator = "Document System";
pdf.MetaData.Producer = "";
pdf.MetaData.Title = "Public Document";
pdf.MetaData.Subject = "";
pdf.MetaData.Keywords = "";

// Normalize dates to remove timing information
pdf.MetaData.CreationDate = DateTime.Now;
pdf.MetaData.ModifiedDate = DateTime.Now;

// Remove specific custom metadata keys
pdf.MetaData.RemoveMetaDataKey("OriginalFilename");
pdf.MetaData.RemoveMetaDataKey("LastSavedBy");
pdf.MetaData.RemoveMetaDataKey("Company");
pdf.MetaData.RemoveMetaDataKey("Manager");

// Remove custom properties added by applications
try
{
    pdf.MetaData.CustomProperties.Remove("SourcePath");
}
catch { }

pdf.SaveAs("confidential-memo-cleaned.pdf");

This code replaces identifying metadata fields with generic values, normalizes timestamps to the current date, and removes custom metadata keys that applications may have added. The RemoveMetaDataKey method targets specific properties like "OriginalFilename" and "LastSavedBy" that could expose internal information.

Sample Output

Thorough metadata cleaning across batch operations requires a systematic approach:

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

public class MetadataCleaner
{
    private readonly string _defaultAuthor;
    private readonly string _defaultCreator;
    
    public MetadataCleaner(string organizationName)
    {
        _defaultAuthor = organizationName;
        _defaultCreator = $"{organizationName} Document System";
    }
    
    public void CleanMetadata(PdfDocument pdf)
    {
        // Replace standard metadata fields
        pdf.MetaData.Author = _defaultAuthor;
        pdf.MetaData.Creator = _defaultCreator;
        pdf.MetaData.Producer = "";
        pdf.MetaData.Subject = "";
        pdf.MetaData.Keywords = "";
        
        // Normalize timestamps
        DateTime now = DateTime.Now;
        pdf.MetaData.CreationDate = now;
        pdf.MetaData.ModifiedDate = now;
        
        // Get all keys and remove potentially sensitive ones
        List<string> keysToRemove = new List<string>();
        foreach (string key in pdf.MetaData.Keys())
        {
            // Keep only essential keys
            if (!IsEssentialKey(key))
            {
                keysToRemove.Add(key);
            }
        }
        
        foreach (string key in keysToRemove)
        {
            pdf.MetaData.RemoveMetaDataKey(key);
        }
    }
    
    private bool IsEssentialKey(string key)
    {
        // Keep only the basic display properties
        string[] essentialKeys = { "Title", "Author", "CreationDate", "ModifiedDate" };
        foreach (string essential in essentialKeys)
        {
            if (key.Equals(essential, StringComparison.OrdinalIgnoreCase))
            {
                return true;
            }
        }
        return false;
    }
}

// Usage
class Program
{
    static void Main()
    {
        MetadataCleaner cleaner = new MetadataCleaner("Acme Corporation");
        
        PdfDocument pdf = PdfDocument.FromFile("report.pdf");
        cleaner.CleanMetadata(pdf);
        pdf.SaveAs("report-clean.pdf");
    }
}
C#

How can I Sanitize a PDF to Remove Embedded Scripts and Hidden Threats?

PDF sanitization addresses security concerns that go beyond visible content and metadata. PDF files can contain JavaScript code, embedded executables, form actions that trigger external connections, and other potentially malicious elements. These capabilities exist for legitimate purposes like interactive forms and multimedia content, but they also create attack vectors. Sanitizing a PDF removes these active elements while preserving the visual content. For additional details on sanitization methods, see our sanitize PDF how-to guide.

IronPDF's Cleaner class handles sanitization through an elegant approach: converting the PDF to an image format and then converting it back. This process strips away JavaScript, embedded objects, form actions, and annotations while keeping the visual appearance intact. The library offers two sanitization methods with different characteristics.

Input

A PDF document received from an external source that may contain JavaScript, embedded objects, or other potentially malicious active content.

using IronPdf;

// Load a PDF that may contain active content
PdfDocument pdf = PdfDocument.FromFile("received-document.pdf");

// Sanitize using SVG conversion
// Faster processing, results in searchable text, slight layout variations possible
PdfDocument sanitizedSvg = Cleaner.SanitizeWithSvg(pdf);
sanitizedSvg.SaveAs("sanitized-svg.pdf");

// Sanitize using Bitmap conversion
// Slower processing, text becomes image (not searchable), exact visual reproduction
PdfDocument sanitizedBitmap = Cleaner.SanitizeWithBitmap(pdf);
sanitizedBitmap.SaveAs("sanitized-bitmap.pdf");

This code demonstrates two sanitization methods provided by IronPDF's Cleaner class. SanitizeWithSvg converts the PDF through an SVG intermediate format, preserving searchable text while removing active content. SanitizeWithBitmap converts pages to images first, producing exact visual copies but with text rendered as non-searchable graphics.

Sample Output

The SVG method works faster and preserves text as searchable content, making it suitable for documents that need to remain indexed or accessible. The bitmap method produces exact visual copies but converts text to images, which prevents text selection and searching. Choose based on your requirements for the output document.

You can also apply rendering options during sanitization to adjust the output:

using IronPdf;

// Load the potentially unsafe document
PdfDocument pdf = PdfDocument.FromFile("untrusted-source.pdf");

// Configure rendering options for sanitization
var renderOptions = new ChromePdfRenderOptions
{
    MarginTop = 10,
    MarginBottom = 10,
    MarginLeft = 10,
    MarginRight = 10
};

// Sanitize with custom options
PdfDocument sanitized = Cleaner.SanitizeWithSvg(pdf, renderOptions);
sanitized.SaveAs("untrusted-source-safe.pdf");

High-security environments often require combining sanitization with other protective measures:

using IronPdf;
using System;

public class SecureDocumentProcessor
{
    public PdfDocument ProcessUntrustedDocument(string inputPath)
    {
        // Load the document
        PdfDocument original = PdfDocument.FromFile(inputPath);

        // Step 1: Sanitize to remove active content
        PdfDocument sanitized = Cleaner.SanitizeWithSvg(original);

        // Step 2: Clean metadata
        sanitized.MetaData.Author = "Processed Document";
        sanitized.MetaData.Creator = "Secure Processor";
        sanitized.MetaData.Producer = "";
        sanitized.MetaData.CreationDate = DateTime.Now;
        sanitized.MetaData.ModifiedDate = DateTime.Now;

        // Remove all custom metadata
        foreach (string key in sanitized.MetaData.Keys())
        {
            if (key != "Title" && key != "Author" && key != "CreationDate" && key != "ModifiedDate")
            {
                sanitized.MetaData.RemoveMetaDataKey(key);
            }
        }

        return sanitized;
    }
}

// Usage
class Program
{
    static void Main()
    {
        SecureDocumentProcessor processor = new SecureDocumentProcessor();
        PdfDocument safe = processor.ProcessUntrustedDocument("email-attachment.pdf");
        safe.SaveAs("email-attachment-safe.pdf");
    }
}

How do I Scan a PDF for Security Vulnerabilities?

Before processing or sanitizing documents, you may want to assess what potential threats they contain. IronPDF's Cleaner.ScanPdf method examines documents using YARA rules, which are pattern definitions commonly used in malware analysis and threat detection. The scan identifies characteristics associated with malicious PDF files.

using IronPdf;

// Load the document to scan
PdfDocument pdf = PdfDocument.FromFile("suspicious-document.pdf");

// Scan using default YARA rules
CleanerScanResult scanResult = Cleaner.ScanPdf(pdf);

// Check the scan results
bool threatsDetected = scanResult.IsDetected;
int riskCount = scanResult.Risks.Count;

// Process identified risks
if (scanResult.IsDetected)
{
    foreach (var risk in scanResult.Risks)
    {
        // Handle each identified risk
    }

    // Sanitize the document before use
    PdfDocument sanitized = Cleaner.SanitizeWithSvg(pdf);
    sanitized.SaveAs("suspicious-document-safe.pdf");
}

You can provide custom YARA rule files for specialized detection requirements. Organizations with specific threat models or compliance needs often maintain their own rule sets targeting particular vulnerability patterns.

using IronPdf;

PdfDocument pdf = PdfDocument.FromFile("incoming-document.pdf");

// Scan with custom YARA rules
string[] customYaraFiles = { "corporate-rules.yar", "industry-specific.yar" };
CleanerScanResult result = Cleaner.ScanPdf(pdf, customYaraFiles);

if (result.IsDetected)
{
    // Document triggered custom rules and requires review or sanitization
    PdfDocument sanitized = Cleaner.SanitizeWithSvg(pdf);
    sanitized.SaveAs("incoming-document-safe.pdf");
}

Integrating scanning into document intake workflows helps automate security decisions:

using IronPdf;
using System;
using System.IO;

public enum DocumentSafetyLevel
{
    Safe,
    Suspicious,
    Dangerous
}

public class DocumentSecurityGateway
{
    public DocumentSafetyLevel EvaluateDocument(string filePath)
    {
        PdfDocument pdf = PdfDocument.FromFile(filePath);
        CleanerScanResult scan = Cleaner.ScanPdf(pdf);

        if (!scan.IsDetected)
        {
            return DocumentSafetyLevel.Safe;
        }

        // Evaluate severity based on number of risks
        if (scan.Risks.Count > 5)
        {
            return DocumentSafetyLevel.Dangerous;
        }

        return DocumentSafetyLevel.Suspicious;
    }

    public PdfDocument ProcessIncomingDocument(string filePath, string outputDirectory)
    {
        DocumentSafetyLevel safety = EvaluateDocument(filePath);
        string fileName = Path.GetFileName(filePath);

        switch (safety)
        {
            case DocumentSafetyLevel.Safe:
                return PdfDocument.FromFile(filePath);

            case DocumentSafetyLevel.Suspicious:
                PdfDocument suspicious = PdfDocument.FromFile(filePath);
                return Cleaner.SanitizeWithSvg(suspicious);

            case DocumentSafetyLevel.Dangerous:
                throw new SecurityException($"Document {fileName} contains dangerous content");

            default:
                throw new InvalidOperationException("Unknown safety level");
        }
    }
}

How can I Build a Complete Redaction and Sanitization Pipeline?

Production document processing typically requires combining multiple protection techniques into a cohesive workflow. A complete pipeline might scan incoming documents for threats, sanitize those that pass initial screening, apply text and region redactions, strip metadata, and produce audit logs documenting all actions taken. This example demonstrates such an integrated approach.

using IronPdf;
using IronSoftware.Drawing;
using System;
using System.Collections.Generic;
using System.IO;
using System.Text.RegularExpressions;

public class DocumentProcessingResult
{
    public string OriginalFile { get; set; }
    public string OutputFile { get; set; }
    public bool WasSanitized { get; set; }
    public int TextRedactionsApplied { get; set; }
    public int RegionRedactionsApplied { get; set; }
    public bool MetadataCleaned { get; set; }
    public List<string> SensitiveDataTypesFound { get; set; } = new List<string>();
    public DateTime ProcessedAt { get; set; }
    public bool Success { get; set; }
    public string ErrorMessage { get; set; }
}

public class ComprehensiveDocumentProcessor
{
    // Sensitive data patterns
    private readonly Dictionary<string, string> _sensitivePatterns = new Dictionary<string, string>
    {
        { "SSN", @"\b\d{3}-\d{2}-\d{4}\b" },
        { "Credit Card", @"\b(?:\d{4}[-\s]?){3}\d{1,4}\b" },
        { "Email", @"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b" },
        { "Phone", @"\b(?:\(\d{3}\)\s?|\d{3}[-.])\d{3}[-.]?\d{4}\b" }
    };

    // Standard regions to redact (signature areas, photo locations)
    private readonly List<RectangleF> _standardRedactionRegions = new List<RectangleF>
    {
        new RectangleF(72, 72, 200, 50),    // Bottom left signature
        new RectangleF(350, 72, 200, 50)    // Bottom right signature
    };

    private readonly string _organizationName;

    public ComprehensiveDocumentProcessor(string organizationName)
    {
        _organizationName = organizationName;
    }

    public DocumentProcessingResult ProcessDocument(
        string inputPath,
        string outputPath,
        bool sanitize = true,
        bool redactPatterns = true,
        bool redactRegions = true,
        bool cleanMetadata = true,
        List<string> additionalTermsToRedact = null)
    {
        var result = new DocumentProcessingResult
        {
            OriginalFile = inputPath,
            OutputFile = outputPath,
            ProcessedAt = DateTime.Now
        };

        try
        {
            // Load the document
            PdfDocument pdf = PdfDocument.FromFile(inputPath);

            // Step 1: Security scan
            CleanerScanResult scanResult = Cleaner.ScanPdf(pdf);

            if (scanResult.IsDetected && scanResult.Risks.Count > 10)
            {
                throw new SecurityException("Document contains too many security risks to process");
            }

            // Step 2: Sanitization (if needed or requested)
            if (sanitize || scanResult.IsDetected)
            {
                pdf = Cleaner.SanitizeWithSvg(pdf);
                result.WasSanitized = true;
            }

            // Step 3: Pattern-based text redaction
            if (redactPatterns)
            {
                string fullText = pdf.ExtractAllText();
                HashSet<string> valuesToRedact = new HashSet<string>();

                foreach (var pattern in _sensitivePatterns)
                {
                    Regex regex = new Regex(pattern.Value, RegexOptions.IgnoreCase);
                    MatchCollection matches = regex.Matches(fullText);

                    if (matches.Count > 0)
                    {
                        result.SensitiveDataTypesFound.Add($"{pattern.Key} ({matches.Count})");
                        foreach (Match match in matches)
                        {
                            valuesToRedact.Add(match.Value);
                        }
                    }
                }

                // Apply redactions
                foreach (string value in valuesToRedact)
                {
                    pdf.RedactTextOnAllPages(value);
                    result.TextRedactionsApplied++;
                }
            }

            // Step 4: Additional specific terms
            if (additionalTermsToRedact != null)
            {
                foreach (string term in additionalTermsToRedact)
                {
                    pdf.RedactTextOnAllPages(term);
                    result.TextRedactionsApplied++;
                }
            }

            // Step 5: Region-based redaction
            if (redactRegions)
            {
                foreach (RectangleF region in _standardRedactionRegions)
                {
                    pdf.RedactRegionsOnAllPages(region);
                    result.RegionRedactionsApplied++;
                }
            }

            // Step 6: Metadata cleaning
            if (cleanMetadata)
            {
                pdf.MetaData.Author = _organizationName;
                pdf.MetaData.Creator = $"{_organizationName} Document Processor";
                pdf.MetaData.Producer = "";
                pdf.MetaData.Subject = "";
                pdf.MetaData.Keywords = "";
                pdf.MetaData.CreationDate = DateTime.Now;
                pdf.MetaData.ModifiedDate = DateTime.Now;
                result.MetadataCleaned = true;
            }

            // Step 7: Save the processed document
            pdf.SaveAs(outputPath);
            result.Success = true;
        }
        catch (Exception ex)
        {
            result.Success = false;
            result.ErrorMessage = ex.Message;
        }

        return result;
    }
}

// Usage example
class Program
{
    static void Main()
    {
        var processor = new ComprehensiveDocumentProcessor("Acme Corporation");

        // Process a single document with all protections
        var result = processor.ProcessDocument(
            inputPath: "customer-application.pdf",
            outputPath: "customer-application-redacted.pdf",
            sanitize: true,
            redactPatterns: true,
            redactRegions: true,
            cleanMetadata: true,
            additionalTermsToRedact: new List<string> { "Project Alpha", "Internal Use Only" }
        );

        // Batch process multiple documents
        string[] inputFiles = Directory.GetFiles("incoming", "*.pdf");
        foreach (string file in inputFiles)
        {
            string outputFile = Path.Combine("processed", Path.GetFileName(file));
            processor.ProcessDocument(file, outputFile);
        }
    }
}

Input

A customer application form containing multiple types of sensitive data including SSNs, credit card numbers, email addresses, and signature blocks requiring comprehensive protection.

Sample Output

This comprehensive processor combines all the techniques covered in this guide into a single, configurable class. It scans for threats, sanitizes when necessary, finds and redacts sensitive patterns, applies region redactions, cleans metadata, and produces detailed reports. You can adjust the sensitivity patterns, redaction regions, and processing options to match your specific requirements.

Next Steps

Protecting sensitive information in PDF documents requires more than superficial measures. True redaction eliminates content from the document structure permanently. Pattern matching automates the discovery and removal of data like Social Security numbers, credit card details, and email addresses. Region-based redaction handles signatures, photos, and other graphical elements that text matching cannot address. Metadata cleaning eliminates hidden information that could reveal authors, timestamps, or internal file paths. Sanitization strips embedded scripts and active content that pose security risks.

IronPDF delivers all these capabilities through a consistent, well-designed API that integrates naturally with C# and .NET development practices. The methods demonstrated in this guide handle single documents or scale to batch processing thousands of files. Whether you are building compliance workflows for healthcare data, preparing legal documents for discovery, or simply ensuring that internal reports can be safely shared externally, these techniques form the foundation of responsible document handling. For comprehensive security coverage, combine redaction with password protection and permissions and digital signatures.

Ready to start building? Download IronPDF and try it with a free trial. The library includes a free development license, so you can fully evaluate redaction, text extraction, and sanitization capabilities before committing to a production license. If you have questions about implementation or compliance workflows, reach out to our engineering support team.

Frequently Asked Questions

What is true redaction in PDFs with IronPDF?

True redaction with IronPDF permanently removes specified content from a PDF's internal structure, ensuring that the original data is irretrievable. This method securely deletes character data from content streams, rather than just visually obscuring it with overlays.

How can IronPDF help comply with regulations like HIPAA, GDPR, and PCI DSS?

IronPDF provides tools for secure document handling, including text redaction, metadata cleanup, and document sanitization. These features help meet regulatory requirements such as HIPAA, GDPR, and PCI DSS by ensuring that sensitive information is not retrievably stored in PDFs.

Can I use regular expressions for redaction in IronPDF?

Yes, IronPDF allows the use of regular expressions to locate and redact patterns like Social Security numbers, email addresses, and credit card numbers, enabling developers to automate the process of identifying and removing sensitive data.

How do I redact specific regions in a PDF using IronPDF?

IronPDF enables region-based redaction by allowing developers to specify rectangular areas on a PDF page using coordinates, effectively obscuring sensitive graphical or image content such as signatures or photographs.

What methods does IronPDF provide for sanitizing PDFs?

IronPDF offers methods like `SanitizeWithSvg` and `SanitizeWithBitmap` to remove potentially harmful content such as JavaScript, embedded files, or form actions from PDFs, while maintaining their visual formatting.

How can I remove sensitive metadata from PDFs using IronPDF?

IronPDF allows for the removal or modification of PDF metadata, including author names, document creation times, and custom properties, to ensure that no sensitive or identifiable information is inadvertently shared.

How can I customize the appearance of redacted content in IronPDF?

IronPDF provides options to customize the appearance of redacted content, such as setting case sensitivity, deciding whether to draw visual markers for redactions, and choosing replacement text to indicate where redactions have occurred.

What are the advantages of using IronPDF for complete document protection workflows?

IronPDF offers a comprehensive set of tools for document protection, including text and region-based redactions, metadata stripping, and vulnerability scanning, all of which are essential for building secure document workflows that comply with legal and regulatory standards.

Can IronPDF handle redaction and sanitization in batch processes?

Yes, IronPDF is designed to handle large volumes of documents through batch processing, allowing users to apply redactions and sanitize multiple PDFs efficiently, which is ideal for enterprise-scale document management.

How does IronPDF handle text redaction across all pages in a document?

IronPDF's `RedactTextOnAllPages` method searches for specified text across every page in a PDF, permanently removing it to ensure that sensitive information cannot be recovered from any part of the document.

Curtis Chau
Curtis Chau
Technical Writer

Curtis Chau holds a Bachelor’s degree in Computer Science (Carleton University) and specializes in front-end development with expertise in Node.js, TypeScript, JavaScript, and React. Passionate about crafting intuitive and aesthetically pleasing user interfaces, Curtis enjoys working with modern frameworks and creating well-structured, visually appealing manuals.

...
Read More

Ready to Get Started?

Nuget Downloads 21,228,841Version:2026.9just released

Free NuGet Download
Total downloads: 21,228,841
Get your free 30-day Trial Key instantly.
No credit card or account creation required
C# NuGet Library for PDF
Install with NuGet

Version: 2026.9

PM > Install-Package IronPdf
nuget.org/packages/IronPdf/
  1. In Solution Explorer, right-click References, Manage NuGet Packages
  2. Select Browse and search "IronPdf"
  3. Select the package and install
C# PDF DLL
Download DLL

Version: 2026.9

or download Windows Installer here.

  1. Download and unzip IronPDF to a location such as ~/Libs within your Solution directory
  2. In Visual Studio Solution Explorer, right click References. Select Browse, "IronPdf.dll"

Licenses from $999

Key in blue circle

Get your free 30-day Trial Key instantly.

Your trial license will be sent to your email address

No limitations. 100% unlocked. No credit card.

OR
bullet_checkedNo credit card or account creation requiredNo limitations. 100% unlocked. No credit card.
  • Logo Aetna
  • Logo NASA
  • Logo GE
  • Logo Porsche
  • Logo USDA
  • Logo Qatar
Join Millions of Engineers who’ve tried IronPDF
Book your free Live Demo
Booking Badge

Trusted by Millions of Engineers Worldwide

Iron Software's customer logos
Get Your No-Obligation Consult
Complete the form below or email sales@ironsoftware.com
Your details will always be kept confidential.
Trusted by Millions of Engineers Worldwide
Iron Software's customer logos
Get your free 30-day Trial Key instantly.
No credit card or account creation required
C# NuGet Library for PDF
Install with NuGet

Version: 2026.9

PM > Install-Package IronPdf
nuget.org/packages/IronPdf/
  1. In Solution Explorer, right-click References, Manage NuGet Packages
  2. Select Browse and search "IronPdf"
  3. Select the package and install
C# PDF DLL
Download DLL

Version: 2026.9

or download Windows Installer here.

  1. Download and unzip IronPDF to a location such as ~/Libs within your Solution directory
  2. In Visual Studio Solution Explorer, right click References. Select Browse, "IronPdf.dll"

Licenses from $999