PDF Electronic Seal API

// Get the samples from https://www.adobe.com/go/pdftoolsapi_java_samples
// Run the sample:
// mvn -f pom.xml exec:java -Dexec.mainClass=com.adobe.pdfservices.operation.samples.electronicseal.ElectronicSeal

package com.adobe.pdfservices.operation.samples.electronicseal;

public class ElectronicSeal {

    // Initialize the logger.
    private static final Logger LOGGER = LoggerFactory.getLogger(ElectronicSeal.class);

    public static void main(String[] args) {
        try (InputStream inputStream = Files.newInputStream(new File("src/main/resources/sampleInvoice.pdf").toPath());
             InputStream inputStreamSealImage = Files.newInputStream(new File("src/main/resources/sampleSealImage.png").toPath())) {
            // Initial setup, create credentials instance
            Credentials credentials = new ServicePrincipalCredentials(
                System.getenv("PDF_SERVICES_CLIENT_ID"),
                System.getenv("PDF_SERVICES_CLIENT_SECRET"));
        
            // Creates a PDF Services instance
            PDFServices pdfServices = new PDFServices(credentials);
            
            // Creates an asset(s) from source file(s) and upload
            Asset asset = pdfServices.upload(inputStream, PDFServicesMediaType.PDF.getMediaType());
            Asset sealImageAsset = pdfServices.upload(inputStreamSealImage, PDFServicesMediaType.PNG.getMediaType());
        
            // Set the document level permission to be applied for output document
            DocumentLevelPermission documentLevelPermission = DocumentLevelPermission.FORM_FILLING;
        
            // Sets the Seal Field Name to be created in input PDF document.
            String sealFieldName = "Signature1";
        
            // Sets the page number in input document for applying seal.
            Integer sealPageNumber = 1;
        
            // Sets if seal should be visible or invisible.
            Boolean sealVisible = true;
        
            // Creates FieldLocation instance and set the coordinates for applying signature
            FieldLocation fieldLocation = new FieldLocation(150, 250, 350, 200);
        
            // Create FieldOptions instance with required details.
            FieldOptions fieldOptions = new FieldOptions.Builder(sealFieldName)
                .setFieldLocation(fieldLocation)
                .setPageNumber(sealPageNumber)
                .setVisible(sealVisible)
                .build();
        
            // Sets the name of TSP Provider being used.
            String providerName = "<PROVIDER_NAME>";
        
            // Sets the access token to be used to access TSP provider hosted APIs.
            String accessToken = "<ACCESS_TOKEN>";
        
            // Sets the credential ID.
            String credentialID = "<CREDENTIAL_ID>";
        
            // Sets the PIN generated while creating credentials.
            String pin = "<PIN>";
        
            // Creates CSCAuthContext instance using access token and token type.
            CSCAuthContext cscAuthContext = new CSCAuthContext(accessToken, "Bearer");
        
            // Create CertificateCredentials instance with required certificate details.
            CertificateCredentials certificateCredentials = CertificateCredentials.cscCredentialBuilder()
                .withProviderName(providerName)
                .withCredentialID(credentialID)
                .withPin(pin)
                .withCSCAuthContext(cscAuthContext)
                .build();
            
            // Create parameters for the job
            PDFElectronicSealParams pdfElectronicSealParams = PDFElectronicSealParams
                .pdfElectronicSealParamsBuilder(certificateCredentials, fieldOptions)
                .withDocumentLevelPermission(documentLevelPermission)
                .build();
        
            // Creates a new job instance
            PDFElectronicSealJob pdfElectronicSealJob = new PDFElectronicSealJob(asset, pdfElectronicSealParams);
        
            // Sets the optional input seal image for PDFElectronicSealOperation instance
            pdfElectronicSealJob.setSealImageAsset(sealImageAsset);
        
            // Submit the job and gets the job result
            String location = pdfServices.submit(pdfElectronicSealJob);
            PDFServicesResponse<PDFElectronicSealResult> pdfServicesResponse = pdfServices.getJobResult(location, PDFElectronicSealResult.class);
        
            // Get content from the resulting asset(s)
            Asset resultAsset = pdfServicesResponse.getResult().getAsset();
            StreamAsset streamAsset = pdfServices.getContent(resultAsset);
        
            // Creates an output stream and copy stream asset's content to it
            Files.createDirectories(Paths.get("output/"));
            OutputStream outputStream = Files.newOutputStream(new File("output/sealedOutput.pdf").toPath());
            LOGGER.info("Saving asset at output/sealedOutput.pdf");
            IOUtils.copy(streamAsset.getInputStream(), outputStream);
            outputStream.close();
        } catch (ServiceApiException | IOException | SDKException | ServiceUsageException ex) {
            LOGGER.error("Exception encountered while executing operation", ex);
        }
    }
}

CopyCopied to your clipboard
1// Get the samples from https://www.adobe.com/go/pdftoolsapi_java_samples
2// Run the sample:
3// mvn -f pom.xml exec:java -Dexec.mainClass=com.adobe.pdfservices.operation.samples.electronicseal.ElectronicSeal
4
5package com.adobe.pdfservices.operation.samples.electronicseal;
6
7public class ElectronicSeal {
8
9    // Initialize the logger.
10    private static final Logger LOGGER = LoggerFactory.getLogger(ElectronicSeal.class);
11
12    public static void main(String[] args) {
13        try (InputStream inputStream = Files.newInputStream(new File("src/main/resources/sampleInvoice.pdf").toPath());
14             InputStream inputStreamSealImage = Files.newInputStream(new File("src/main/resources/sampleSealImage.png").toPath())) {
15            // Initial setup, create credentials instance
16            Credentials credentials = new ServicePrincipalCredentials(
17                System.getenv("PDF_SERVICES_CLIENT_ID"),
18                System.getenv("PDF_SERVICES_CLIENT_SECRET"));
19        
20            // Creates a PDF Services instance
21            PDFServices pdfServices = new PDFServices(credentials);
22            
23            // Creates an asset(s) from source file(s) and upload
24            Asset asset = pdfServices.upload(inputStream, PDFServicesMediaType.PDF.getMediaType());
25            Asset sealImageAsset = pdfServices.upload(inputStreamSealImage, PDFServicesMediaType.PNG.getMediaType());
26        
27            // Set the document level permission to be applied for output document
28            DocumentLevelPermission documentLevelPermission = DocumentLevelPermission.FORM_FILLING;
29        
30            // Sets the Seal Field Name to be created in input PDF document.
31            String sealFieldName = "Signature1";
32        
33            // Sets the page number in input document for applying seal.
34            Integer sealPageNumber = 1;
35        
36            // Sets if seal should be visible or invisible.
37            Boolean sealVisible = true;
38        
39            // Creates FieldLocation instance and set the coordinates for applying signature
40            FieldLocation fieldLocation = new FieldLocation(150, 250, 350, 200);
41        
42            // Create FieldOptions instance with required details.
43            FieldOptions fieldOptions = new FieldOptions.Builder(sealFieldName)
44                .setFieldLocation(fieldLocation)
45                .setPageNumber(sealPageNumber)
46                .setVisible(sealVisible)
47                .build();
48        
49            // Sets the name of TSP Provider being used.
50            String providerName = "<PROVIDER_NAME>";
51        
52            // Sets the access token to be used to access TSP provider hosted APIs.
53            String accessToken = "<ACCESS_TOKEN>";
54        
55            // Sets the credential ID.
56            String credentialID = "<CREDENTIAL_ID>";
57        
58            // Sets the PIN generated while creating credentials.
59            String pin = "<PIN>";
60        
61            // Creates CSCAuthContext instance using access token and token type.
62            CSCAuthContext cscAuthContext = new CSCAuthContext(accessToken, "Bearer");
63        
64            // Create CertificateCredentials instance with required certificate details.
65            CertificateCredentials certificateCredentials = CertificateCredentials.cscCredentialBuilder()
66                .withProviderName(providerName)
67                .withCredentialID(credentialID)
68                .withPin(pin)
69                .withCSCAuthContext(cscAuthContext)
70                .build();
71            
72            // Create parameters for the job
73            PDFElectronicSealParams pdfElectronicSealParams = PDFElectronicSealParams
74                .pdfElectronicSealParamsBuilder(certificateCredentials, fieldOptions)
75                .withDocumentLevelPermission(documentLevelPermission)
76                .build();
77        
78            // Creates a new job instance
79            PDFElectronicSealJob pdfElectronicSealJob = new PDFElectronicSealJob(asset, pdfElectronicSealParams);
80        
81            // Sets the optional input seal image for PDFElectronicSealOperation instance
82            pdfElectronicSealJob.setSealImageAsset(sealImageAsset);
83        
84            // Submit the job and gets the job result
85            String location = pdfServices.submit(pdfElectronicSealJob);
86            PDFServicesResponse<PDFElectronicSealResult> pdfServicesResponse = pdfServices.getJobResult(location, PDFElectronicSealResult.class);
87        
88            // Get content from the resulting asset(s)
89            Asset resultAsset = pdfServicesResponse.getResult().getAsset();
90            StreamAsset streamAsset = pdfServices.getContent(resultAsset);
91        
92            // Creates an output stream and copy stream asset's content to it
93            Files.createDirectories(Paths.get("output/"));
94            OutputStream outputStream = Files.newOutputStream(new File("output/sealedOutput.pdf").toPath());
95            LOGGER.info("Saving asset at output/sealedOutput.pdf");
96            IOUtils.copy(streamAsset.getInputStream(), outputStream);
97            outputStream.close();
98        } catch (ServiceApiException | IOException | SDKException | ServiceUsageException ex) {
99            LOGGER.error("Exception encountered while executing operation", ex);
100        }
101    }
102}
103

