1. IronPDF
  2. Tutorials
  3. PDF Digital Signatures Guide

Sign PDF Programmatically in C# .NET 10: Digital Signature Guide

Curtis Chau
Curtis Chau
Updated:

Digital signatures have become essential for modern enterprise document workflows. Whether you're processing contracts, invoices, compliance documents, or legal filings, your organization needs reliable ways to authenticate PDFs and verify that documents haven't been tampered with. This guide walks you through implementing digital signature functionality in .NET applications, covering everything from basic certificate signing to multi-party approval workflows.

Before diving into code, it helps to understand the difference between simply displaying a signature image and applying real cryptographic authentication. Once you grasp when each approach fits your needs and how to implement both, you can build document systems that meet security targets while remaining easy to use.

Quickstart: Sign Your First PDF with IronPDF

To begin signing PDFs with IronPDF and to follow the tutorial examples outlined in this article, check out the quick installation guide that will assist you in getting everything set up smoothly.

Sign your first PDF in C# using IronPDF with just a few lines of code. This quick example shows you how to load a certificate, apply a digital signature, and save the signed result.

Nuget IconGet started making PDFs with NuGet now:

  1. Install IronPDF with NuGet Package Manager

    PM > Install-Package IronPdf

  2. Copy and run this code snippet.

    var signature = new IronPdf.Signing.PdfSignature("certificate.pfx", "password");
IronPdf.PdfDocument.FromFile("document.pdf").Sign(signature).SaveAs("signed.pdf");

  3. Deploy to test on your live environment

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

Download the Complete Project

To get started quickly, download the complete working project with all code examples from this tutorial.

The download includes a fully configured .NET project with sample certificate and all signing examples ready to build and run.

Table of Contents

What is the difference between Digital Signatures and Visual Signatures in PDF documents?

People often use "digital signature" and "electronic signature" interchangeably, but they work quite differently when it comes to document security. A digital signature uses cryptographic techniques to encrypt a hash of the document's contents with a private key. Anyone with access to the corresponding public key can then verify that the document hasn't changed since signing.

A visual signature, on the other hand, is simply an image placed on a PDF page. It could be a scanned handwritten signature, a company logo, or a stylized text version of a name. While visual signatures help documents look "signed" to human readers, they offer no cryptographic protection against tampering.

In practice, business applications often need both types working together. A legal contract might require the cryptographic protection of a certificate based digital signature to ensure document integrity, plus a visible signature block so recipients can see who signed and when.

The following table summarizes the key differences between these signature types:

CharacteristicDigital SignatureVisual Signature
Cryptographic ProtectionUses PKI and X.509 certificates to create tamper evident sealNone, image can be removed or replaced
Non RepudiationSigner cannot credibly deny signingProvides no technical proof of identity
Tamper DetectionAny modification invalidates the signatureNo way to detect if document was altered
Legal StandingRecognized under regulations like ESIGN Act and eIDASMay satisfy "intent to sign" requirements only
VerificationCan be validated programmatically or in PDF readersRequires visual inspection only
Certificate RequiredYes, requires .pfx or .p12 certificate fileNo, any image file works

For most business use cases, digital signatures with an accompanying visual representation provide the strongest combination of security and usability. The cryptographic layer ensures document integrity while the visual layer provides a familiar signing experience for recipients.

How can Development Teams set up Digital Signature Infrastructure?

Implementing digital signatures requires two things: X.509 certificates for signing and some knowledge of how certificate management works in production. This section walks through each component.

What Certificate Formats does IronPDF support for PDF Signing?

Digital signatures rely on X.509 certificates, which contain a public and private key pair along with identity information about the certificate holder. These credentials typically have validity periods of one to three years. IronPDF works with certificates in the standard PKCS#12 format, usually stored as .pfx or .p12 files. These files bundle the private key (needed for signing) with the public certificate (needed for verification) into a single password protected container.

Enterprise environments usually obtain certificates from one of several sources:

Commercial Certificate Authorities such as DigiCert, Sectigo, or GlobalSign issue certificates that are automatically trusted by major PDF readers.

Internal PKI Infrastructure allows organizations to issue their own certificates, though recipients may need to manually trust the issuing CA.

Self Signed Certificates work for prototyping but will display warnings in PDF readers unless manually trusted.

When loading a certificate for IronPDF, the X509KeyStorageFlags.Exportable flag must be specified. This lets the cryptographic subsystem access the private key for signing. Here's how to load a certificate properly:

:path=/static-assets/pdf/content-code-examples/tutorials/pdf-digital-signatures-csharp-guide/load-certificate.cs
using System.Security.Cryptography.X509Certificates;

// Load the certificate from a PKCS#12 file (.pfx or .p12)
// The Exportable flag allows the private key to be used for signing
var certificate = new X509Certificate2(
    "company-signing-cert.pfx",
    "certificate-password",
    X509KeyStorageFlags.Exportable
);

Imports System.Security.Cryptography.X509Certificates

' Load the certificate from a PKCS#12 file (.pfx or .p12)
' The Exportable flag allows the private key to be used for signing
Dim certificate As New X509Certificate2( _
    "company-signing-cert.pfx", _
    "certificate-password", _
    X509KeyStorageFlags.Exportable _
)
$vbLabelText   $csharpLabel

Example Output:

