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

A Developer's Guide to Digitally Signing PDFs with C#

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
Updated: October 2, 2026

This guide shows C# developers how to digitally sign PDFs using IronPDF, covering certificate-based signatures, visual stamps, and interactive form fields to ensure document authenticity and security.

Adding a signature to a PDF document is a common requirement in many applications, but "signing" can mean different things. For some, it's about applying a tamper-proof digital signature using a security certificate. For others, it might be stamping a visual, handwritten signature image onto a document or adding an interactive form field for users to sign electronically.

This guide provides a comprehensive walkthrough for C# developers on how to accomplish all of these tasks using the IronPDF for .NET library. We will cover everything from applying a secure X509Certificate2 digital signature to stamping graphical signatures and creating interactive signature fields, ensuring your PDF documents are authentic, secure, and professional.

Quickstart: Effortlessly Digitally Sign a PDF Using IronPDF

Get started quickly with IronPDF to digitally sign your PDF documents using a simple, straightforward process. This example demonstrates how to use a .pfx certificate to authenticate and sign a PDF file, ensuring document integrity and authenticity. Follow these steps to integrate digital signing into your application.

  1. 1Install IronPDF with NuGet Package Manager

    PM > Install-Package IronPdf

  2. 2Copy and run this code snippet.

    IronPdf.PdfDocument.FromFile("input.pdf").SignWithFile("certificate.pfx", "password").SaveAs("signed.pdf");

  3. 3Deploy to test on your live environment

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

Minimal Workflow (5 steps)

IronPDF tutorial showing 5 steps to digitally sign PDF files in C# with installation command
  1. Install the IronPDF library for .NET.
  2. Apply a digital signature using an X509Certificate2 object.
  3. Add a visual image to represent the digital signature.
  4. Stamp a graphical or handwritten signature onto a PDF file.
  5. Add an interactive signature form field for electronic signing.

How Do I Apply a Digital Signature to a PDF with a Certificate?

You can apply a digital signature to a PDF document using a digital certificate file (such as .pfx or .p12) to guarantee the document's authenticity and integrity. This process ensures that the document has not been altered since it was signed. For a complete overview of digital signing capabilities, explore our comprehensive digital signatures guide.

IronPDF provides a straightforward API for this purpose, supporting multiple ways to apply a digital signature. The core of this functionality revolves around the PdfSignature class, which encapsulates the certificate and all associated metadata for the signature.

Signing MethodDescription
SignSigns a PDF with a PdfSignature object that you create and configure.
SignWithFileSigns a PDF using a digital signature certificate file (.pfx or .p12) located on disk.
SignWithStoreSigns a PDF with a digital signature from your computer's certificate store, identified by its thumbprint ID.

Using an X509Certificate2 Object

For maximum control, you can create an X509Certificate2 object from your certificate file. IronPDF fully complies with the X509Certificate2 standard, providing a reliable and secure method for digital signature implementation. When creating the certificate object, ensure the X509KeyStorageFlags are set to Exportable, as this is required by the underlying cryptographic APIs. Check out practical examples of digital signatures in our code repository.

PM > Install-Package IronPdf

using IronPdf;
using IronPdf.Signing;
using System.Security.Cryptography.X509Certificates;

// Create a new PDF from an HTML string for demonstration.
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Signed Document</h1><p>This document has been digitally signed.</p>");

// Load the certificate from a .pfx file with its password.
// The X509KeyStorageFlags.Exportable flag is crucial for allowing the private key to be used in the signing process.
var cert = new X509Certificate2("IronSoftware.pfx", "123456", X509KeyStorageFlags.Exportable);

// Create a PdfSignature object using the loaded certificate.
var signature = new PdfSignature(cert);

// Apply the signature to the PDF document.
pdf.Sign(signature);

// Save the securely signed PDF document.
pdf.SaveAs("Signed.pdf");

The code above first generates a simple PDF. It then loads a .pfx certificate file into an X509Certificate2 object. This object, which represents the digital identity, is passed to the PdfSignature constructor. Finally, the pdf.Sign method applies this signature to the document before saving it. For more information on the X509Certificate2 class, you can refer to the official Microsoft documentation.

Adding Granular Details to a Digital Signature

A digital signature can contain more than just the certificate; you can embed rich metadata to provide context about the signature. This includes the signing location, reason, contact information, and a secure timestamp from a trusted authority. You can also set and edit metadata for additional document properties.

