Documentation – PdfFileSignature Class

Python-Net: Sign PDF Documents

Tue, 14 Apr 2026 00:00:00 +0000

Aspose.PDF for Python via .NET provides the PdfFileSignature facade for applying digital signatures to existing PDF documents. Using a certificate file, you can sign a document programmatically, place the signature on a page, assign signature metadata, and customize how the signature is displayed.

This article demonstrates several common signing workflows:

Create and bind a PdfFileSignature object to the input PDF.
Configure the signing certificate.
Apply a digital signature to the target page.
Optionally assign a signature name and visible appearance.
Save the signed PDF.

Prepare reusable signing helpers

Before applying a digital signature to a PDF, it is useful to set up a small group of reusable helper functions. These helpers initialize the signature handler, define the visible signature area, configure the certificate, and build reusable PKCS#7 signature objects so the signing examples below remain self-contained and easier to follow.

import aspose.pdf as ap
import aspose.pdf.facades as pdf_facades
import aspose.pydrawing as apd


DEFAULT_CERTIFICATE_PASSWORD = "Aspose2021"
DEFAULT_SIGNATURE_NAME = "Signature1"


def create_pdf_file_signature(infile):
    pdf_signature = pdf_facades.PdfFileSignature()
    pdf_signature.bind_pdf(infile)
    return pdf_signature


def create_signature_rectangle():
    return apd.Rectangle(10, 10, 200, 60)


def configure_signature_certificate(
    pdf_signature, certificate_path, certificate_password=DEFAULT_CERTIFICATE_PASSWORD
):
    pdf_signature.set_certificate(certificate_path, certificate_password)


def create_pkcs7_signature(
    certificate_path, certificate_password=DEFAULT_CERTIFICATE_PASSWORD
):
    signature = ap.forms.PKCS7(certificate_path, certificate_password)
    signature.reason = "Document approval"
    signature.contact_info = "qa@example.com"
    signature.location = "New York, USA"
    signature.authority = "Aspose.PDF Example"
    return signature


def create_custom_signature_appearance():
    appearance = ap.forms.SignatureCustomAppearance()
    appearance.font_family_name = "Arial"
    appearance.font_size = 10
    appearance.show_contact_info = True
    appearance.show_location = True
    appearance.show_reason = True
    return appearance

Sign a PDF with basic certificate parameters

This approach configures the certificate directly on the PdfFileSignature object. It is useful when you want a straightforward signing flow with standard signature metadata and no separate signature object management.

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def sign_pdf_with_basic_parameters(infile, outfile, certificate_path):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        configure_signature_certificate(pdf_signature, certificate_path)
        pdf_signature.sign(
            1,
            "Document approval",
            "qa@example.com",
            "New York, USA",
            False,
            create_signature_rectangle(),
        )
        pdf_signature.save(outfile)
    finally:
        pdf_signature.close()

Sign a PDF with a PKCS7 object

Use a PKCS7 object when you need to prepare the signature first and then pass it into the signing call. This pattern gives you more control over the signature settings and is a good basis for more advanced workflows.

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def sign_pdf_with_certificate_object(infile, outfile, certificate_path):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        signature = create_pkcs7_signature(certificate_path)
        pdf_signature.sign(1, False, create_signature_rectangle(), signature)
        pdf_signature.save(outfile)
    finally:
        pdf_signature.close()

Sign a PDF with a named signature

If your document workflow relies on a predefined signature field name, pass that name to sign(). This makes it easier to reference the signature later for validation, processing, or integration with an approval workflow.

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def sign_pdf_with_named_signature(infile, outfile, certificate_path):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        signature = create_pkcs7_signature(certificate_path)
        signature.reason = "Approved by signing workflow"
        pdf_signature.sign(
            1,
            DEFAULT_SIGNATURE_NAME,
            "Approved by signing workflow",
            "qa@example.com",
            "New York, USA",
            True,
            create_signature_rectangle(),
            signature,
        )
        pdf_signature.save(outfile)
    finally:
        pdf_signature.close()

Apply a visible signature