Certificate loaded successfully
  Subject: CN=Test Signer, O=Test Organization, C=US
  Issuer: CN=Test Signer, O=Test Organization, C=US
  Valid From: 2026-01-27 7:50:04 AM
  Valid To: 2027-01-27 8:00:03 AM
  Thumbprint: 41355DE5ADD66CD64B2B99FF2CF87B9C87BD412F
  Has Private Key: True

In production, pull certificate passwords from secure configuration systems like Azure Key Vault, AWS Secrets Manager, or HashiCorp Vault instead of hardcoding them. Store the certificate files with proper access controls and never commit them to version control.

How can Developers apply Digital Signatures to PDF Documents Programmatically?

The basic signing workflow in IronPDF involves creating a PdfSignature object from a certificate and applying it to a PDF. This section covers the signing process along with options for adding metadata and configuring signature behavior.

What does Basic Certificate Signing look like in C#?

The simplest signing scenario is loading an existing PDF, creating a signature from a certificate, and saving the signed result. IronPDF handles all the cryptographic operations under the hood:

:path=/static-assets/pdf/content-code-examples/tutorials/pdf-digital-signatures-csharp-guide/basic-signing.cs
using IronPdf;
using IronPdf.Signing;

// Load the PDF document that needs to be signed
PdfDocument pdf = PdfDocument.FromFile("contract.pdf");

// Create a signature object using the certificate file path and password
var signature = new PdfSignature("certificate.pfx", "password");

// Apply the cryptographic signature to the document
// This embeds an invisible digital signature in the PDF structure
pdf.Sign(signature);

// Save the signed document to a new file
pdf.SaveAs("contract-signed.pdf");

Imports IronPdf
Imports IronPdf.Signing

' Load the PDF document that needs to be signed
Dim pdf As PdfDocument = PdfDocument.FromFile("contract.pdf")

' Create a signature object using the certificate file path and password
Dim signature As New PdfSignature("certificate.pfx", "password")

' Apply the cryptographic signature to the document
' This embeds an invisible digital signature in the PDF structure
pdf.Sign(signature)

' Save the signed document to a new file
pdf.SaveAs("contract-signed.pdf")
$vbLabelText   $csharpLabel

Input

contract.pdf - Sample contract before signing

contract.pdf - Sample contract before signing

Output

This creates a PDF with an invisible digital signature embedded in it. When opened in Adobe Acrobat or another signature aware PDF reader, the document displays signature validation info showing whether the signature is valid and whether the document has been modified since signing.

For scenarios that only require signing a document without loading it into memory for other changes, IronPDF has a streamlined one line approach:

:path=/static-assets/pdf/content-code-examples/tutorials/pdf-digital-signatures-csharp-guide/one-line-signing.cs
using IronPdf;
using IronPdf.Signing;

// One-line approach for signing PDFs
// Useful for batch processing where you don't need to manipulate the document
var signature = new PdfSignature("certificate.pfx", "password");
PdfDocument.FromFile("document.pdf").Sign(signature).SaveAs("document-signed.pdf");

Imports IronPdf
Imports IronPdf.Signing

' One-line approach for signing PDFs
' Useful for batch processing where you don't need to manipulate the document
Dim signature As New PdfSignature("certificate.pfx", "password")
PdfDocument.FromFile("document.pdf").Sign(signature).SaveAs("document-signed.pdf")
$vbLabelText   $csharpLabel

This is especially handy for batch processing when signing lots of documents without making other changes.

How should Signature Metadata be configured for Audit Trails?

Digital signatures can carry metadata that gives context about the signing event. This info shows up in the signature panel of PDF readers and adds to the document's audit trail. IronPDF supports several standard metadata fields:

:path=/static-assets/pdf/content-code-examples/tutorials/pdf-digital-signatures-csharp-guide/signature-metadata.cs
using IronPdf;
using IronPdf.Signing;
using System;

// Load the document to be signed
PdfDocument pdf = PdfDocument.FromFile("invoice.pdf");

// Create a signature with the company certificate
var signature = new PdfSignature("certificate.pfx", "password")
{
    // Add metadata to create an audit trail
    // This information appears in the signature panel of PDF readers
    SigningReason = "Invoice Approval",
    SigningLocation = "New York Office",
    SigningContact = "accounts@company.com",
    SignatureDate = DateTime.UtcNow
};

// Apply the signature with all metadata included
pdf.Sign(signature);
pdf.SaveAs("invoice-approved.pdf");

Imports IronPdf
Imports IronPdf.Signing
Imports System

' Load the document to be signed
Dim pdf As PdfDocument = PdfDocument.FromFile("invoice.pdf")

' Create a signature with the company certificate
Dim signature As New PdfSignature("certificate.pfx", "password") With {
    ' Add metadata to create an audit trail
    ' This information appears in the signature panel of PDF readers
    .SigningReason = "Invoice Approval",
    .SigningLocation = "New York Office",
    .SigningContact = "accounts@company.com",
    .SignatureDate = DateTime.UtcNow
}

' Apply the signature with all metadata included
pdf.Sign(signature)
pdf.SaveAs("invoice-approved.pdf")
$vbLabelText   $csharpLabel

Input

invoice.pdf - Invoice before signing

invoice.pdf - Invoice before signing

Output

The metadata fields serve different purposes in document workflows:

Metadata FieldPurposeExample Value
SigningReasonExplains why the document was signed"Contract approval", "Audit certification"
SigningLocationRecords where the signing occurred"New York Office", "Remote Home Office"
SigningContactProvides contact information for inquiries"legal@company.com", "+1 555 0123"
SignatureDateTimestamps the signing eventDateTime.UtcNow