Adding these details improves the document's audit trail and provides verifiers with valuable information. IronPDF also supports timestamping servers that use modern SHA256 and SHA512 hash algorithms.

TimeStampUrl takes the TSA endpoint as a string. Set TimestampHashAlgorithm explicitly alongside it rather than relying on the default: as of version 2026.8.1 that default is SHA1, and a growing number of timestamp authorities reject SHA-1 imprints outright.

The same two properties are available when signing with an HSM, so a document signed on a hardware token can carry a trusted timestamp too.

using IronPdf;
using IronPdf.Signing;
using IronSoftware.Drawing;
using System;

// Load an existing PDF document to be signed.
var pdf = PdfDocument.FromFile("invoice.pdf");

// Create a PdfSignature object directly from the certificate file and password.
var signature = new PdfSignature("IronSoftware.pfx", "123456");

// Add detailed metadata to the signature for a comprehensive audit trail.
// These properties enhance the signature's credibility and provide context
signature.SignatureDate = DateTime.Now;
signature.SigningContact = "legal@ironsoftware.com";
signature.SigningLocation = "Chicago, USA";
signature.SigningReason = "Contractual Agreement";

// Add a secure timestamp from a trusted Time Stamp Authority (TSA).
// This provides cryptographic proof of the signing time.
signature.TimeStampUrl = "http://timestamp.digicert.com";
signature.TimestampHashAlgorithm = TimestampHashAlgorithms.SHA256;

// Apply a visual appearance to the signature. (More on this in the next section)
signature.SignatureImage = new PdfSignatureImage("assets/visual-signature.png", 0, new Rectangle(350, 750, 200, 100));

// Sign the PDF document with the configured signature object.
pdf.Sign(signature);

// Save the final, signed PDF document.
pdf.SaveAs("DetailedSignature.pdf");

You may notice a warning icon in some PDF viewers if the signing certificate is not in the system's trusted store. To get a green checkmark, the certificate must be added to the viewer's trusted identities.

How Can I Add a Visual Representation to a Digital Signature?

While a digital signature is cryptographically embedded in the PDF, it's often useful to have a visual representation on the page. This can be a company logo, a handwritten signature image, or other graphics. IronPDF makes it easy to add an image to a PdfSignature object.

You can load an image from a file or a stream and position it precisely on any page of the PDF. Supported image formats include PNG, JPEG, GIF, BMP, TIFF, and WebP. This technique is similar to how you might stamp text and images on PDF documents.

using IronPdf.Signing;
using IronSoftware.Drawing;

// This example demonstrates various ways to add a visual image to a PDF signature.

// Create a PdfSignature object.
var signature = new PdfSignature("IronSoftware.pfx", "123456");

// Define the position and size for the signature image on the first page (index 0).
// Rectangle parameters: x position, y position, width, height
var signatureRectangle = new Rectangle(350, 750, 200, 100);

// Option 1: Set the SignatureImage property directly.
// This is the most straightforward approach
signature.SignatureImage = new PdfSignatureImage("assets/visual-signature.png", 0, signatureRectangle);

// Option 2: Use the LoadSignatureImageFromFile method.
// This method provides the same functionality with a different syntax
signature.LoadSignatureImageFromFile("assets/visual-signature.png", 0, signatureRectangle);

// Option 3: Load an image from a stream. This is useful for images generated in memory.
// Perfect for scenarios where images are retrieved from databases or web services
AnyBitmap image = AnyBitmap.FromFile("assets/visual-signature.png");
using (var imageStream = image.ToStream())
{
    signature.LoadSignatureImageFromStream(imageStream, 0, signatureRectangle);
}

// After configuring the signature image, apply it to a PDF.
var pdf = PdfDocument.FromFile("invoice.pdf");
pdf.Sign(signature);
pdf.SaveAs("VisualSignature.pdf");

This code showcases three equivalent ways to add a visual component to a digital signature. Whether you have an image on disk or in memory, you can easily stamp it onto the PDF as part of the signing process. This bridges the gap between invisible cryptographic security and visible document approval.

How Do I Sign an Existing Named Signature Field?

A supplied form often arrives with its signature blocks already placed and named: a government form with one block for the preparer and another for the approver. Set SignatureFieldName to the name of one of those fields and IronPDF fills it where it sits, keeping the position and appearance the form author defined, instead of appending a new field.