// Get the samples from https://www.adobe.com/go/pdftoolsapi_net_samples
// Run the sample:
// cd ElectronicSeal/
// dotnet run ElectronicSeal.csproj

namespace ElectronicSeal
{
    class Program
    {
        // Initialize the logger.
        private static readonly ILog log = LogManager.GetLogger(typeof(Program));
        static void Main()
        {
            //Configure the logging
            ConfigureLogging();

            try
            {
                // Initial setup, create credentials instance.
                Credentials credentials = Credentials.ServicePrincipalCredentialsBuilder()
                    .WithClientId("PDF_SERVICES_CLIENT_ID")
                    .WithClientSecret("PDF_SERVICES_CLIENT_SECRET")
                    .Build();

                // Create an ExecutionContext using credentials.
                ExecutionContext executionContext = ExecutionContext.Create(credentials);

                //Set the input document to perform the sealing operation
                FileRef sourceFile = FileRef.CreateFromLocalFile(@"SampleInvoice.pdf");

                //Set the background seal image for signature , if required.
                FileRef sealImageFile = FileRef.CreateFromLocalFile(@"sampleSealImage.png");

                //Set the Seal Field Name to be created in input PDF document.
                string sealFieldName = "Signature1";

                //Set the page number in input document for applying seal.
                int sealPageNumber = 1;

                //Set if seal should be visible or invisible.
                bool sealVisible = true;

                //Create FieldLocation instance and set the coordinates for applying signature
                FieldLocation fieldLocation = new FieldLocation(150, 250, 350, 200);

                //Create FieldOptions instance with required details.
                FieldOptions sealFieldOptions = new FieldOptions.Builder(sealFieldName)
                .SetVisible(sealVisible)
                .SetFieldLocation(fieldLocation)
                .SetPageNumber(sealPageNumber)
                .Build();

                //Set the name of TSP Provider being used.
                string providerName = "<PROVIDER_NAME>";

                //Set the access token to be used to access TSP provider hosted APIs.
                string accessToken = "<ACCESS_TOKEN>";

                //Set the credential ID.
                string credentialID = "<CREDENTIAL_ID>";

                //Set the PIN generated while creating credentials.
                string pin = "<PIN>";

                CSCAuthContext cscAuthContext = new CSCAuthContext(accessToken, "Bearer");

                //Create CertificateCredentials instance with required certificate details.
                CertificateCredentials certificateCredentials = CertificateCredentials.CSCCredentialBuilder()
                .WithProviderName(providerName)
                .WithCredentialID(credentialID)
                .WithPin(pin)
                .WithCSCAuthContext(cscAuthContext)
                .Build();

                //Create SealingOptions instance with all the sealing parameters.
                SealOptions sealOptions = new SealOptions.Builder(certificateCredentials, fieldOptions).build();

                //Create the PDFElectronicSealOperation instance using the PDFElectronicSealOptions instance
                PDFElectronicSealOperation pdfElectronicSealOperation = PDFElectronicSealOperation.CreateNew(sealOptions);

                //Set the input source file for PDFElectronicSealOperation instance
                pdfElectronicSealOperation.SetInput(sourceFile);

                //Set the optional input seal image for PDFElectronicSealOperation instance
                pdfElectronicSealOperation.SetSealImage(sealImageFile);

                //Execute the operation
                FileRef result = pdfElectronicSealOperation.Execute(executionContext);

                // Save the output at specified location.
                result.SaveAs(output/sealedOutput.pdf);
            }
            catch (ServiceUsageException ex)
            {
                log.Error("Exception encountered while executing operation", ex);
            }
            catch (ServiceApiException ex)
            {
                log.Error("Exception encountered while executing operation", ex);
            }
            catch (SDKException ex)
            {
                log.Error("Exception encountered while executing operation", ex);
            }
            catch (IOException ex)
            {
                log.Error("Exception encountered while executing operation", ex);
            }
            catch (Exception ex)
            {
                log.Error("Exception encountered while executing operation", ex);
            }

        }
        static void ConfigureLogging()
        {
            ILoggerRepository logRepository = LogManager.GetRepository(Assembly.GetEntryAssembly());
            XmlConfigurator.Configure(logRepository, new FileInfo("log4net.config"));
        }
    }
}
CopyCopied to your clipboard
1// Get the samples from https://www.adobe.com/go/pdftoolsapi_net_samples
2// Run the sample:
3// cd ElectronicSeal/
4// dotnet run ElectronicSeal.csproj
5
6namespace ElectronicSeal
7{
8    class Program
9    {
10        // Initialize the logger.
11        private static readonly ILog log = LogManager.GetLogger(typeof(Program));
12        static void Main()
13        {
14            //Configure the logging
15            ConfigureLogging();
16
17            try
18            {
19                // Initial setup, create credentials instance.
20                Credentials credentials = Credentials.ServicePrincipalCredentialsBuilder()
21                    .WithClientId("PDF_SERVICES_CLIENT_ID")
22                    .WithClientSecret("PDF_SERVICES_CLIENT_SECRET")
23                    .Build();
24
25                // Create an ExecutionContext using credentials.
26                ExecutionContext executionContext = ExecutionContext.Create(credentials);
27
28                //Set the input document to perform the sealing operation
29                FileRef sourceFile = FileRef.CreateFromLocalFile(@"SampleInvoice.pdf");
30
31                //Set the background seal image for signature , if required.
32                FileRef sealImageFile = FileRef.CreateFromLocalFile(@"sampleSealImage.png");
33
34                //Set the Seal Field Name to be created in input PDF document.
35                string sealFieldName = "Signature1";
36
37                //Set the page number in input document for applying seal.
38                int sealPageNumber = 1;
39
40                //Set if seal should be visible or invisible.
41                bool sealVisible = true;
42
43                //Create FieldLocation instance and set the coordinates for applying signature
44                FieldLocation fieldLocation = new FieldLocation(150, 250, 350, 200);
45
46                //Create FieldOptions instance with required details.
47                FieldOptions sealFieldOptions = new FieldOptions.Builder(sealFieldName)
48                .SetVisible(sealVisible)
49                .SetFieldLocation(fieldLocation)
50                .SetPageNumber(sealPageNumber)
51                .Build();
52
53                //Set the name of TSP Provider being used.
54                string providerName = "<PROVIDER_NAME>";
55
56                //Set the access token to be used to access TSP provider hosted APIs.
57                string accessToken = "<ACCESS_TOKEN>";
58
59                //Set the credential ID.
60                string credentialID = "<CREDENTIAL_ID>";
61
62                //Set the PIN generated while creating credentials.
63                string pin = "<PIN>";
64
65                CSCAuthContext cscAuthContext = new CSCAuthContext(accessToken, "Bearer");
66
67                //Create CertificateCredentials instance with required certificate details.
68                CertificateCredentials certificateCredentials = CertificateCredentials.CSCCredentialBuilder()
69                .WithProviderName(providerName)
70                .WithCredentialID(credentialID)
71                .WithPin(pin)
72                .WithCSCAuthContext(cscAuthContext)
73                .Build();
74
75                //Create SealingOptions instance with all the sealing parameters.
76                SealOptions sealOptions = new SealOptions.Builder(certificateCredentials, fieldOptions).build();
77
78                //Create the PDFElectronicSealOperation instance using the PDFElectronicSealOptions instance
79                PDFElectronicSealOperation pdfElectronicSealOperation = PDFElectronicSealOperation.CreateNew(sealOptions);
80
81                //Set the input source file for PDFElectronicSealOperation instance
82                pdfElectronicSealOperation.SetInput(sourceFile);
83
84                //Set the optional input seal image for PDFElectronicSealOperation instance
85                pdfElectronicSealOperation.SetSealImage(sealImageFile);
86
87                //Execute the operation
88                FileRef result = pdfElectronicSealOperation.Execute(executionContext);
89
90                // Save the output at specified location.
91                result.SaveAs(output/sealedOutput.pdf);
92            }
93            catch (ServiceUsageException ex)
94            {
95                log.Error("Exception encountered while executing operation", ex);
96            }
97            catch (ServiceApiException ex)
98            {
99                log.Error("Exception encountered while executing operation", ex);
100            }
101            catch (SDKException ex)
102            {
103                log.Error("Exception encountered while executing operation", ex);
104            }
105            catch (IOException ex)
106            {
107                log.Error("Exception encountered while executing operation", ex);
108            }
109            catch (Exception ex)
110            {
111                log.Error("Exception encountered while executing operation", ex);
112            }
113
114        }
115        static void ConfigureLogging()
116        {
117            ILoggerRepository logRepository = LogManager.GetRepository(Assembly.GetEntryAssembly());
118            XmlConfigurator.Configure(logRepository, new FileInfo("log4net.config"));
119        }
120    }
121}