In enterprise settings, these fields often tie into operational data. An invoice approval system might set the signing reason to the purchase order number, while a contract management system might include the contract ID and approval stage.

What role do Timestamp Servers play in Signature Validity over time?

Digital signatures include a timestamp showing when the document was signed, but this timestamp comes from the signing computer's local clock. For signatures that may need verification years down the road, or when proving the exact signing time matters legally, a trusted timestamp from an external Time Stamping Authority (TSA) provides much stronger evidence.

A timestamp server provides cryptographic proof that a document existed in its current form at a specific moment. Even if the signing certificate later expires or gets revoked, the timestamp shows the signature was valid when it was applied. IronPDF supports RFC 3161 timestamp servers:

:path=/static-assets/pdf/content-code-examples/tutorials/pdf-digital-signatures-csharp-guide/timestamp-server.cs
using IronPdf;
using IronPdf.Signing;
using System;

// Load the document to sign
PdfDocument pdf = PdfDocument.FromFile("agreement.pdf");
var signature = new PdfSignature("certificate.pfx", "password")
{
    SigningReason = "Agreement Execution",
    // Configure a trusted timestamp server (RFC 3161 compliant)
    // This provides cryptographic proof of when the document was signed
    TimestampHashAlgorithm = TimestampHashAlgorithms.SHA256,
    TimeStampUrl = new Uri("http://timestamp.digicert.com")
};

// Apply the signature with the trusted timestamp
pdf.Sign(signature);
pdf.SaveAs("agreement-timestamped.pdf");

Imports IronPdf
Imports IronPdf.Signing
Imports System

' Load the document to sign
Dim pdf As PdfDocument = PdfDocument.FromFile("agreement.pdf")
Dim signature As New PdfSignature("certificate.pfx", "password") With {
    .SigningReason = "Agreement Execution",
    ' Configure a trusted timestamp server (RFC 3161 compliant)
    ' This provides cryptographic proof of when the document was signed
    .TimestampHashAlgorithm = TimestampHashAlgorithms.SHA256,
    .TimeStampUrl = New Uri("http://timestamp.digicert.com")
}

' Apply the signature with the trusted timestamp
pdf.Sign(signature)
pdf.SaveAs("agreement-timestamped.pdf")
$vbLabelText   $csharpLabel

Input

agreement.pdf - Service agreement before signing

agreement.pdf - Service agreement before signing

Output

Several public timestamp servers are available for general use, including ones operated by major certificate authorities. Larger organizations may also run their own internal timestamp servers that follow company security policies.

The choice of hash algorithm matters for extended validity. SHA 256 is the current standard, though IronPDF also supports SHA 512 for stricter security requirements. Older algorithms like SHA 1 should be avoided since they're no longer considered cryptographically secure.

When should Signatures be Invisible versus Visible on the document?

Digital signatures can be applied in two modes: invisible signatures that exist only in the PDF's cryptographic structure, or visible signatures that also display a graphical representation on a designated page. The choice depends on the document's purpose and the expectations of its recipients.

Invisible signatures work well for automated document processing where human review is not expected, situations where the existing document layout should not change, and multi signature workflows where visible signatures would clutter the document.

Visible signatures are preferred when recipients expect to see visual evidence of signing, when workflows require signature placement in particular locations, or when the document will be printed and the signature should appear on paper.

The next section covers visual signature implementation in detail.

How are Visual Signature Appearances added to Digitally Signed PDFs?

Many business processes have grown up around visible signature blocks, and recipients often expect to see where and when a document was signed. IronPDF allows you to apply cryptographic protection while also showing a visible signature on the page, giving you the best of both worlds.

How can Signature Images be loaded and positioned?

A visual signature is typically an image (like a scanned handwritten signature, company seal, or styled text block) placed at a specific spot on a PDF page. IronPDF's PdfSignatureImage class handles the positioning and rendering:

:path=/static-assets/pdf/content-code-examples/tutorials/pdf-digital-signatures-csharp-guide/visual-signature.cs
using IronPdf;
using IronPdf.Signing;
using IronSoftware.Drawing;

// Load the document to sign
PdfDocument pdf = PdfDocument.FromFile("contract.pdf");
var signature = new PdfSignature("certificate.pfx", "password")
{
    SigningReason = "Contract Approval",
    SigningLocation = "Head Office"
};

// Define the position and size for the visible signature image
// Rectangle parameters: x position, y position, width, height (in points)
// Points are measured from the bottom-left corner of the page
var signatureArea = new Rectangle(150, 100, 200, 50);

// Load and attach the visual signature image
// The image will appear at the specified location on the document
signature.LoadSignatureImageFromFile(
    "signature-image.png",   // Path to the signature image file
    0,                       // Page index (0 = first page)
    signatureArea            // Position and dimensions
);

// Apply both the cryptographic signature and visual representation
pdf.Sign(signature);
pdf.SaveAs("contract-visually-signed.pdf");

Imports IronPdf
Imports IronPdf.Signing
Imports IronSoftware.Drawing

' Load the document to sign
Dim pdf As PdfDocument = PdfDocument.FromFile("contract.pdf")
Dim signature As New PdfSignature("certificate.pfx", "password") With {
    .SigningReason = "Contract Approval",
    .SigningLocation = "Head Office"
}

' Define the position and size for the visible signature image
' Rectangle parameters: x position, y position, width, height (in points)
' Points are measured from the bottom-left corner of the page
Dim signatureArea As New Rectangle(150, 100, 200, 50)