using IronPdf;
using IronPdf.Signing;

// A form that already contains named signature blocks
PdfDocument pdf = PdfDocument.FromFile("dd-form-200.pdf");

PdfSignature signature = new PdfSignature("cert.pfx", "password")
{
    // Name of an existing, unsigned signature field
    SignatureFieldName = "ApproverSignature"
};

// Fills that field where the form author placed it
pdf.Sign(signature);
pdf.SaveAs("signed.pdf");
C#

Use the Name of the signature form field as the document exposes it. Leave SignatureFieldName unset, empty, or whitespace and signing behaves exactly as it always has, appending a new field.

Signing throws if no unsigned field with that name exists, or if every field with that name has already been signed. The error message names the field, so a typo is easy to spot.

Warning: SignatureFieldName cannot be combined with SignatureImage. Applying an image repositions the field, which would move the block the form author placed, so the combination throws NotSupportedException. Sign the named field without an image, or leave SignatureFieldName unset to append a new field you can position freely.
Please note: SignaturePermissions has no effect on this path. Filling a pre-placed field always produces a plain approval signature with no certification permissions attached, so a permission value passed alongside SignatureFieldName is inert rather than wrong. Certification permissions apply when signing appends a new field, which is typically the first or author signature.

Deployments running IronPdfEngine or Docker need an engine build that includes this feature. An older engine does not recognise the field name and silently falls back to appending a new field, leaving the named block blank — so match the engine version to the library version.

How Can I Control Document Permissions After Signing?

When you sign a document, you might want to specify what changes, if any, are permitted afterward. For example, you might want to lock the document completely or only allow users to fill in form fields. IronPDF lets you set these permissions using the SignaturePermissions enumeration. For more advanced permission control, see our guide on setting PDF passwords and permissions.

Setting signature permissions is a key part of managing a document's lifecycle. It ensures that the document's integrity is maintained according to your rules after your signature is applied. If a user performs a disallowed action, the signature will be invalidated.

These values are the standard PDF DocMDP certification permissions defined by ISO 32000 and written into the signature itself, so Adobe Acrobat and other conforming readers honour them. Each one describes what a later party may do to the document without invalidating this signature.

SignaturePermissions MemberDocMDP levelWhat a later party may do
NoChangesAllowed1Nothing. The document is effectively locked.
AdditionalSignaturesAndFormFillingAllowed2Add another signature and fill form fields.
AdditionalSignaturesFormFillingAndAnnotationsAllowed3Add another signature, fill form fields, and create or modify annotations.

How Many Signatures Can One Save Carry?

One. A PdfDocument accepts a single new signature per save, and adding a second to the same open document throws NotSupportedException at the point the second signature is added — whether or not the save is incremental.

This is a property of how PDF signing works rather than a policy choice. A signature covers the file up to its own placeholder, so a second signature added to the same revision alters bytes the first one already signed. Only the last signature could ever verify. Earlier versions allowed the pattern and produced exactly that: a document where the earlier signatures were silently invalid. Signing now refuses instead.

So pdf.Sign(a).Sign(b).SaveAs(...) no longer works, and neither does calling Sign() twice on the same object.

How Do Several Parties Sign the Same Document?

Multi-party signing is fully supported. The rule is one signature per revision, not one signature per document. Each party signs their own incremental revision:

PdfDocument.FromFile("form.pdf").Sign(signatureA).SaveAs("step1.pdf");
PdfDocument.FromFile("step1.pdf").Sign(signatureB).SaveAsRevision("step2.pdf");
C#

The revision history then holds two revisions with one signature each, and both verify. AdditionalSignaturesAndFormFillingAllowed on the first signature is what permits the second party's revision without invalidating the first.

Tips: SaveAsRevision("step2.pdf") writes the revision straight to disk. Called with no path, it returns the revision in memory for a later SaveAs.
Please note: SignaturePermissions and the one-signature-per-save rule are separate ideas and easy to conflate. The permission is written into the signed document and governs what a later party may do to it. The rule governs how many Sign() calls you may batch before a single save. A permission allowing additional signatures does not allow two signatures in one save, and the rule does not restrict what later revisions may add.

Saving and Signing a Specific PDF Revision

PDFs can store a history of changes, much like a version control system. This is known as incremental saving. When you sign a PDF, the signature applies to a specific revision of the document. This is crucial for workflows where a document goes through multiple stages of approval. Learn more about managing PDF revision history in our detailed guide.