// Get the samples from http://www.adobe.com/go/pdftoolsapi_node_sample
// Run the sample:
// node src/electronicseal/electronic-seal.js

const {
    ServicePrincipalCredentials,
    PDFServices,
    MimeType,
    DocumentLevelPermission,
    FieldLocation,
    FieldOptions,
    CSCAuthContext,
    CSCCredential,
    PDFElectronicSealParams,
    PDFElectronicSealJob,
    PDFElectronicSealResult,
    SDKError,
    ServiceUsageError,
    ServiceApiError
} = require("@adobe/pdfservices-node-sdk");
const fs = require("fs");

(async () => {
    let sourceFileReadStream;
    let sealImageReadStream;
    try {
        // Initial setup, create credentials instance
        const credentials = new ServicePrincipalCredentials({
            clientId: process.env.PDF_SERVICES_CLIENT_ID,
            clientSecret: process.env.PDF_SERVICES_CLIENT_SECRET
        });

        // Creates a PDF Services instance
        const pdfServices = new PDFServices({credentials});

        // Creates an asset(s) from source file(s) and upload
        sourceFileReadStream = fs.createReadStream("./sampleInvoice.pdf")
        sealImageReadStream = fs.createReadStream("./sampleSealImage.png");
        const [sourceFileAsset, sealImageAsset] = await pdfServices.uploadAssets({
            streamAssets: [{
                readStream: sourceFileReadStream,
                mimeType: MimeType.PDF
            }, {
                readStream: sealImageReadStream,
                mimeType: MimeType.PNG
            }]
        });

        // Set the document level permission to be applied for output document
        const documentLevelPermission = DocumentLevelPermission.FORM_FILLING;

        // Set the Seal Field Name to be created in input PDF document
        const sealFieldName = "Signature1";

        // Set the page number in input document for applying seal
        const sealPageNumber = 1;

        // Set if seal should be visible or invisible
        const sealVisible = true;

        // Create FieldLocation instance and set the coordinates for applying signature
        const fieldLocation = new FieldLocation({
            left: 150,
            top: 250,
            right: 350,
            bottom: 200
        });

        // Create FieldOptions instance with required details
        const sealFieldOptions = new FieldOptions({
            visible: sealVisible,
            location: fieldLocation,
            fieldName: sealFieldName,
            pageNumber: sealPageNumber,
        });

        // Set the name of TSP Provider being used
        const providerName = "<PROVIDER_NAME>";

        // Set the access token to be used to access TSP provider hosted APIs
        const accessToken = "<ACCESS_TOKEN>";

        // Set the credential ID
        const credentialId = "<CREDENTIAL_ID>";

        // Set the PIN generated while creating credentials
        const pin = "<PIN>";

        // Create CSCAuthContext instance using access token and token type
        const authorizationContext = new CSCAuthContext({
            accessToken,
            tokenType: "Bearer"
        });

        // Create CertificateCredentials instance with required certificate details
        const certificateCredentials = new CSCCredential({
            providerName,
            credentialId,
            pin,
            authorizationContext,
        });

        // Create parameters for the job
        const params = new PDFElectronicSealParams({
            certificateCredentials,
            sealFieldOptions,
            documentLevelPermission,
        });

        // Creates a new job instance
        const job = new PDFElectronicSealJob({
            inputAsset: sourceFileAsset,
            sealImageAsset,
            params,
        });

        // Submit the job and get the job result
        const pollingURL = await pdfServices.submit({job});
        const pdfServicesResponse = await pdfServices.getJobResult({
            pollingURL,
            resultType: PDFElectronicSealResult
        });

        // Get content from the resulting asset(s)
        const resultAsset = pdfServicesResponse.result.asset;
        const streamAsset = await pdfServices.getContent({asset: resultAsset});

        // Creates a write stream and copy stream asset's content to it
        const outputFilePath = "./sealedOutput.pdf";
        console.log(`Saving asset at ${outputFilePath}`);

        const writeStream = fs.createWriteStream(outputFilePath);
        streamAsset.readStream.pipe(writeStream);
    } catch (err) {
        if (err instanceof SDKError || err instanceof ServiceUsageError || err instanceof ServiceApiError) {
            console.log("Exception encountered while executing operation", err);
        } else {
            console.log("Exception encountered while executing operation", err);
        }
    } finally {
        sourceFileReadStream?.destroy();
        sealImageReadStream?.destroy();
    }
})();
CopyCopied to your clipboard
1// Get the samples from http://www.adobe.com/go/pdftoolsapi_node_sample
2// Run the sample:
3// node src/electronicseal/electronic-seal.js
4
5const {
6    ServicePrincipalCredentials,
7    PDFServices,
8    MimeType,
9    DocumentLevelPermission,
10    FieldLocation,
11    FieldOptions,
12    CSCAuthContext,
13    CSCCredential,
14    PDFElectronicSealParams,
15    PDFElectronicSealJob,
16    PDFElectronicSealResult,
17    SDKError,
18    ServiceUsageError,
19    ServiceApiError
20} = require("@adobe/pdfservices-node-sdk");
21const fs = require("fs");
22
23(async () => {
24    let sourceFileReadStream;
25    let sealImageReadStream;
26    try {
27        // Initial setup, create credentials instance
28        const credentials = new ServicePrincipalCredentials({
29            clientId: process.env.PDF_SERVICES_CLIENT_ID,
30            clientSecret: process.env.PDF_SERVICES_CLIENT_SECRET
31        });
32
33        // Creates a PDF Services instance
34        const pdfServices = new PDFServices({credentials});
35
36        // Creates an asset(s) from source file(s) and upload
37        sourceFileReadStream = fs.createReadStream("./sampleInvoice.pdf")
38        sealImageReadStream = fs.createReadStream("./sampleSealImage.png");
39        const [sourceFileAsset, sealImageAsset] = await pdfServices.uploadAssets({
40            streamAssets: [{
41                readStream: sourceFileReadStream,
42                mimeType: MimeType.PDF
43            }, {
44                readStream: sealImageReadStream,
45                mimeType: MimeType.PNG
46            }]
47        });
48
49        // Set the document level permission to be applied for output document
50        const documentLevelPermission = DocumentLevelPermission.FORM_FILLING;
51
52        // Set the Seal Field Name to be created in input PDF document
53        const sealFieldName = "Signature1";
54
55        // Set the page number in input document for applying seal
56        const sealPageNumber = 1;
57
58        // Set if seal should be visible or invisible
59        const sealVisible = true;
60
61        // Create FieldLocation instance and set the coordinates for applying signature
62        const fieldLocation = new FieldLocation({
63            left: 150,
64            top: 250,
65            right: 350,
66            bottom: 200
67        });
68
69        // Create FieldOptions instance with required details
70        const sealFieldOptions = new FieldOptions({
71            visible: sealVisible,
72            location: fieldLocation,
73            fieldName: sealFieldName,
74            pageNumber: sealPageNumber,
75        });
76
77        // Set the name of TSP Provider being used
78        const providerName = "<PROVIDER_NAME>";
79
80        // Set the access token to be used to access TSP provider hosted APIs
81        const accessToken = "<ACCESS_TOKEN>";
82
83        // Set the credential ID
84        const credentialId = "<CREDENTIAL_ID>";
85
86        // Set the PIN generated while creating credentials
87        const pin = "<PIN>";
88
89        // Create CSCAuthContext instance using access token and token type
90        const authorizationContext = new CSCAuthContext({
91            accessToken,
92            tokenType: "Bearer"
93        });
94
95        // Create CertificateCredentials instance with required certificate details
96        const certificateCredentials = new CSCCredential({
97            providerName,
98            credentialId,
99            pin,
100            authorizationContext,
101        });
102
103        // Create parameters for the job
104        const params = new PDFElectronicSealParams({
105            certificateCredentials,
106            sealFieldOptions,
107            documentLevelPermission,
108        });
109
110        // Creates a new job instance
111        const job = new PDFElectronicSealJob({
112            inputAsset: sourceFileAsset,
113            sealImageAsset,
114            params,
115        });
116
117        // Submit the job and get the job result
118        const pollingURL = await pdfServices.submit({job});
119        const pdfServicesResponse = await pdfServices.getJobResult({
120            pollingURL,
121            resultType: PDFElectronicSealResult
122        });
123
124        // Get content from the resulting asset(s)
125        const resultAsset = pdfServicesResponse.result.asset;
126        const streamAsset = await pdfServices.getContent({asset: resultAsset});
127
128        // Creates a write stream and copy stream asset's content to it
129        const outputFilePath = "./sealedOutput.pdf";
130        console.log(`Saving asset at ${outputFilePath}`);
131
132        const writeStream = fs.createWriteStream(outputFilePath);
133        streamAsset.readStream.pipe(writeStream);
134    } catch (err) {
135        if (err instanceof SDKError || err instanceof ServiceUsageError || err instanceof ServiceApiError) {
136            console.log("Exception encountered while executing operation", err);
137        } else {
138            console.log("Exception encountered while executing operation", err);
139        }
140    } finally {
141        sourceFileReadStream?.destroy();
142        sealImageReadStream?.destroy();
143    }
144})();