' Load and attach the visual signature image
' The image will appear at the specified location on the document
signature.LoadSignatureImageFromFile(
    "signature-image.png",   ' Path to the signature image file
    0,                       ' Page index (0 = first page)
    signatureArea            ' Position and dimensions
)

' Apply both the cryptographic signature and visual representation
pdf.Sign(signature)
pdf.SaveAs("contract-visually-signed.pdf")
$vbLabelText   $csharpLabel

Output

The coordinate system uses points (1/72 of an inch) measured from the bottom left corner of the page. For a standard US Letter page (612 x 792 points), placing a signature near the bottom right means accounting for both the signature size and appropriate margins.

Alternative methods exist for loading signature images from different sources:

:path=/static-assets/pdf/content-code-examples/tutorials/pdf-digital-signatures-csharp-guide/load-signature-image.cs
using IronPdf.Signing;
using IronSoftware.Drawing;
using System.IO;

// Create signature object
var signature = new PdfSignature("certificate.pfx", "password");
var signatureArea = new Rectangle(400, 50, 150, 75);

// Method 1: Load signature image directly from a file path
signature.LoadSignatureImageFromFile("signature.png", 0, signatureArea);

// Method 2: Load from a stream (useful for database-stored images)
using (FileStream imageStream = File.OpenRead("signature.png"))
{
    signature.LoadSignatureImageFromStream(imageStream, 0, signatureArea);
}

// Method 3: Load from AnyBitmap (IronSoftware's cross-platform image type)
AnyBitmap signatureBitmap = AnyBitmap.FromFile("signature.png");
using (var stream = signatureBitmap.ToStream())
{
    signature.LoadSignatureImageFromStream(stream, 0, signatureArea);
}

Imports IronPdf.Signing
Imports IronSoftware.Drawing
Imports System.IO

' Create signature object
Dim signature As New PdfSignature("certificate.pfx", "password")
Dim signatureArea As New Rectangle(400, 50, 150, 75)

' Method 1: Load signature image directly from a file path
signature.LoadSignatureImageFromFile("signature.png", 0, signatureArea)

' Method 2: Load from a stream (useful for database-stored images)
Using imageStream As FileStream = File.OpenRead("signature.png")
    signature.LoadSignatureImageFromStream(imageStream, 0, signatureArea)
End Using

' Method 3: Load from AnyBitmap (IronSoftware's cross-platform image type)
Dim signatureBitmap As AnyBitmap = AnyBitmap.FromFile("signature.png")
Using stream = signatureBitmap.ToStream()
    signature.LoadSignatureImageFromStream(stream, 0, signatureArea)
End Using
$vbLabelText   $csharpLabel

Supported image formats include PNG, JPEG, GIF, BMP, TIFF, and WebP. PNG files with transparency work great for signature images since the transparent background lets the underlying document content show through.

How does Signature Positioning work across Multiple Pages?

Documents requiring signatures on certain pages (like the last page of a multi page contract) need careful positioning logic. The page index parameter in PdfSignatureImage uses zero based numbering, so 0 is the first page:

:path=/static-assets/pdf/content-code-examples/tutorials/pdf-digital-signatures-csharp-guide/multi-page-signing.cs
using IronPdf;
using IronPdf.Signing;

// Load a multi-page document
PdfDocument pdf = PdfDocument.FromFile("multi-page-contract.pdf");

// Create signature - digital signatures protect the entire document
// regardless of page count
var signature = new PdfSignature("certificate.pfx", "password");

// Sign and save the document
// The signature applies to all pages in the document
pdf.Sign(signature);
pdf.SaveAs("contract-signed-last-page.pdf");

Imports IronPdf
Imports IronPdf.Signing

' Load a multi-page document
Dim pdf As PdfDocument = PdfDocument.FromFile("multi-page-contract.pdf")

' Create signature - digital signatures protect the entire document
' regardless of page count
Dim signature As New PdfSignature("certificate.pfx", "password")

' Sign and save the document
' The signature applies to all pages in the document
pdf.Sign(signature)
pdf.SaveAs("contract-signed-last-page.pdf")
$vbLabelText   $csharpLabel

Input

multi-page-contract.pdf (last page) - Signature page before signing

multi-page-contract.pdf (last page) - Signature page before signing

Output

For signatures on multiple pages (like initials on each page of a legal agreement), developers can apply image stamps separately from the cryptographic signature:

:path=/static-assets/pdf/content-code-examples/tutorials/pdf-digital-signatures-csharp-guide/initials-stamp.cs
using IronPdf;
using IronPdf.Editing;
using IronPdf.Signing;

// Load the document
PdfDocument pdf = PdfDocument.FromFile("agreement.pdf");

// Create an image stamp for initials that will appear on every page
var initialsStamp = new ImageStamper("initials.png")
{
    HorizontalAlignment = HorizontalAlignment.Right,
    VerticalAlignment = VerticalAlignment.Bottom,
    HorizontalOffset = new Length(50, MeasurementUnit.Points),
    VerticalOffset = new Length(50, MeasurementUnit.Points)
};

// Apply initials stamp to all pages
pdf.ApplyStamp(initialsStamp);

// Now apply the cryptographic signature with a full signature image on the last page
var signature = new PdfSignature("certificate.pfx", "password");
var signatureArea = new Rectangle(100, 100, 200, 100);
signature.SignatureImage = new PdfSignatureImage(
    "full-signature.png",
    pdf.PageCount - 1,    // Last page only
    signatureArea
);