You can make the signature visible on the PDF page by assigning a custom appearance to the PKCS7 object. This is useful when the output document should show approval details such as the reason, location, and contact information to end users.

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def apply_visible_signature(infile, outfile, certificate_path):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        signature = create_pkcs7_signature(certificate_path)
        signature.reason = "Visible approval signature"
        signature.custom_appearance = create_custom_signature_appearance()
        pdf_signature.sign(
            1,
            "Visible approval signature",
            "qa@example.com",
            "New York, USA",
            True,
            create_signature_rectangle(),
            signature,
        )
        pdf_signature.save(outfile)
    finally:
        pdf_signature.close()

Python-Net: PDF Certification

Thu, 02 Apr 2026 00:00:00 +0000

Aspose.PDF for Python via .NET lets you certify PDF documents by applying a document-level signature with PdfFileSignature. Certification is different from a standard approval signature because it defines what changes, if any, are allowed after the document has been certified.

This article demonstrates two common certification workflows:

Certify a PDF and allow form filling after certification.
Certify a PDF and prevent any further changes.

Certify a PDF for form filling

Use this approach when the document should remain certified but users still need to complete interactive forms or continue signing the file. The FILLING_IN_FORMS permission level allows those controlled changes while keeping the certification valid.

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def certify_pdf_with_mdp_signature(infile, outfile, certificate_path):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        doc_mdp_signature = create_doc_mdp_signature(
            certificate_path,
            ap.forms.DocMDPAccessPermissions.FILLING_IN_FORMS,
            reason="Certified for form filling and signing",
        )
        pdf_signature.certify(
            1,
            "Certified for form filling and signing",
            "security@example.com",
            "New York, USA",
            True,
            create_signature_rectangle(),
            doc_mdp_signature,
        )
        pdf_signature.save(outfile)
    finally:
        pdf_signature.close()

Apply document-level certification with no changes allowed

Use this mode when the certified document must remain unchanged after certification. The NO_CHANGES permission level is appropriate for finalized PDFs where any later modification should invalidate the certification state.

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def apply_document_level_certification(infile, outfile, certificate_path):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        doc_mdp_signature = create_doc_mdp_signature(
            certificate_path,
            ap.forms.DocMDPAccessPermissions.NO_CHANGES,
            reason="Certified with no further changes allowed",
        )
        pdf_signature.certify(
            1,
            "Certified with no further changes allowed",
            "security@example.com",
            "New York, USA",
            True,
            create_signature_rectangle(),
            doc_mdp_signature,
        )
        pdf_signature.save(outfile)
    finally:
        pdf_signature.close()

Python-Net: Revision and Permissions

Thu, 02 Apr 2026 00:00:00 +0000

Aspose.PDF for Python via .NET provides the PdfFileSignature facade for working with signed and certified PDF documents. Besides adding signatures, you can also inspect signature metadata to understand how many revisions a document contains and what changes are allowed after certification.

This example demonstrates three common inspection tasks:

Get the revision number for an existing signature.
Get the total number of revisions in a signed document.
Read the access permissions from a certified PDF.

Get the revision number for a signature

Use this approach when a PDF already contains one or more signatures and you need to identify the revision associated with a specific signature. The example resolves the first available signature name and then calls get_revision().

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def get_signature_revision(infile):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        sign_name = require_signature_name(pdf_signature)
        signature_revision = pdf_signature.get_revision(sign_name)
        print(f"Signature Revision for '{sign_name}': {signature_revision}")
    finally:
        pdf_signature.close()

Get the total number of document revisions

Use get_total_revision() when you need to know how many revisions are stored in the signed PDF. This is useful for checking whether the document has gone through multiple updates after the original signature was applied.

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def get_total_document_revisions(infile):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        total_revisions = pdf_signature.get_total_revision()
        print(f"Total Document Revisions: {total_revisions}")
    finally:
        pdf_signature.close()

Get access permissions from a certified PDF

Certified documents can define what changes are allowed after certification. Use get_access_permissions() to inspect that permission level and determine whether the document allows no changes, form filling, or other controlled modifications.

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def get_access_permissions(infile):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        access_permissions = pdf_signature.get_access_permissions()
        print(f"Access Permissions: {access_permissions}")
    finally:
        pdf_signature.close()

Python-Net: Signature Extraction

Thu, 02 Apr 2026 00:00:00 +0000

Aspose.PDF for Python via .NET provides the PdfFileSignature facade for inspecting and extracting data from signed PDF documents. After a PDF has been signed, you can use it to export signature resources such as the visual signature image and the certificate associated with the signature.