curl --location --request POST 'https://pdf-services.adobe.io/operation/electronicseal' \
--header 'x-api-key: {{Placeholder for client_id}}' \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer {{Placeholder for token}}' \
--data-raw '{
    "inputDocumentAssetID": "urn:aaid:AS:UE1:23c30ee0-2c4d-xxxx-xxxx-087832fca718",
    "sealImageAssetID": "urn:aaid:AS:UE1:23c30ee0-2e4d-xxxx-xxxx-087832fca718",
    "sealOptions": {
        "signatureFormat": "PKCS7",
        "documentLevelPermission": "FORM_FILLING",
        "cscCredentialOptions": {
            "credentialId": "<CREDENTIAL_ID>",
            "providerName": "<PROVIDER_NAME>",
            "authorizationContext": {
                "tokenType": "Bearer",
                "accessToken": "<ACCESS_TOKEN>"
            },
            "credentialAuthParameters": {
                "pin": "<PIN>"
            }
        },
        "sealFieldOptions": {
            "location": {
                "left": 150,
                "top": 250,
                "right": 350,
                "bottom": 200
            },
            "fieldName": "Signature1",
            "pageNumber": 1
        }
    }
}'
CopyCopied to your clipboard
1curl --location --request POST 'https://pdf-services.adobe.io/operation/electronicseal' \
2--header 'x-api-key: {{Placeholder for client_id}}' \
3--header 'Content-Type: application/json' \
4--header 'Authorization: Bearer {{Placeholder for token}}' \
5--data-raw '{
6    "inputDocumentAssetID": "urn:aaid:AS:UE1:23c30ee0-2c4d-xxxx-xxxx-087832fca718",
7    "sealImageAssetID": "urn:aaid:AS:UE1:23c30ee0-2e4d-xxxx-xxxx-087832fca718",
8    "sealOptions": {
9        "signatureFormat": "PKCS7",
10        "documentLevelPermission": "FORM_FILLING",
11        "cscCredentialOptions": {
12            "credentialId": "<CREDENTIAL_ID>",
13            "providerName": "<PROVIDER_NAME>",
14            "authorizationContext": {
15                "tokenType": "Bearer",
16                "accessToken": "<ACCESS_TOKEN>"
17            },
18            "credentialAuthParameters": {
19                "pin": "<PIN>"
20            }
21        },
22        "sealFieldOptions": {
23            "location": {
24                "left": 150,
25                "top": 250,
26                "right": 350,
27                "bottom": 200
28            },
29            "fieldName": "Signature1",
30            "pageNumber": 1
31        }
32    }
33}'

// Get the samples from https://github.com/adobe/pdfservices-java-sdk-samples/tree/beta
// Run the sample:
// mvn -f pom.xml exec:java -Dexec.mainClass=com.adobe.pdfservices.operation.samples.electronicseal.ElectronicSealWithAppearanceOptions

package com.adobe.pdfservices.operation.samples.electronicseal;

public class ElectronicSealWithAppearanceOptions {

    // Initialize the logger.
    private static final Logger LOGGER = LoggerFactory.getLogger(ElectronicSealWithAppearanceOptions.class);