// Sign the entire document cryptographically
pdf.Sign(signature);
pdf.SaveAs("agreement-initialed-and-signed.pdf");

Imports IronPdf
Imports IronPdf.Editing
Imports IronPdf.Signing

' Load the document
Dim pdf As PdfDocument = PdfDocument.FromFile("agreement.pdf")

' Create an image stamp for initials that will appear on every page
Dim initialsStamp As New ImageStamper("initials.png") With {
    .HorizontalAlignment = HorizontalAlignment.Right,
    .VerticalAlignment = VerticalAlignment.Bottom,
    .HorizontalOffset = New Length(50, MeasurementUnit.Points),
    .VerticalOffset = New Length(50, MeasurementUnit.Points)
}

' Apply initials stamp to all pages
pdf.ApplyStamp(initialsStamp)

' Now apply the cryptographic signature with a full signature image on the last page
Dim signature As New PdfSignature("certificate.pfx", "password")
Dim signatureArea As New Rectangle(100, 100, 200, 100)
signature.SignatureImage = New PdfSignatureImage(
    "full-signature.png",
    pdf.PageCount - 1,    ' Last page only
    signatureArea
)

' Sign the entire document cryptographically
pdf.Sign(signature)
pdf.SaveAs("agreement-initialed-and-signed.pdf")
$vbLabelText   $csharpLabel

This approach separates the visual elements (which can appear on multiple pages) from the cryptographic signature (which protects the entire document).

How do Multi-Party Signing Workflows function in Enterprise Applications?

Complex business processes often need multiple signatures from different people, applied in a specific order. A purchase order might need approval from a department manager, then finance review, then executive sign off. IronPDF supports these workflows through incremental saving and signature permissions.

What is Sequential Signing and how does Incremental Saving enable it?

PDF documents can store multiple revisions internally, similar to version control. Each time someone signs, that signature applies to the document's state at that moment. Later signers add their signatures to new revisions, creating a chain of approvals where each signature can be verified independently.

:path=/static-assets/pdf/content-code-examples/tutorials/pdf-digital-signatures-csharp-guide/sequential-signing-first.cs
using IronPdf;
using IronPdf.Signing;

// Load the purchase order document
PdfDocument pdf = PdfDocument.FromFile("purchase-order.pdf");

// First signer: Department Manager approves the purchase order
var managerSignature = new PdfSignature("certificate.pfx", "password")
{
    SigningReason = "Manager Approval",
    SigningLocation = "Department A"
};

// Sign the document and save
// This preserves the original state while adding the signature
pdf.Sign(managerSignature);
pdf.SaveAs("po-manager-approved.pdf");

Imports IronPdf
Imports IronPdf.Signing

' Load the purchase order document
Dim pdf As PdfDocument = PdfDocument.FromFile("purchase-order.pdf")

' First signer: Department Manager approves the purchase order
Dim managerSignature As New PdfSignature("certificate.pfx", "password") With {
    .SigningReason = "Manager Approval",
    .SigningLocation = "Department A"
}

' Sign the document and save
' This preserves the original state while adding the signature
pdf.Sign(managerSignature)
pdf.SaveAs("po-manager-approved.pdf")
$vbLabelText   $csharpLabel

Input

purchase-order.pdf - Purchase order awaiting approval

purchase-order.pdf - Purchase order awaiting approval

Output

When the document moves to the next approver, they load it and add their own signature:

:path=/static-assets/pdf/content-code-examples/tutorials/pdf-digital-signatures-csharp-guide/sequential-signing-second.cs
using IronPdf;
using IronPdf.Signing;

// Load the document that already has the manager's signature
PdfDocument pdf = PdfDocument.FromFile("po-manager-approved.pdf");

// Second signer: Finance department verifies budget availability
var financeSignature = new PdfSignature("certificate.pfx", "password")
{
    SigningReason = "Finance Approval",
    SigningLocation = "Finance Department"
};

// Add the second signature
// Both signatures remain independently verifiable
pdf.Sign(financeSignature);
pdf.SaveAs("po-finance-approved.pdf");

Imports IronPdf
Imports IronPdf.Signing

' Load the document that already has the manager's signature
Dim pdf As PdfDocument = PdfDocument.FromFile("po-manager-approved.pdf")

' Second signer: Finance department verifies budget availability
Dim financeSignature As New PdfSignature("certificate.pfx", "password") With {
    .SigningReason = "Finance Approval",
    .SigningLocation = "Finance Department"
}

' Add the second signature
' Both signatures remain independently verifiable
pdf.Sign(financeSignature)
pdf.SaveAs("po-finance-approved.pdf")
$vbLabelText   $csharpLabel

Output

Each revision maintains its own signature, and PDF readers can display the full history of who signed when.

How can you verify Existing Signatures before Adding new ones?

Before adding a new signature to a document, your code should verify that existing signatures are still valid. A document modified outside the proper workflow might have invalid signatures, which could indicate tampering or process violations.

:path=/static-assets/pdf/content-code-examples/tutorials/pdf-digital-signatures-csharp-guide/verify-signatures.cs
using IronPdf;
using System;

// Load a signed document
PdfDocument pdf = PdfDocument.FromFile("contract-signed.pdf");

// Verify all existing signatures in the document
// Returns true only if ALL signatures are valid and untampered
bool isValid = pdf.VerifyPdfSignatures();

Console.WriteLine($"Signatures Valid: {isValid}");