This example demonstrates two common extraction tasks:

Extract the visual image associated with a signature.
Extract the signing certificate from a signed PDF.

Extract a signature image

Use this method when the PDF contains a visible signature and you want to export its image data. The example opens the signed document, gets the first available signature name, extracts the image stream, and writes it to a file.

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def extract_signature_image(infile, outfile):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        sign_name = require_signature_name(pdf_signature)
        signature_image = pdf_signature.extract_image(sign_name)
        write_stream_data(signature_image, outfile)
    finally:
        pdf_signature.close()

Extract a signature certificate

Use extract_certificate() when you need the certificate data attached to a signature. This is useful for inspection, validation workflows, or storing the signer certificate separately from the PDF document.

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def extract_signature_certificate(infile, outfile):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        sign_name = require_signature_name(pdf_signature)
        signature_certificate = pdf_signature.extract_certificate(sign_name)
        write_stream_data(signature_certificate, outfile)
    finally:
        pdf_signature.close()

Python-Net: Signature Information

Thu, 02 Apr 2026 00:00:00 +0000

Aspose.PDF for Python via .NET provides the PdfFileSignature facade for inspecting digital signatures in PDF documents. After a document has been signed, you can use it to read the signature names and retrieve metadata such as the signer name, contact information, signing time, reason, and location.

This example demonstrates four common signature information tasks:

List all signature names in a signed PDF.
Read signer details for a selected signature.
Get the signing date and time.
Read the signature reason and location.

Get signature names

Use this method when a PDF may contain one or more signatures and you want to inspect which signature entries are available. The example opens the document and prints the list returned by get_sign_names().

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def get_signature_names(infile):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        signature_names = list_signature_names(pdf_signature)
        print(f"Signature Names: {signature_names}")
    finally:
        pdf_signature.close()

Get signer details

Once you know the signature name, you can retrieve signer-specific metadata. This example reads the signer name and contact information for the first available signature in the document.

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def get_signer_details(infile):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        sign_name = require_signature_name(pdf_signature)
        signer_name = pdf_signature.get_signer_name(sign_name)
        contact_info = pdf_signature.get_contact_info(sign_name)
        print(
            f"Signer Details for '{sign_name}': "
            f"signer_name={signer_name}, contact_info={contact_info}"
        )
    finally:
        pdf_signature.close()

Get signature date and time

Use get_date_time() to determine when a specific signature was applied. This is useful for auditing and for displaying signature history in document workflows.

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def get_signature_date_and_time(infile):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        sign_name = require_signature_name(pdf_signature)
        signature_date = pdf_signature.get_date_time(sign_name)
        print(f"Signature Date and Time for '{sign_name}': {signature_date}")
    finally:
        pdf_signature.close()

Get signature reason and location

Digital signatures can also store descriptive metadata such as the signing reason and location. This example retrieves both values for the selected signature and prints them together.

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def get_signature_reason_and_location(infile):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        sign_name = require_signature_name(pdf_signature)
        signature_reason = pdf_signature.get_reason(sign_name)
        signature_location = pdf_signature.get_location(sign_name)
        print(
            f"Signature Reason and Location for '{sign_name}': "
            f"reason={signature_reason}, location={signature_location}"
        )
    finally:
        pdf_signature.close()

Python-Net: Signature Integrity Checks

Thu, 02 Apr 2026 00:00:00 +0000

Aspose.PDF for Python via .NET provides the PdfFileSignature facade for validating signed PDF documents. After a file has been signed, you can use it to check whether the signature applies to the complete document and whether the signed content is still valid.

This example demonstrates two common integrity checks:

Check whether a signature covers the whole document.
Validate the integrity of the signed PDF content.

Check whether a signature covers the whole document

Use covers_whole_document() when you need to confirm that the signature applies to the complete PDF and not only to part of its content. The example reads the first available signature name and checks its coverage.

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def check_signature_coverage(infile):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        sign_name = require_signature_name(pdf_signature)
        covers_document = pdf_signature.covers_whole_document(sign_name)
        print(f"Signature '{sign_name}' covers the whole document: {covers_document}")
    finally:
        pdf_signature.close()

Validate document integrity