    public static void main(String[] args) {
        try (InputStream inputStream = Files.newInputStream(new File("src/main/resources/sampleInvoice.pdf").toPath());
             InputStream inputStreamSealImage = Files.newInputStream(new File("src/main/resources/sampleSealImage.png").toPath())) {
            // Initial setup, create credentials instance
            Credentials credentials = new ServicePrincipalCredentials(
                System.getenv("PDF_SERVICES_CLIENT_ID"),
                System.getenv("PDF_SERVICES_CLIENT_SECRET"));
        
            // Creates a PDF Services instance
            PDFServices pdfServices = new PDFServices(credentials);
       
            // Creates an asset(s) from source file(s) and upload
            Asset asset = pdfServices.upload(inputStream, PDFServicesMediaType.PDF.getMediaType());
            Asset sealImageAsset = pdfServices.upload(inputStreamSealImage, PDFServicesMediaType.PNG.getMediaType());

            // Set the document level permission to be applied for output document
            DocumentLevelPermission documentLevelPermission = DocumentLevelPermission.FORM_FILLING;

            // Create AppearanceOptions and add the required signature display items to it
            AppearanceOptions appearanceOptions = new AppearanceOptions();
            appearanceOptions.addItem(AppearanceItem.NAME);
            appearanceOptions.addItem(AppearanceItem.LABELS);
            appearanceOptions.addItem(AppearanceItem.DATE);
            appearanceOptions.addItem(AppearanceItem.SEAL_IMAGE);
            appearanceOptions.addItem(AppearanceItem.DISTINGUISHED_NAME);
        
        
            // Sets the Seal Field Name to be created in input PDF document.
            String sealFieldName = "Signature1";
        
            // Sets the page number in input document for applying seal.
            Integer sealPageNumber = 1;
        
            // Sets if seal should be visible or invisible.
            Boolean sealVisible = true;
        
            // CreatesFieldLocation instance and set the coordinates for applying signature
            FieldLocation fieldLocation = new FieldLocation(150, 250, 350, 200);
        
            // Create FieldOptions instance with required details.
            FieldOptions fieldOptions = new FieldOptions.Builder(sealFieldName)
                .setFieldLocation(fieldLocation)
                .setPageNumber(sealPageNumber)
                .setVisible(sealVisible)
                .build();
        
            // Sets the name of TSP Provider being used.
            String providerName = "<PROVIDER_NAME>";
        
            // Sets the access token to be used to access TSP provider hosted APIs.
            String accessToken = "<ACCESS_TOKEN>";
        
            // Sets the credential ID.
            String credentialID = "<CREDENTIAL_ID>";
        
            // Sets the PIN generated while creating credentials.
            String pin = "<PIN>";
        
            // Creates CSCAuthContext instance using access token and token type.
            CSCAuthContext cscAuthContext = new CSCAuthContext(accessToken, "Bearer");
        
            // Create CertificateCredentials instance with required certificate details.
            CertificateCredentials certificateCredentials = CertificateCredentials.cscCredentialBuilder()
                .withProviderName(providerName)
                .withCredentialID(credentialID)
                .withPin(pin)
                .withCSCAuthContext(cscAuthContext)
                .build();
            
            // Create parameters for the job
            PDFElectronicSealParams pdfElectronicSealParams = PDFElectronicSealParams
                .pdfElectronicSealParamsBuilder(certificateCredentials, fieldOptions)
                .withDocumentLevelPermission(documentLevelPermission)
                .withAppearanceOptions(appearanceOptions)
                .build();
        
            // Creates a new job instance
            PDFElectronicSealJob pdfElectronicSealJob = new PDFElectronicSealJob(asset, pdfElectronicSealParams);
            pdfElectronicSealJob.setSealImageAsset(sealImageAsset);
        
            // Submit the job and gets the job result
            String location = pdfServices.submit(pdfElectronicSealJob);
            PDFServicesResponse<PDFElectronicSealResult> pdfServicesResponse = pdfServices.getJobResult(location, PDFElectronicSealResult.class);
        
            // Get content from the resulting asset(s)
            Asset resultAsset = pdfServicesResponse.getResult().getAsset();
            StreamAsset streamAsset = pdfServices.getContent(resultAsset);
        
            // Creates an output stream and copy stream asset's content to it
            Files.createDirectories(Paths.get("output/"));
            OutputStream outputStream = Files.newOutputStream(new File("output/sealedOutput.pdf").toPath());
            LOGGER.info("Saving asset at output/sealedOutput.pdf");
            IOUtils.copy(streamAsset.getInputStream(), outputStream);
            outputStream.close();
        } catch (ServiceApiException | IOException | SDKException | ServiceUsageException ex) {
            LOGGER.error("Exception encountered while executing operation", ex);
        }
    }
}

CopyCopied to your clipboard
1// Get the samples from https://github.com/adobe/pdfservices-java-sdk-samples/tree/beta
2// Run the sample:
3// mvn -f pom.xml exec:java -Dexec.mainClass=com.adobe.pdfservices.operation.samples.electronicseal.ElectronicSealWithAppearanceOptions
4
5package com.adobe.pdfservices.operation.samples.electronicseal;
6
7public class ElectronicSealWithAppearanceOptions {
8
9    // Initialize the logger.
10    private static final Logger LOGGER = LoggerFactory.getLogger(ElectronicSealWithAppearanceOptions.class);
11
12    public static void main(String[] args) {
13        try (InputStream inputStream = Files.newInputStream(new File("src/main/resources/sampleInvoice.pdf").toPath());
14             InputStream inputStreamSealImage = Files.newInputStream(new File("src/main/resources/sampleSealImage.png").toPath())) {
15            // Initial setup, create credentials instance
16            Credentials credentials = new ServicePrincipalCredentials(
17                System.getenv("PDF_SERVICES_CLIENT_ID"),
18                System.getenv("PDF_SERVICES_CLIENT_SECRET"));
19        
20            // Creates a PDF Services instance
21            PDFServices pdfServices = new PDFServices(credentials);
22       
23            // Creates an asset(s) from source file(s) and upload
24            Asset asset = pdfServices.upload(inputStream, PDFServicesMediaType.PDF.getMediaType());
25            Asset sealImageAsset = pdfServices.upload(inputStreamSealImage, PDFServicesMediaType.PNG.getMediaType());
26
27            // Set the document level permission to be applied for output document
28            DocumentLevelPermission documentLevelPermission = DocumentLevelPermission.FORM_FILLING;
29
30            // Create AppearanceOptions and add the required signature display items to it
31            AppearanceOptions appearanceOptions = new AppearanceOptions();
32            appearanceOptions.addItem(AppearanceItem.NAME);
33            appearanceOptions.addItem(AppearanceItem.LABELS);
34            appearanceOptions.addItem(AppearanceItem.DATE);
35            appearanceOptions.addItem(AppearanceItem.SEAL_IMAGE);
36            appearanceOptions.addItem(AppearanceItem.DISTINGUISHED_NAME);
37        
38        
39            // Sets the Seal Field Name to be created in input PDF document.
40            String sealFieldName = "Signature1";
41        
42            // Sets the page number in input document for applying seal.
43            Integer sealPageNumber = 1;
44        
45            // Sets if seal should be visible or invisible.
46            Boolean sealVisible = true;
47        
48            // CreatesFieldLocation instance and set the coordinates for applying signature
49            FieldLocation fieldLocation = new FieldLocation(150, 250, 350, 200);
50        
51            // Create FieldOptions instance with required details.
52            FieldOptions fieldOptions = new FieldOptions.Builder(sealFieldName)
53                .setFieldLocation(fieldLocation)
54                .setPageNumber(sealPageNumber)
55                .setVisible(sealVisible)
56                .build();
57        
58            // Sets the name of TSP Provider being used.
59            String providerName = "<PROVIDER_NAME>";
60        
61            // Sets the access token to be used to access TSP provider hosted APIs.
62            String accessToken = "<ACCESS_TOKEN>";
63        
64            // Sets the credential ID.
65            String credentialID = "<CREDENTIAL_ID>";
66        
67            // Sets the PIN generated while creating credentials.
68            String pin = "<PIN>";
69        
70            // Creates CSCAuthContext instance using access token and token type.
71            CSCAuthContext cscAuthContext = new CSCAuthContext(accessToken, "Bearer");
72        
73            // Create CertificateCredentials instance with required certificate details.
74            CertificateCredentials certificateCredentials = CertificateCredentials.cscCredentialBuilder()
75                .withProviderName(providerName)
76                .withCredentialID(credentialID)
77                .withPin(pin)
78                .withCSCAuthContext(cscAuthContext)
79                .build();
80            
81            // Create parameters for the job
82            PDFElectronicSealParams pdfElectronicSealParams = PDFElectronicSealParams
83                .pdfElectronicSealParamsBuilder(certificateCredentials, fieldOptions)
84                .withDocumentLevelPermission(documentLevelPermission)
85                .withAppearanceOptions(appearanceOptions)
86                .build();
87        
88            // Creates a new job instance
89            PDFElectronicSealJob pdfElectronicSealJob = new PDFElectronicSealJob(asset, pdfElectronicSealParams);
90            pdfElectronicSealJob.setSealImageAsset(sealImageAsset);
91        
92            // Submit the job and gets the job result
93            String location = pdfServices.submit(pdfElectronicSealJob);
94            PDFServicesResponse<PDFElectronicSealResult> pdfServicesResponse = pdfServices.getJobResult(location, PDFElectronicSealResult.class);
95        
96            // Get content from the resulting asset(s)
97            Asset resultAsset = pdfServicesResponse.getResult().getAsset();
98            StreamAsset streamAsset = pdfServices.getContent(resultAsset);
99        
100            // Creates an output stream and copy stream asset's content to it
101            Files.createDirectories(Paths.get("output/"));
102            OutputStream outputStream = Files.newOutputStream(new File("output/sealedOutput.pdf").toPath());
103            LOGGER.info("Saving asset at output/sealedOutput.pdf");
104            IOUtils.copy(streamAsset.getInputStream(), outputStream);
105            outputStream.close();
106        } catch (ServiceApiException | IOException | SDKException | ServiceUsageException ex) {
107            LOGGER.error("Exception encountered while executing operation", ex);
108        }
109    }
110}
111