In the following example, we load a PDF, make edits, and then sign the current revision while allowing only form-filling as a future change. We use SaveAsRevision to commit the current state to the document's history before saving the file.

Understanding incremental saves is key to advanced PDF workflows. While a simple viewer might only show the latest version, a tool like Adobe Acrobat can reveal the entire revision history, showing who signed which version and what changes were made between signatures. IronPDF gives you full programmatic control over this process.

For businesses managing complex document workflows that require high security and compliance, a comprehensive solution may be needed. Iron Software offers Iron Suite, which includes IronPDF for signing and manipulation, plus other libraries for a wide range of document processing tasks, available for a single one-time payment.

How Can I Manage and Verify Signatures Across Revisions?

A PDF document can have multiple signatures applied across its various revisions. IronPDF provides tools to manage this history effectively.

  • Roll Back to a Previous Revision: You can revert a document to an earlier state using the RollBackToRevision method. This will discard all changes and signatures made after that revision.
  • Verify All Signatures: The VerifyAllSignatures method checks the validity of all signatures across all revisions of the document. It returns SignatureStatus.Valid only if every signature is valid and no unauthorized changes have been made.
  • Remove Signatures: The RemoveSignatures method will strip all digital signatures from every revision of the document, creating a clean, unsigned version.
// Load a PDF with a complex signature history.
var pdf = PdfDocument.FromFile("multi_signed_report.pdf");

// Verify all signatures across all revisions.
// This ensures document integrity throughout its entire history
bool allSignaturesValid = pdf.VerifySignatures();
Console.WriteLine($"All signatures are valid: {allSignaturesValid}");

// Roll back to the first revision (index 0).
// Useful for reviewing the original document state
if (pdf.RevisionCount > 1)
{
    PdfDocument firstRevision = pdf.GetRevision(0);
    firstRevision.SaveAs("report_first_revision.pdf");
}