// Get signature details
var signatures = pdf.GetVerifiedSignatures();
Console.WriteLine($"Number of Signatures: {signatures.Count}");

Imports IronPdf
Imports System

' Load a signed document
Dim pdf As PdfDocument = PdfDocument.FromFile("contract-signed.pdf")

' Verify all existing signatures in the document
' Returns true only if ALL signatures are valid and untampered
Dim isValid As Boolean = pdf.VerifyPdfSignatures()

Console.WriteLine($"Signatures Valid: {isValid}")

' Get signature details
Dim signatures = pdf.GetVerifiedSignatures()
Console.WriteLine($"Number of Signatures: {signatures.Count}")
$vbLabelText   $csharpLabel

For more detailed inspection, you can retrieve information about each verified signature:

:path=/static-assets/pdf/content-code-examples/tutorials/pdf-digital-signatures-csharp-guide/get-verified-signatures.cs
using IronPdf;
using System;

// Load a document with multiple signatures
PdfDocument pdf = PdfDocument.FromFile("multi-signed-document.pdf");

// Retrieve detailed information about each verified signature
var verifiedSignatures = pdf.GetVerifiedSignatures();

// Iterate through all signatures to build an audit trail
foreach (var sig in verifiedSignatures)
{
    Console.WriteLine($"Signer: {sig.SignerName}");
    Console.WriteLine($"Reason: {sig.SigningReason}");
    Console.WriteLine($"Location: {sig.SigningLocation}");
    Console.WriteLine($"Date: {sig.SigningDate}");
    Console.WriteLine($"Contact: {sig.SigningContact}");
    Console.WriteLine("---");
}

Imports IronPdf
Imports System

' Load a document with multiple signatures
Dim pdf As PdfDocument = PdfDocument.FromFile("multi-signed-document.pdf")

' Retrieve detailed information about each verified signature
Dim verifiedSignatures = pdf.GetVerifiedSignatures()

' Iterate through all signatures to build an audit trail
For Each sig In verifiedSignatures
    Console.WriteLine($"Signer: {sig.SignerName}")
    Console.WriteLine($"Reason: {sig.SigningReason}")
    Console.WriteLine($"Location: {sig.SigningLocation}")
    Console.WriteLine($"Date: {sig.SigningDate}")
    Console.WriteLine($"Contact: {sig.SigningContact}")
    Console.WriteLine("---")
Next
$vbLabelText   $csharpLabel

This information enables you to build audit trails, verify approval chains, and ensure documents have all required signatures before moving to the next stage.

How does IronPDF detect Tampered Documents?

The VerifyPdfSignatures() method returns false if any signature in the document is invalid. This usually happens when content was modified after the document was signed, when the signature data itself was corrupted, when the certificate has been revoked, or when the certificate was not yet valid at the time it was used.

:path=/static-assets/pdf/content-code-examples/tutorials/pdf-digital-signatures-csharp-guide/detect-tampering.cs
using IronPdf;
using System;

// Load a signed document and verify
PdfDocument pdf = PdfDocument.FromFile("contract-signed.pdf");

// Check if all signatures are still valid
bool isValid = pdf.VerifyPdfSignatures();

if (isValid)
{
    Console.WriteLine("Document has not been tampered with");
    Console.WriteLine("All signatures are valid");
}
else
{
    Console.WriteLine("WARNING: Document may have been tampered with!");
    Console.WriteLine("One or more signatures are invalid");
}

Imports IronPdf
Imports System

' Load a signed document and verify
Dim pdf As PdfDocument = PdfDocument.FromFile("contract-signed.pdf")

' Check if all signatures are still valid
Dim isValid As Boolean = pdf.VerifyPdfSignatures()

If isValid Then
    Console.WriteLine("Document has not been tampered with")
    Console.WriteLine("All signatures are valid")
Else
    Console.WriteLine("WARNING: Document may have been tampered with!")
    Console.WriteLine("One or more signatures are invalid")
End If
$vbLabelText   $csharpLabel

For applications requiring signature removal (perhaps to create an unsigned copy for redistribution), IronPDF has the RemoveSignatures() method:

:path=/static-assets/pdf/content-code-examples/tutorials/pdf-digital-signatures-csharp-guide/remove-signatures.cs
using IronPdf;

// Load a signed document
PdfDocument pdf = PdfDocument.FromFile("signed-template.pdf");

// Remove all digital signatures from the document
// This strips signature data but does not restore previous document state
pdf.RemoveSignatures();

// Save as an unsigned version
pdf.SaveAs("unsigned-template.pdf");

Imports IronPdf

' Load a signed document
Dim pdf As PdfDocument = PdfDocument.FromFile("signed-template.pdf")

' Remove all digital signatures from the document
' This strips signature data but does not restore previous document state
pdf.RemoveSignatures()

' Save as an unsigned version
pdf.SaveAs("unsigned-template.pdf")
$vbLabelText   $csharpLabel

Note that removing signatures does not recover any previous document state. The method simply strips the signature data from the current document version.

What Technical Capabilities support Regulatory Compliance for PDF Signatures?

Digital signature regulations differ across jurisdictions and industries, but they share common technical needs around certificate validation, timestamping, and signature metadata. Instead of attempting to interpret specific legal mandates (which you should discuss with qualified legal counsel), this section focuses on the technical capabilities that compliance frameworks generally demand.

What are the key Regulatory Frameworks for Digital Signatures?

The following table summarizes common regulatory frameworks and their general technical requirements:

FrameworkJurisdictionKey Technical Requirements
ESIGN ActUnited StatesIntent to sign, consent to electronic records, record retention
UETAUS StatesSimilar to ESIGN, applies to intrastate transactions
eIDASEuropean UnionThree signature levels (simple, advanced, qualified); qualified requires QSCD
21 CFR Part 11US FDAElectronic signatures must be linked to electronic records, audit trails required

These frameworks generally recognize digital signatures as legally equivalent to handwritten signatures when properly implemented. The evidentiary value of a digital signature often depends on proving that the signature was valid when it was applied, which is where trusted timestamps become essential for document retention over years or decades.

:path=/static-assets/pdf/content-code-examples/tutorials/pdf-digital-signatures-csharp-guide/compliance-signing.cs
using IronPdf;
using IronPdf.Signing;
using System;

// Load the compliance document
PdfDocument pdf = PdfDocument.FromFile("compliance-document.pdf");
var signature = new PdfSignature("certificate.pfx", "password")
{
    // Add comprehensive metadata for audit trail requirements
    SigningReason = "21 CFR Part 11 Compliance Certification",
    SigningLocation = "Quality Assurance Department",
    SigningContact = "compliance@company.com",
    SignatureDate = DateTime.UtcNow,
    // Configure a trusted timestamp for regulatory compliance
    // The timestamp proves when the signature was applied
    TimestampHashAlgorithm = TimestampHashAlgorithms.SHA256,
    TimeStampUrl = new Uri("http://timestamp.digicert.com")
};

// Apply the signature with timestamp and full metadata
pdf.Sign(signature);
pdf.SaveAs("compliance-document-certified.pdf");

Imports IronPdf
Imports IronPdf.Signing
Imports System

' Load the compliance document
Dim pdf As PdfDocument = PdfDocument.FromFile("compliance-document.pdf")
Dim signature As New PdfSignature("certificate.pfx", "password") With {
    ' Add comprehensive metadata for audit trail requirements
    .SigningReason = "21 CFR Part 11 Compliance Certification",
    .SigningLocation = "Quality Assurance Department",
    .SigningContact = "compliance@company.com",
    .SignatureDate = DateTime.UtcNow,
    ' Configure a trusted timestamp for regulatory compliance
    ' The timestamp proves when the signature was applied
    .TimestampHashAlgorithm = TimestampHashAlgorithms.SHA256,
    .TimeStampUrl = New Uri("http://timestamp.digicert.com")
}

' Apply the signature with timestamp and full metadata
pdf.Sign(signature)
pdf.SaveAs("compliance-document-certified.pdf")
$vbLabelText   $csharpLabel

Input

compliance-document.pdf - Compliance document awaiting certification

compliance-document.pdf - Compliance document awaiting certification

Output

What Certificate Requirements apply to Regulated Industries?

Different regulatory contexts may specify criteria for the certificates used in signing. These criteria might include issuance by accredited authorities, minimum key lengths (usually 2048 bit RSA or equivalent), particular extended key usage attributes, or hardware based key storage using HSM or smart card solutions.

IronPDF works with any X.509 certificate that meets standard format specs, allowing you to use certificates from your preferred certificate authority. For environments requiring hardware protected keys, IronPDF supports PKCS#11 based HSM integration through its HsmSigner functionality.

Those in regulated industries should work with their legal and compliance departments to nail down what's needed, then set up signing infrastructure to match.

How does Signature Permission Control support Document Lifecycle Management?

After signing, documents sometimes need to stay editable for specific purposes, like letting additional signers add their signatures or allowing form fields to be filled. IronPDF's SignaturePermissions enumeration controls what changes are allowed after signing:

:path=/static-assets/pdf/content-code-examples/tutorials/pdf-digital-signatures-csharp-guide/signature-permissions.cs
using IronPdf;
using IronPdf.Signing;

// Load a form document that needs signing
PdfDocument pdf = PdfDocument.FromFile("approval-form.pdf");

// Sign with specific permissions for document lifecycle management
// FormFillingAllowed permits form completion after signing
pdf.SignWithFile(
    "approver-cert.pfx",
    "password",
    SignaturePermissions.FormFillingAllowed
);

// Save the signed document with form-filling permissions enabled
pdf.SaveAs("approval-form-signed.pdf");

Imports IronPdf
Imports IronPdf.Signing

' Load a form document that needs signing
Dim pdf As PdfDocument = PdfDocument.FromFile("approval-form.pdf")

' Sign with specific permissions for document lifecycle management
' FormFillingAllowed permits form completion after signing
pdf.SignWithFile(
    "approver-cert.pfx",
    "password",
    SignaturePermissions.FormFillingAllowed
)

' Save the signed document with form-filling permissions enabled
pdf.SaveAs("approval-form-signed.pdf")
$vbLabelText   $csharpLabel

The available permission levels are:

Permission LevelAllowed Changes After Signing
NoChangesAllowedDocument is completely locked
FormFillingAllowedOnly form fields can be filled; no content changes
FormFillingAndAnnotationsAllowedForm filling plus annotations permitted

The appropriate permission level depends on the document's role. A completed agreement might use NoChangesAllowed, while an approval form still in progress might allow form filling to collect additional info.

When does building Custom Signing make more sense than using External Services?

Anyone implementing document signing faces a fundamental architecture decision: build signing capabilities into their own applications or use hosted signing services. Both approaches have their place, and the right choice depends on volume, customization demands, compliance considerations, and total cost of ownership.

What factors favor building Internal Signing Capabilities?