// Get the samples from https://www.adobe.com/go/pdftoolsapi_net_samples
// Run the sample:
// cd ElectronicSealWithAppearanceOptions/
// dotnet run ElectronicSealWithAppearanceOptions.csproj

namespace ElectronicSealWithAppearanceOptions
{
    class Program
    {
        // Initialize the logger.
        private static readonly ILog log = LogManager.GetLogger(typeof(Program));
        static void Main()
        {
            //Configure the logging
            ConfigureLogging();

            try
            {
                // Initial setup, create credentials instance.
                Credentials credentials = Credentials.ServicePrincipalCredentialsBuilder()
                    .WithClientId("PDF_SERVICES_CLIENT_ID")
                    .WithClientSecret("PDF_SERVICES_CLIENT_SECRET")
                    .Build();


                // Create an ExecutionContext using credentials.
                ExecutionContext executionContext = ExecutionContext.Create(credentials);

                //Set the input document to perform the sealing operation
                FileRef sourceFile = FileRef.CreateFromLocalFile(@"SampleInvoice.pdf");

                //Set the background seal image for signature , if required.
                FileRef sealImageFile = FileRef.CreateFromLocalFile(@"sampleSealImage.png");

                //Create AppearanceOptions and add the required signature appearance items
                AppearanceOptions appearanceOptions = new AppearanceOptions();
                appearanceOptions.AddItem(AppearanceItem.NAME);
                appearanceOptions.AddItem(AppearanceItem.LABELS);
                appearanceOptions.AddItem(AppearanceItem.DATE);
                appearanceOptions.AddItem(AppearanceItem.SEAL_IMAGE);
                appearanceOptions.AddItem(AppearanceItem.DISTINGUISHED_NAME);

                //Set the Seal Field Name to be created in input PDF document.
                string sealFieldName = "Signature1";

                //Set the page number in input document for applying seal.
                int sealPageNumber = 1;

                //Set if seal should be visible or invisible.
                bool sealVisible = true;

                //Create FieldLocation instance and set the coordinates for applying signature
                FieldLocation fieldLocation = new FieldLocation(150, 250, 350, 200);
                
                //Create FieldOptions instance with required details.
                FieldOptions fieldOptions = new FieldOptions.Builder(sealFieldName)
                    .SetVisible(sealVisible)
                    .SetFieldLocation(fieldLocation)
                    .SetPageNumber(sealPageNumber)
                    .Build();

                //Set the name of TSP Provider being used.
                string providerName = "<PROVIDER_NAME>";

                //Set the access token to be used to access TSP provider hosted APIs.
                string accessToken = "<ACCESS_TOKEN>";

                //Set the credential ID.
                string credentialID = "<CREDENTIAL_ID>";

                //Set the PIN generated while creating credentials.
                string pin = "<PIN>";

                CSCAuthContext cscAuthContext = new CSCAuthContext(accessToken, "Bearer");

                //Create CertificateCredentials instance with required certificate details.
                CertificateCredentials certificateCredentials = CertificateCredentials.CSCCredentialBuilder()
                    .WithProviderName(providerName)
                    .WithCredentialID(credentialID)
                    .WithPin(pin)
                    .WithCSCAuthContext(cscAuthContext)
                    .Build();
                
                
                //Create SealingOptions instance with all the sealing parameters.
                SealOptions sealOptions = new SealOptions.Builder(certificateCredentials, fieldOptions)
                    .WithAppearanceOptions(appearanceOptions).Build();

                //Create the PDFElectronicSealOperation instance using the SealOptions instance
                PDFElectronicSealOperation pdfElectronicSealOperation = PDFElectronicSealOperation.CreateNew(sealOptions);

                //Set the input source file for PDFElectronicSealOperation instance
                pdfElectronicSealOperation.SetInput(sourceFile);

                //Set the optional input seal image for PDFElectronicSealOperation instance
                pdfElectronicSealOperation.SetSealImage(sealImageFile);

                //Execute the operation
                FileRef result = pdfElectronicSealOperation.Execute(executionContext);

                // Save the output at specified location.
                result.SaveAs(output/sealedOutput.pdf);
            }
            catch (ServiceUsageException ex)
            {
                log.Error("Exception encountered while executing operation", ex);
            }
            catch (ServiceApiException ex)
            {
                log.Error("Exception encountered while executing operation", ex);
            }
            catch (SDKException ex)
            {
                log.Error("Exception encountered while executing operation", ex);
            }
            catch (IOException ex)
            {
                log.Error("Exception encountered while executing operation", ex);
            }
            catch (Exception ex)
            {
                log.Error("Exception encountered while executing operation", ex);
            }

        }
        static void ConfigureLogging()
        {
            ILoggerRepository logRepository = LogManager.GetRepository(Assembly.GetEntryAssembly());
            XmlConfigurator.Configure(logRepository, new FileInfo("log4net.config"));
        }
    }
}
CopyCopied to your clipboard
1// Get the samples from https://www.adobe.com/go/pdftoolsapi_net_samples
2// Run the sample:
3// cd ElectronicSealWithAppearanceOptions/
4// dotnet run ElectronicSealWithAppearanceOptions.csproj
5
6namespace ElectronicSealWithAppearanceOptions
7{
8    class Program
9    {
10        // Initialize the logger.
11        private static readonly ILog log = LogManager.GetLogger(typeof(Program));
12        static void Main()
13        {
14            //Configure the logging
15            ConfigureLogging();
16
17            try
18            {
19                // Initial setup, create credentials instance.
20                Credentials credentials = Credentials.ServicePrincipalCredentialsBuilder()
21                    .WithClientId("PDF_SERVICES_CLIENT_ID")
22                    .WithClientSecret("PDF_SERVICES_CLIENT_SECRET")
23                    .Build();
24
25
26                // Create an ExecutionContext using credentials.
27                ExecutionContext executionContext = ExecutionContext.Create(credentials);
28
29                //Set the input document to perform the sealing operation
30                FileRef sourceFile = FileRef.CreateFromLocalFile(@"SampleInvoice.pdf");
31
32                //Set the background seal image for signature , if required.
33                FileRef sealImageFile = FileRef.CreateFromLocalFile(@"sampleSealImage.png");
34
35                //Create AppearanceOptions and add the required signature appearance items
36                AppearanceOptions appearanceOptions = new AppearanceOptions();
37                appearanceOptions.AddItem(AppearanceItem.NAME);
38                appearanceOptions.AddItem(AppearanceItem.LABELS);
39                appearanceOptions.AddItem(AppearanceItem.DATE);
40                appearanceOptions.AddItem(AppearanceItem.SEAL_IMAGE);
41                appearanceOptions.AddItem(AppearanceItem.DISTINGUISHED_NAME);
42
43                //Set the Seal Field Name to be created in input PDF document.
44                string sealFieldName = "Signature1";
45
46                //Set the page number in input document for applying seal.
47                int sealPageNumber = 1;
48
49                //Set if seal should be visible or invisible.
50                bool sealVisible = true;
51
52                //Create FieldLocation instance and set the coordinates for applying signature
53                FieldLocation fieldLocation = new FieldLocation(150, 250, 350, 200);
54                
55                //Create FieldOptions instance with required details.
56                FieldOptions fieldOptions = new FieldOptions.Builder(sealFieldName)
57                    .SetVisible(sealVisible)
58                    .SetFieldLocation(fieldLocation)
59                    .SetPageNumber(sealPageNumber)
60                    .Build();
61
62                //Set the name of TSP Provider being used.
63                string providerName = "<PROVIDER_NAME>";
64
65                //Set the access token to be used to access TSP provider hosted APIs.
66                string accessToken = "<ACCESS_TOKEN>";
67
68                //Set the credential ID.
69                string credentialID = "<CREDENTIAL_ID>";
70
71                //Set the PIN generated while creating credentials.
72                string pin = "<PIN>";
73
74                CSCAuthContext cscAuthContext = new CSCAuthContext(accessToken, "Bearer");
75
76                //Create CertificateCredentials instance with required certificate details.
77                CertificateCredentials certificateCredentials = CertificateCredentials.CSCCredentialBuilder()
78                    .WithProviderName(providerName)
79                    .WithCredentialID(credentialID)
80                    .WithPin(pin)
81                    .WithCSCAuthContext(cscAuthContext)
82                    .Build();
83                
84                
85                //Create SealingOptions instance with all the sealing parameters.
86                SealOptions sealOptions = new SealOptions.Builder(certificateCredentials, fieldOptions)
87                    .WithAppearanceOptions(appearanceOptions).Build();
88
89                //Create the PDFElectronicSealOperation instance using the SealOptions instance
90                PDFElectronicSealOperation pdfElectronicSealOperation = PDFElectronicSealOperation.CreateNew(sealOptions);
91
92                //Set the input source file for PDFElectronicSealOperation instance
93                pdfElectronicSealOperation.SetInput(sourceFile);
94
95                //Set the optional input seal image for PDFElectronicSealOperation instance
96                pdfElectronicSealOperation.SetSealImage(sealImageFile);
97
98                //Execute the operation
99                FileRef result = pdfElectronicSealOperation.Execute(executionContext);
100
101                // Save the output at specified location.
102                result.SaveAs(output/sealedOutput.pdf);
103            }
104            catch (ServiceUsageException ex)
105            {
106                log.Error("Exception encountered while executing operation", ex);
107            }
108            catch (ServiceApiException ex)
109            {
110                log.Error("Exception encountered while executing operation", ex);
111            }
112            catch (SDKException ex)
113            {
114                log.Error("Exception encountered while executing operation", ex);
115            }
116            catch (IOException ex)
117            {
118                log.Error("Exception encountered while executing operation", ex);
119            }
120            catch (Exception ex)
121            {
122                log.Error("Exception encountered while executing operation", ex);
123            }
124
125        }
126        static void ConfigureLogging()
127        {
128            ILoggerRepository logRepository = LogManager.GetRepository(Assembly.GetEntryAssembly());
129            XmlConfigurator.Configure(logRepository, new FileInfo("log4net.config"));
130        }
131    }
132}