Use verify_signed() to confirm that the signed document content has not been altered after the signature was applied. This method helps verify whether the document remains valid for the selected signature.

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def validate_document_integrity(infile):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        sign_name = require_signature_name(pdf_signature)
        is_valid = pdf_signature.verify_signed(sign_name)
        print(f"Document integrity for '{sign_name}' is valid: {is_valid}")
    finally:
        pdf_signature.close()

Python-Net: Signature Management

Thu, 02 Apr 2026 00:00:00 +0000

Aspose.PDF for Python via .NET provides the PdfFileSignature facade for working with existing digital signatures in PDF documents. In addition to reading and validating signatures, you can also remove them when a workflow requires the signed content to be updated or the signature field to be cleared.

This example demonstrates two common signature management tasks:

Remove a signature from a PDF document.
Remove a signature and clean up the associated signature field.

Remove a signature from a PDF

Use remove_signature() when you want to delete the selected signature from the document while keeping the underlying signature field structure in place. The example opens the signed PDF, resolves the signature name, removes it, and saves the updated output file.

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def remove_signature_from_pdf(infile, outfile):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        sign_name = require_signature_name(pdf_signature)
        pdf_signature.remove_signature(sign_name)
        pdf_signature.save(outfile)
    finally:
        pdf_signature.close()

Remove a signature and clean up the field

Use the overload with the additional True flag when you want to remove the signature and also clean up the related signature field. This is useful when the field should not remain in the document after the signature has been deleted.

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def remove_signature_with_field_cleanup(infile, outfile):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        sign_name = require_signature_name(pdf_signature)
        pdf_signature.remove_signature(sign_name, True)
        pdf_signature.save(outfile)
    finally:
        pdf_signature.close()

Python-Net: Signature Verification

Thu, 02 Apr 2026 00:00:00 +0000

Aspose.PDF for Python via .NET provides the PdfFileSignature facade for validating signed PDF documents. After a PDF has been signed, you can use it to confirm that a signature is valid and to detect whether the document contains any signature entries.

This example demonstrates two common verification tasks:

Verify that an existing PDF signature is valid.
Check whether a PDF contains any signatures.

Verify a PDF signature

Use verify_signature() when you need to validate a specific signature in the document. The example resolves the first available signature name and verifies whether that signature is valid.

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def verify_pdf_signature(infile):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        sign_name = require_signature_name(pdf_signature)
        is_valid = pdf_signature.verify_signature(sign_name)
        print(f"Signature '{sign_name}' is valid: {is_valid}")
    finally:
        pdf_signature.close()

Check whether a PDF contains signatures

Use contains_signature() when you only need to know whether the PDF includes any signatures at all. This is useful as a quick check before running more detailed verification or extraction logic.

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def check_if_pdf_contains_signatures(infile):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        contains_signatures = pdf_signature.contains_signature()
        print(f"PDF contains signatures: {contains_signatures}")
    finally:
        pdf_signature.close()

Python-Net: Usage Rights Management

Thu, 02 Apr 2026 00:00:00 +0000

Aspose.PDF for Python via .NET provides the PdfFileSignature facade for working with signed PDFs and related usage-rights settings. In some workflows, you may need to inspect whether a document contains usage rights and remove them before saving an updated version of the file.

This example demonstrates one common usage-rights management task:

Check whether a PDF contains usage rights.
Remove usage rights from the document.
Save the updated PDF file.

Check whether the PDF contains usage rights

Before removing usage rights, the example checks the current state of the document by calling contains_usage_rights(). This lets you confirm whether usage rights are present before making changes.

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def check_usage_rights(infile):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        had_usage_rights = pdf_signature.contains_usage_rights()
        print(f"PDF contains usage rights: {had_usage_rights}")
    finally:
        pdf_signature.close()

Remove usage rights from the PDF

Use remove_usage_rights() when the document should no longer retain its existing usage-rights settings. The example checks the initial state, removes the rights, and saves the updated PDF to a new file.

import aspose.pdf.facades as pdf_facades
import sys
from os import path


def remove_usage_rights(infile, outfile):
    pdf_signature = create_pdf_file_signature(infile)
    try:
        had_usage_rights = pdf_signature.contains_usage_rights()
        print(f"PDF contains usage rights before removal: {had_usage_rights}")
        pdf_signature.remove_usage_rights()
        pdf_signature.save(outfile)
    finally:
        pdf_signature.close()