Here are some scenarios where building signing functionality directly into applications makes sense:

High document volumes make per transaction pricing expensive at scale. Businesses processing thousands of documents monthly often find that perpetual license libraries like IronPDF provide better financial sense than per signature API fees. A one time license investment pays for itself quickly compared to ongoing transaction costs.

Unique process requirements arise when external signing services come with their own paradigms. Teams with unusual approval flows, specialized document handling, or integration demands that don't fit standard offerings often find building their own solution easier than trying to adapt to a service's limitations.

Data sovereignty and security policies prevent some companies from sending documents to external services due to regulations, security policies, or contractual obligations. Keeping the signing process in house ensures documents stay within corporate boundaries throughout.

Offline or air gapped environments cannot rely on hosted solutions that need network connectivity. Applications that must work in disconnected settings (field service apps, classified systems, or places with spotty internet) need locally implemented signing capabilities.

Cost predictability matters because subscription based pricing creates ongoing expenses that accumulate. Perpetual library licenses provide stable costs that finance departments can plan around without worrying about volume swings or price hikes.

What scenarios favor Hosted Signing Solutions?

Hosted solutions work well in different circumstances:

Low volume with diverse signing parties occurs when documents need signatures from people outside your company who don't have their own certificates. Services that handle identity verification and certificate issuance reduce friction. Building that infrastructure internally rarely pays off for occasional use.

Rapid deployment matters when you need to get signing up and running fast without dev resources to build from scratch. These platforms come with ready made user interfaces and email notifications that provide turnkey capabilities.

Compliance delegation becomes valuable when vendors specialize in specific regulatory frameworks and can provide certifications or attestations that would be expensive to obtain independently.

The decision often comes down to whether signing is a core competency worth investing in or a commodity function better left to specialists. Businesses that handle documents as a central part of their operations (law firms, financial institutions, healthcare providers, government agencies) usually get better returns from owning their signing infrastructure. Those where document signing is secondary may prefer the simplicity of outsourced options.

How can Development Teams evaluate their Signing Infrastructure Needs?

Before committing to either approach, consider these factors:

Current and projected volume drives your cost analysis. How many documents need signatures now, and how will that change over time?

Integration considerations influence your architecture. How will signing fit into existing applications and workflows? Libraries offer maximum flexibility, while external platforms may require adapting to their APIs and user interfaces.

Signing party types affect complexity. Will documents be signed only by internal users with managed certificates, or will you need to accommodate outside signers as well?

Compliance landscape dictates technical requirements. What regulations apply, and how do they affect your implementation choices? Some mandates are easier to meet with services; others require internal control.

Technical resources determine feasibility. Does the team have the bandwidth to implement and maintain signing functionality, or would that pull focus from core development priorities?

Conclusion

Building digital signatures into .NET applications means understanding both the cryptographic fundamentals and the practical needs that drive business document processing. IronPDF provides the technical foundation for certificate based signing, visual signature rendering, multi party workflow support, and signature verification while leaving the architectural decisions about when and how to use these features to developers who know their specific requirements.

The capabilities covered in this guide provide the building blocks for solid signing implementations, whether you're automating contract execution, implementing approval chains, or meeting compliance requirements. For organizations ready to add PDF signing to their .NET applications, IronPDF offers a straightforward path from concept to production with comprehensive documentation and responsive support.

IronPDF offers a free trial that allows you to test digital signature functionality during development. You can evaluate certificate-based signing, signature verification, and multi-party workflows with your actual documents before making any purchasing decisions. Visit ironpdf.com to download the library and access additional documentation, code samples, and support resources.

Frequently Asked Questions

What is a digital signature in the context of PDFs?

A digital signature is a cryptographic mechanism used to verify the authenticity and integrity of a PDF document. It ensures that the document has not been altered and confirms the identity of the signer.

How can I implement digital signatures in C# using IronPDF?

IronPDF provides a straightforward API to implement digital signatures in PDFs using C#. You can sign documents programmatically by using certificate signing, adding visual signatures, and managing multi-party workflows.

What types of digital signatures does IronPDF support?

IronPDF supports various types of digital signatures, including certificate-based signatures, visual signatures, and those requiring timestamp servers for additional verification.

Can I verify a digital signature in a PDF using IronPDF?

Yes, IronPDF includes features for verifying digital signatures in PDF documents, ensuring that the document is authentic and has not been tampered with since it was signed.

What is the role of a timestamp server in digital signatures?

A timestamp server provides a trusted time source to confirm when a digital signature was applied to a document. This adds an extra layer of security by verifying the exact time of signing.

How do visual signatures differ from digital certificates?

Visual signatures display a graphical representation of a signature on a document, whereas digital certificates provide cryptographic proof of authenticity and integrity without necessarily displaying a visual mark.

Can IronPDF handle multi-party signature workflows?

Yes, IronPDF is capable of managing multi-party signature workflows, allowing multiple parties to sign a document in a coordinated and secure manner.

What are the benefits of using digital signatures in PDF documents?

Digital signatures enhance security by ensuring document integrity and authenticity. They also streamline workflows by enabling electronic signing, which is faster and more efficient than traditional methods.

Is it possible to sign PDFs programmatically without user interaction?

Yes, with IronPDF, you can sign PDFs programmatically in C# without requiring user interaction, making it ideal for automated workflows and batch processing.

Curtis Chau
Curtis Chau
  Chat with engineering team now
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 17,269,395 | Version: 2026.1 just released