// Get the samples from http://www.adobe.com/go/pdftoolsapi_node_sample
// Run the sample:
// node src/electronicseal/electronic-seal-with-appearance-options.js

const {
    ServicePrincipalCredentials,
    PDFServices,
    MimeType,
    FieldLocation,
    FieldOptions,
    CSCAuthContext,
    CSCCredential,
    PDFElectronicSealParams,
    PDFElectronicSealJob,
    PDFElectronicSealResult,
    AppearanceOptions,
    AppearanceItem,
    SDKError,
    ServiceUsageError,
    ServiceApiError, DocumentLevelPermission
} = require("@adobe/pdfservices-node-sdk");
const fs = require("fs");

(async () => {

    let sourceFileReadStream;
    let sealImageReadStream;
    try {
        // Initial setup, create credentials instance
        const credentials = new ServicePrincipalCredentials({
            clientId: process.env.PDF_SERVICES_CLIENT_ID,
            clientSecret: process.env.PDF_SERVICES_CLIENT_SECRET
        });

        // Creates a PDF Services instance
        const pdfServices = new PDFServices({credentials});

        // Creates an asset(s) from source file(s) and upload
        sourceFileReadStream = fs.createReadStream("./sampleInvoice.pdf")
        sealImageReadStream = fs.createReadStream("./sampleSealImage.png");
        const [sourceFileAsset, sealImageAsset] = await pdfServices.uploadAssets({
            streamAssets: [{
                readStream: sourceFileReadStream,
                mimeType: MimeType.PDF
            }, {
                readStream: sealImageReadStream,
                mimeType: MimeType.PNG
            }]
        });

        // Set the document level permission to be applied for output document
        const documentLevelPermission = DocumentLevelPermission.FORM_FILLING;

        // Create AppearanceOptions and add the required signature appearance items
        const sealAppearanceOptions = new AppearanceOptions({
            items: [
                AppearanceItem.DATE,
                AppearanceItem.SEAL_IMAGE,
                AppearanceItem.NAME,
                AppearanceItem.LABELS,
                AppearanceItem.DISTINGUISHED_NAME
            ]
        });

        // Set the Seal Field Name to be created in input PDF document
        const sealFieldName = "Signature1";

        // Set the page number in input document for applying seal
        const sealPageNumber = 1;

        // Set if seal should be visible or invisible
        const sealVisible = true;

        // Create FieldLocation instance and set the coordinates for applying signature
        const fieldLocation = new FieldLocation({
            left: 150,
            top: 250,
            right: 350,
            bottom: 200
        });

        // Create FieldOptions instance with required details
        const sealFieldOptions = new FieldOptions({
            visible: sealVisible,
            location: fieldLocation,
            fieldName: sealFieldName,
            pageNumber: sealPageNumber,
        });

        // Set the name of TSP Provider being used
        const providerName = "<PROVIDER_NAME>";

        // Set the access token to be used to access TSP provider hosted APIs
        const accessToken = "<ACCESS_TOKEN>";

        // Set the credential ID
        const credentialId = "<CREDENTIAL_ID>";

        // Set the PIN generated while creating credentials
        const pin = "<PIN>";

        // Create CSCAuthContext instance using access token and token type
        const authorizationContext = new CSCAuthContext({
            accessToken,
            tokenType: "Bearer"
        });

        // Create CertificateCredentials instance with required certificate details
        const certificateCredentials = new CSCCredential({
            providerName,
            credentialId,
            pin,
            authorizationContext,
        });

        // Create parameters for the job
        const params = new PDFElectronicSealParams({
            documentLevelPermission
            certificateCredentials,
            sealFieldOptions,
            sealAppearanceOptions
        });

        // Creates a new job instance
        const job = new PDFElectronicSealJob({
            inputAsset: sourceFileAsset,
            sealImageAsset,
            params,
        });

        // Submit the job and get the job result
        const pollingURL = await pdfServices.submit({job});
        const pdfServicesResponse = await pdfServices.getJobResult({
            pollingURL,
            resultType: PDFElectronicSealResult
        });

        // Get content from the resulting asset(s)
        const resultAsset = pdfServicesResponse.result.asset;
        const streamAsset = await pdfServices.getContent({asset: resultAsset});

        // Creates a write stream and copy stream asset's content to it
        const outputFilePath = "./sealedOutput.pdf";
        console.log(`Saving asset at ${outputFilePath}`);

        const writeStream = fs.createWriteStream(outputFilePath);
        streamAsset.readStream.pipe(writeStream);
    } catch (err) {
        if (err instanceof SDKError || err instanceof ServiceUsageError || err instanceof ServiceApiError) {
            console.log("Exception encountered while executing operation", err);
        } else {
            console.log("Exception encountered while executing operation", err);
        }
    } finally {
        sourceFileReadStream?.destroy();
        sealImageReadStream?.destroy();
    }
})();
CopyCopied to your clipboard
1// Get the samples from http://www.adobe.com/go/pdftoolsapi_node_sample
2// Run the sample:
3// node src/electronicseal/electronic-seal-with-appearance-options.js
4
5const {
6    ServicePrincipalCredentials,
7    PDFServices,
8    MimeType,
9    FieldLocation,
10    FieldOptions,
11    CSCAuthContext,
12    CSCCredential,
13    PDFElectronicSealParams,
14    PDFElectronicSealJob,
15    PDFElectronicSealResult,
16    AppearanceOptions,
17    AppearanceItem,
18    SDKError,
19    ServiceUsageError,
20    ServiceApiError, DocumentLevelPermission
21} = require("@adobe/pdfservices-node-sdk");
22const fs = require("fs");
23
24(async () => {
25
26    let sourceFileReadStream;
27    let sealImageReadStream;
28    try {
29        // Initial setup, create credentials instance
30        const credentials = new ServicePrincipalCredentials({
31            clientId: process.env.PDF_SERVICES_CLIENT_ID,
32            clientSecret: process.env.PDF_SERVICES_CLIENT_SECRET
33        });
34
35        // Creates a PDF Services instance
36        const pdfServices = new PDFServices({credentials});
37
38        // Creates an asset(s) from source file(s) and upload
39        sourceFileReadStream = fs.createReadStream("./sampleInvoice.pdf")
40        sealImageReadStream = fs.createReadStream("./sampleSealImage.png");
41        const [sourceFileAsset, sealImageAsset] = await pdfServices.uploadAssets({
42            streamAssets: [{
43                readStream: sourceFileReadStream,
44                mimeType: MimeType.PDF
45            }, {
46                readStream: sealImageReadStream,
47                mimeType: MimeType.PNG
48            }]
49        });
50
51        // Set the document level permission to be applied for output document
52        const documentLevelPermission = DocumentLevelPermission.FORM_FILLING;
53
54        // Create AppearanceOptions and add the required signature appearance items
55        const sealAppearanceOptions = new AppearanceOptions({
56            items: [
57                AppearanceItem.DATE,
58                AppearanceItem.SEAL_IMAGE,
59                AppearanceItem.NAME,
60                AppearanceItem.LABELS,
61                AppearanceItem.DISTINGUISHED_NAME
62            ]
63        });
64
65        // Set the Seal Field Name to be created in input PDF document
66        const sealFieldName = "Signature1";
67
68        // Set the page number in input document for applying seal
69        const sealPageNumber = 1;
70
71        // Set if seal should be visible or invisible
72        const sealVisible = true;
73
74        // Create FieldLocation instance and set the coordinates for applying signature
75        const fieldLocation = new FieldLocation({
76            left: 150,
77            top: 250,
78            right: 350,
79            bottom: 200
80        });
81
82        // Create FieldOptions instance with required details
83        const sealFieldOptions = new FieldOptions({
84            visible: sealVisible,
85            location: fieldLocation,
86            fieldName: sealFieldName,
87            pageNumber: sealPageNumber,
88        });
89
90        // Set the name of TSP Provider being used
91        const providerName = "<PROVIDER_NAME>";
92
93        // Set the access token to be used to access TSP provider hosted APIs
94        const accessToken = "<ACCESS_TOKEN>";
95
96        // Set the credential ID
97        const credentialId = "<CREDENTIAL_ID>";
98
99        // Set the PIN generated while creating credentials
100        const pin = "<PIN>";
101
102        // Create CSCAuthContext instance using access token and token type
103        const authorizationContext = new CSCAuthContext({
104            accessToken,
105            tokenType: "Bearer"
106        });
107
108        // Create CertificateCredentials instance with required certificate details
109        const certificateCredentials = new CSCCredential({
110            providerName,
111            credentialId,
112            pin,
113            authorizationContext,
114        });
115
116        // Create parameters for the job
117        const params = new PDFElectronicSealParams({
118            documentLevelPermission
119            certificateCredentials,
120            sealFieldOptions,
121            sealAppearanceOptions
122        });
123
124        // Creates a new job instance
125        const job = new PDFElectronicSealJob({
126            inputAsset: sourceFileAsset,
127            sealImageAsset,
128            params,
129        });
130
131        // Submit the job and get the job result
132        const pollingURL = await pdfServices.submit({job});
133        const pdfServicesResponse = await pdfServices.getJobResult({
134            pollingURL,
135            resultType: PDFElectronicSealResult
136        });
137
138        // Get content from the resulting asset(s)
139        const resultAsset = pdfServicesResponse.result.asset;
140        const streamAsset = await pdfServices.getContent({asset: resultAsset});
141
142        // Creates a write stream and copy stream asset's content to it
143        const outputFilePath = "./sealedOutput.pdf";
144        console.log(`Saving asset at ${outputFilePath}`);
145
146        const writeStream = fs.createWriteStream(outputFilePath);
147        streamAsset.readStream.pipe(writeStream);
148    } catch (err) {
149        if (err instanceof SDKError || err instanceof ServiceUsageError || err instanceof ServiceApiError) {
150            console.log("Exception encountered while executing operation", err);
151        } else {
152            console.log("Exception encountered while executing operation", err);
153        }
154    } finally {
155        sourceFileReadStream?.destroy();
156        sealImageReadStream?.destroy();
157    }
158})();