// Create a completely unsigned version of the document.
// This removes all digital signatures while preserving content
pdf.RemoveSignatures();
pdf.SaveAs("report_unsigned.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 Do I Stamp a Handwritten Signature onto a PDF?

Sometimes, you don't need the cryptographic security of a digital signature but simply want to apply a visual, electronic signature, like a scanned handwritten signature. This is often referred to as stamping. IronPDF can do this using its Watermark or Stamp features. For more advanced watermarking options, explore our custom watermarks guide.

Let's start with a sample invoice PDF and a .png image of a handwritten signature.

The original invoice PDF before stamping a signature.

Here is the signature image we will apply:

Handwritten signature sample showing 'IRON' in black ink for PDF stamping tutorial A sample handwritten signature image.

The following code uses the SignatureImage property to stamp this image onto the bottom-right corner of the PDF.

using IronPdf;
using IronPdf.Editing;

// Load the existing PDF document.
var pdf = PdfDocument.FromFile("invoice.pdf");

// Create an HtmlStamper containing our signature image.
// HtmlStamper allows us to position HTML content precisely on the page
var signatureStamp = new HtmlStamper("<img src='assets/signature.png'/>")
{
    // Configure the stamp's position and appearance.
    VerticalAlignment = VerticalAlignment.Bottom,
    HorizontalAlignment = HorizontalAlignment.Right,
    HorizontalOffset = new Length(-10, MeasurementUnit.Pixel),  // Add some space from the edge.
    VerticalOffset = new Length(-10, MeasurementUnit.Pixel),
    Opacity = 90  // Make it slightly transparent for a more authentic look.
};

// Apply the stamp to all pages of the PDF.
// You can also specify specific page numbers if needed
pdf.ApplyStamp(signatureStamp);

// Save the modified PDF document.
pdf.SaveAs("official_invoice.pdf");

What Does the Stamped PDF Result Look Like?

After running the code, the signature image is stamped onto the document, creating a visually signed invoice.

The final PDF with the handwritten signature image stamped in the bottom-right corner.

How Can I Add an Interactive Signature Field to a PDF?

For documents that need to be signed by an end-user in a PDF viewer like Adobe Acrobat, you can add an interactive signature form field. This creates an empty, clickable area that prompts the user to apply their own digital signature. For a complete guide on PDF forms, see our creating PDF forms tutorial.

You can create a SignatureFormField and add it to the PDF's form collection. You have precise control over its location and size on the page. This is particularly useful for documents that require multiple signatures or when you need to collect signatures from external parties.

using IronPdf.Forms;
using IronSoftware.Drawing;

// Create a new PDF to add the signature field to.
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Please Sign Below</h1>");

// Define the properties for the signature form field.
string fieldName = "ClientSignature";  // Unique identifier for the field
int pageIndex = 0;  // Add to the first page (zero-indexed)
var fieldRect = new Rectangle(50, 200, 300, 100);  // Position: (x, y), Size: (width, height)

// Create the SignatureFormField object.
// This creates an interactive field that users can click to sign
var signatureField = new SignatureFormField(fieldName, pageIndex, fieldRect);

// Add the signature field to the PDF's form.
pdf.Form.Add(signatureField);

// Save the PDF with the new interactive signature field.
pdf.SaveAs("interactive_signature.pdf");

When a user opens this PDF, they will see a clickable field, allowing them to complete the signing process using their own digital ID. You can learn more about creating and managing interactive forms in our How-To guide on creating PDF forms.

PDF editor showing unsigned signature field with 'Click to sign' prompt in document titled 'testing' An unsigned, interactive signature field added programmatically to a PDF document.

How Do I Retrieve the Signer Name from Verified Signatures?

To obtain the common name of the certificate owner who signed a signature, we can use the VerifiedSignature class to access the SignerName property. Below is a code snippet demonstrating how to accomplish this.

using IronPdf;
using System;

// Import the Signed PDF report
var pdf = PdfDocument.FromFile("multi_signed_report.pdf");

// Using GetVerifiedSignatures() obtain a list of `VerifiedSignature` objects from the PDF
pdf.GetVerifiedSignatures().ForEach(signature =>
{
    // Print out the SignerName of each `VerifiedSignature` object
    Console.WriteLine($"SignatureName: {signature.SignerName}");
});

After importing the signed PDF file, we utilize the GetSignatures(...) method to retrieve a list of VerifiedSignature objects within the report and print the SignerName for each signature.

Please note that this value is extracted from the certificate's Subject Distinguished Name (SubjectDN) and will return null if the CN field is not present.

What Are the Next Steps for PDF Signing with IronPDF?

This guide has demonstrated the powerful and flexible PDF signing capabilities of IronPDF. Whether you need to apply secure digital signatures with detailed metadata, manage document revisions, stamp visual signatures, or create interactive forms, IronPDF provides a comprehensive and developer-friendly API to get the job done.

To continue exploring, you can download the IronPDF library for .NET and get a free trial license to test out all its features in your projects. For more advanced document manipulation techniques, including adding annotations and working with form fields, check out our extensive documentation and tutorials.

Ready to see what else you can do? Check out our tutorial page here: Sign and Secure PDFs

Frequently Asked Questions

How can I digitally sign a PDF using IronPDF with a certificate?

To digitally sign a PDF using IronPDF with a certificate, you can use an `X509Certificate2` object to apply a secure digital signature. This ensures the document's authenticity and integrity by making use of the `PdfSignature` class. The process involves loading the certificate file, creating a `PdfSignature` object, and applying the signature to your PDF file.

What are the steps to add a visual image as a digital signature in IronPDF?

To add a visual image as a digital signature in IronPDF, first create a `PdfSignature` object with your certificate. Then, add your signature image to the `SignatureImage` property, specifying its position and size. This image can be loaded from a file or stream, and then be stamped onto your PDF document using methods like `LoadSignatureImageFromFile` or `LoadSignatureImageFromStream`.

Can I add an interactive signature field to a PDF in IronPDF?

Yes, you can add an interactive signature field to a PDF using IronPDF. This is done with the `SignatureFormField` class where you define the field's properties, such as name, position, and size. The added field will allow users to digitally sign the PDF in a compatible viewer.

What methods does IronPDF offer to verify all signatures in a PDF document?

IronPDF allows you to verify all signatures in a PDF using the `VerifyAllSignatures` method. This method checks the validity of all signatures across all revisions of the document. It confirms the integrity of the document by ensuring that no unauthorized changes have been made since signing.

How can I manage document permissions after signing a PDF with IronPDF?

With IronPDF, you can control document permissions using the `SignaturePermissions` enumeration after signing a PDF. Options include `NoChangesAllowed` for complete locking, `FormFillingAllowed` to permit only form filling, and `AnnotationsAndFormFillingAllowed` for additional annotation capabilities.

How does IronPDF handle the timestamping of digital signatures?

IronPDF supports advanced timestamping of digital signatures using secure timestamp servers. This involves setting a `TimeStampUrl` and a `TimestampHashAlgorithm` like `SHA256` within the `PdfSignature` object. This provides cryptographic proof of when the document was signed.

What feature does IronPDF provide for adding handwritten-looking signatures to PDFs?

IronPDF allows you to stamp handwritten-looking signatures onto PDFs using its watermark or stamp features. You can load an image of the signature and position it on the document, creating a visually signed PDF without the cryptographic elements of a digital signature.

How can I retrieve the signer's name from a verified signature in a PDF using IronPDF?

To retrieve the signer's name from a verified signature, use the `GetVerifiedSignatures` method in IronPDF, which returns a list of `VerifiedSignature` objects. From this list, access the `SignerName` property to get the common name extracted from the certificate used for signing.

Is it possible to roll back to a previous revision of a signed PDF document in IronPDF?

Yes, IronPDF allows you to roll back to a previous revision of a signed PDF document using the `RollBackToRevision` method. This feature is useful for reviewing the previous document state and managing multiple stages of document approval.

What steps should I take to get started with PDF signing using IronPDF?

To get started with PDF signing using IronPDF, download the IronPDF library for .NET and explore the comprehensive examples and documentation provided. You may also obtain a free trial license to test out features like digital and visual signatures, signature fields, and more in your projects.

How do I sign into an existing named signature field in a PDF?

Set the SignatureFieldName property on PdfSignature to the Name of an existing, unsigned signature form field. IronPDF fills that field where the form author placed it instead of appending a new one, which is what forms with multiple named signature blocks require. Signing throws if no unsigned field with that name exists, and the error message names the field. SignatureFieldName cannot be combined with SignatureImage, because applying an image repositions the field.

Why does signing a PDF twice throw a NotSupportedException?

A PdfDocument carries one new signature per save. A signature covers the file up to its own placeholder, so a second signature added to the same revision would alter bytes the first already signed, leaving only the last one valid. Signing refuses rather than producing a silently invalid document. To have several parties sign, give each their own incremental revision: sign and save, then reopen and sign again with SaveAsRevision.

Why is only the last signature valid when I sign several fields in one go?

Each signature covers the file up to its own placeholder, so adding a second signature before saving changes bytes the first one already signed, and only the last one verifies. Earlier versions allowed this and produced documents with silently invalid signatures; current versions throw NotSupportedException instead. Give each signature its own incremental revision, following the one-signature-per-save pattern: sign and save, then reopen and sign again with SaveAsRevision.

What is the difference between SignaturePermissions and the one-signature-per-save rule?

They are separate ideas. SignaturePermissions is a standard PDF certification permission defined by ISO 32000 that is written into the signed document and governs what a later party may do to it without invalidating the signature. The one-signature-per-save rule governs how many Sign() calls can be batched before a single save. A permission that allows additional signatures does not allow two signatures in one save, and the rule does not restrict what later revisions may add.

Does SignaturePermissions apply when signing a named field?

No. Filling a pre-placed field always produces a plain approval signature with no certification permissions attached, so a permission value passed alongside SignatureFieldName has no effect. Certification permissions apply when signing appends a new field, which is typically the first or author signature.

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
Chief Technology Officer

Jacob Mellor is Chief Technology Officer at Iron Software and a visionary engineer pioneering C# PDF technology. As the original developer behind Iron Software's core codebase, he has shaped the company's product architecture since its inception, transforming it alongside CEO Cameron Rimington into a 50+ person company serving NASA, Tesla, and global government agencies.

...
Read More

Ready to Get Started?

Nuget Downloads 21,253,952Version:2026.10just released

Free NuGet Download
Total downloads: 21,253,952

Get your FREE

30-day Trial Key instantly.

bullet_checkedNo credit card or account creation required
bullet_testTest in production
without watermarks
bullet_calendar30 days fully
functional product
bullet_support24/5 technical
support during trial
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.10

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

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.

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 a Quote, No Obligation
Your details will always be kept confidential.
  • Logo Aetna
  • Logo NASA
  • Logo GE
  • Logo Porsche
  • Logo USDA
  • Logo Qatar
Trusted by Millions of Engineers Worldwide
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.10

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

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