curl --location --request POST 'https://pdf-services.adobe.io/operation/electronicseal' \
--header 'x-api-key: {{Placeholder for client_id}}' \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer {{Placeholder for token}}' \
--data-raw '{
    "inputDocumentAssetID": "urn:aaid:AS:UE1:23c30ee0-2c4d-xxxx-xxxx-087832fca718",
    "sealImageAssetID": "urn:aaid:AS:UE1:23c30ee0-2e4d-xxxx-xxxx-087832fca718",
    "sealOptions": {
        "signatureFormat": "PKCS7",
        "documentLevelPermission": "FORM_FILLING",
        "cscCredentialOptions": {
            "credentialId": "<CREDENTIAL_ID>",
            "providerName": "<PROVIDER_NAME>",
            "authorizationContext": {
                "tokenType": "Bearer",
                "accessToken": "<ACCESS_TOKEN>"
            },
            "credentialAuthParameters": {
                "pin": "<PIN>"
            }
        },
        "sealFieldOptions": {
            "location": {
                "left": 150,
                "top": 250,
                "right": 350,
                "bottom": 200
            },
            "fieldName": "Signature1",
            "pageNumber": 1
        },
        "sealAppearanceOptions": {
            "displayOptions": [
                "NAME",
                "DATE",
                "DISTINGUISHED_NAME",
                "LABELS",
                "SEAL_IMAGE"
            ]
        }
    }
}'
CopyCopied to your clipboard
1curl --location --request POST 'https://pdf-services.adobe.io/operation/electronicseal' \
2--header 'x-api-key: {{Placeholder for client_id}}' \
3--header 'Content-Type: application/json' \
4--header 'Authorization: Bearer {{Placeholder for token}}' \
5--data-raw '{
6    "inputDocumentAssetID": "urn:aaid:AS:UE1:23c30ee0-2c4d-xxxx-xxxx-087832fca718",
7    "sealImageAssetID": "urn:aaid:AS:UE1:23c30ee0-2e4d-xxxx-xxxx-087832fca718",
8    "sealOptions": {
9        "signatureFormat": "PKCS7",
10        "documentLevelPermission": "FORM_FILLING",
11        "cscCredentialOptions": {
12            "credentialId": "<CREDENTIAL_ID>",
13            "providerName": "<PROVIDER_NAME>",
14            "authorizationContext": {
15                "tokenType": "Bearer",
16                "accessToken": "<ACCESS_TOKEN>"
17            },
18            "credentialAuthParameters": {
19                "pin": "<PIN>"
20            }
21        },
22        "sealFieldOptions": {
23            "location": {
24                "left": 150,
25                "top": 250,
26                "right": 350,
27                "bottom": 200
28            },
29            "fieldName": "Signature1",
30            "pageNumber": 1
31        },
32        "sealAppearanceOptions": {
33            "displayOptions": [
34                "NAME",
35                "DATE",
36                "DISTINGUISHED_NAME",
37                "LABELS",
38                "SEAL_IMAGE"
39            ]
40        }
41    }
42}'