Insert Pages

// 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.insertpages.InsertPDFPages
 
    public class InsertPDFPages {
  
     // Initialize the logger.
     private static final Logger LOGGER = LoggerFactory.getLogger(InsertPDFPages.class);
  
     public static void main(String[] args) {
         try (InputStream baseInputStream = Files.newInputStream(new File("src/main/resources/baseInput.pdf").toPath());
              InputStream firstInputStreamToInsert = Files.newInputStream(new File("src/main/resources/firstFileToInsertInput.pdf").toPath());
              InputStream secondInputStreamToInsert = Files.newInputStream(new File("src/main/resources/secondFileToInsertInput.pdf").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 baseAsset = pdfServices.upload(baseInputStream, PDFServicesMediaType.PDF.getMediaType());
            Asset firstAssetToInsert = pdfServices.upload(firstInputStreamToInsert, PDFServicesMediaType.PDF.getMediaType());
            Asset secondAssetToInsert = pdfServices.upload(secondInputStreamToInsert, PDFServicesMediaType.PDF.getMediaType());

            PageRanges pageRanges = getPageRangeForFirstFile();

            // Create parameters for the job
            InsertPagesParams insertPagesParams = InsertPagesParams.insertPagesParamsBuilder(baseAsset)
                    .addPagesToInsertAt(firstAssetToInsert, pageRanges, 2) // Add the first asset as input to the params, along with its page ranges and base page
                    .addPagesToInsertAt(secondAssetToInsert, 3) // Add the seccond asset as input to the params, along with base page
                    .build();

            // Creates a new job instance
            InsertPagesPDFJob insertPagesJob = new InsertPagesPDFJob(insertPagesParams);

            // Submit the job and gets the job result
            String location = pdfServices.submit(insertPagesJob);
            PDFServicesResponse<InsertPagesResult> pdfServicesResponse = pdfServices.getJobResult(location, InsertPagesResult.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/insertPagesOutput.pdf").toPath());
            LOGGER.info("Saving asset at output/insertPagesOutput.pdf");
            IOUtils.copy(streamAsset.getInputStream(), outputStream);
            outputStream.close();
         } catch (IOException | ServiceApiException | SDKException | ServiceUsageException e) {
             LOGGER.error("Exception encountered while executing operation", e);
         }
     }
  
     private static PageRanges getPageRangeForFirstFile() {
         // Specify which pages of the first file are to be inserted in the base file
         PageRanges pageRanges = new PageRanges();
         // Add pages 1 to 3
         pageRanges.addRange(1, 3);
  
         // Add page 4.
         pageRanges.addSinglePage(4);
  
         return pageRanges;
     }
   }
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.insertpages.InsertPDFPages
4 
5    public class InsertPDFPages {
6  
7     // Initialize the logger.
8     private static final Logger LOGGER = LoggerFactory.getLogger(InsertPDFPages.class);
9  
10     public static void main(String[] args) {
11         try (InputStream baseInputStream = Files.newInputStream(new File("src/main/resources/baseInput.pdf").toPath());
12              InputStream firstInputStreamToInsert = Files.newInputStream(new File("src/main/resources/firstFileToInsertInput.pdf").toPath());
13              InputStream secondInputStreamToInsert = Files.newInputStream(new File("src/main/resources/secondFileToInsertInput.pdf").toPath())) {
14            // Initial setup, create credentials instance
15            Credentials credentials = new ServicePrincipalCredentials(
16                    System.getenv("PDF_SERVICES_CLIENT_ID"),
17                    System.getenv("PDF_SERVICES_CLIENT_SECRET"));
18
19            // Creates a PDF Services instance
20            PDFServices pdfServices = new PDFServices(credentials);
21
22            // Creates an asset(s) from source file(s) and upload
23            Asset baseAsset = pdfServices.upload(baseInputStream, PDFServicesMediaType.PDF.getMediaType());
24            Asset firstAssetToInsert = pdfServices.upload(firstInputStreamToInsert, PDFServicesMediaType.PDF.getMediaType());
25            Asset secondAssetToInsert = pdfServices.upload(secondInputStreamToInsert, PDFServicesMediaType.PDF.getMediaType());
26
27            PageRanges pageRanges = getPageRangeForFirstFile();
28
29            // Create parameters for the job
30            InsertPagesParams insertPagesParams = InsertPagesParams.insertPagesParamsBuilder(baseAsset)
31                    .addPagesToInsertAt(firstAssetToInsert, pageRanges, 2) // Add the first asset as input to the params, along with its page ranges and base page
32                    .addPagesToInsertAt(secondAssetToInsert, 3) // Add the seccond asset as input to the params, along with base page
33                    .build();
34
35            // Creates a new job instance
36            InsertPagesPDFJob insertPagesJob = new InsertPagesPDFJob(insertPagesParams);
37
38            // Submit the job and gets the job result
39            String location = pdfServices.submit(insertPagesJob);
40            PDFServicesResponse<InsertPagesResult> pdfServicesResponse = pdfServices.getJobResult(location, InsertPagesResult.class);
41
42            // Get content from the resulting asset(s)
43            Asset resultAsset = pdfServicesResponse.getResult().getAsset();
44            StreamAsset streamAsset = pdfServices.getContent(resultAsset);
45
46            // Creates an output stream and copy stream asset's content to it
47            Files.createDirectories(Paths.get("output/"));
48            OutputStream outputStream = Files.newOutputStream(new File("output/insertPagesOutput.pdf").toPath());
49            LOGGER.info("Saving asset at output/insertPagesOutput.pdf");
50            IOUtils.copy(streamAsset.getInputStream(), outputStream);
51            outputStream.close();
52         } catch (IOException | ServiceApiException | SDKException | ServiceUsageException e) {
53             LOGGER.error("Exception encountered while executing operation", e);
54         }
55     }
56  
57     private static PageRanges getPageRangeForFirstFile() {
58         // Specify which pages of the first file are to be inserted in the base file
59         PageRanges pageRanges = new PageRanges();
60         // Add pages 1 to 3
61         pageRanges.addRange(1, 3);
62  
63         // Add page 4.
64         pageRanges.addSinglePage(4);
65  
66         return pageRanges;
67     }
68   }

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

  namespace InsertPDFPages
  {
    class Program
    {
        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);
 
                // Create a new operation instance
                InsertPagesOperation insertPagesOperation = InsertPagesOperation.CreateNew();
 
                // Set operation base input from a source file.
                FileRef baseSourceFile = FileRef.CreateFromLocalFile(@"baseInput.pdf");
                insertPagesOperation.SetBaseInput(baseSourceFile);
 
                // Create a FileRef instance using a local file.
                FileRef firstFileToInsert = FileRef.CreateFromLocalFile(@"firstFileToInsertInput.pdf");
                PageRanges pageRanges = GetPageRangeForFirstFile();
 
                // Adds the pages (specified by the page ranges) of the input PDF file to be inserted at
                // the specified page of the base PDF file.
                insertPagesOperation.AddPagesToInsertAt(firstFileToInsert, pageRanges, 2);
 
                // Create a FileRef instance using a local file.
                FileRef secondFileToInsert = FileRef.CreateFromLocalFile(@"secondFileToInsertInput.pdf");
 
                // Adds all the pages of the input PDF file to be inserted at the specified page of the
                // base PDF file.
                insertPagesOperation.AddPagesToInsertAt(secondFileToInsert, 3);
 
                // Execute the operation.
                FileRef result = insertPagesOperation.Execute(executionContext);
 
                // Save the result to the specified location.
                result.SaveAs(Directory.GetCurrentDirectory() + "/output/insertPagesOutput.pdf");
            }
            catch (ServiceUsageException ex)
            {
                log.Error("Exception encountered while executing operation", ex);
            // Catch more errors here . . .
        }
 
        private static PageRanges GetPageRangeForFirstFile()
        {
            // Specify which pages of the first file are to be inserted in the base file.
            PageRanges pageRanges = new PageRanges();
            // Add pages 1 to 3.
            pageRanges.AddRange(1, 3);
 
            // Add page 4.
            pageRanges.AddSinglePage(4);
 
            return pageRanges;
        }
 
        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 InsertPDFPages/
4// dotnet run InsertPDFPages.csproj
5
6  namespace InsertPDFPages
7  {
8    class Program
9    {
10        private static readonly ILog log = LogManager.GetLogger(typeof(Program));
11        static void Main()
12        {
13            // Configure the logging
14            ConfigureLogging();
15            try
16            {
17                // Initial setup, create credentials instance.
18                Credentials credentials = Credentials.ServicePrincipalCredentialsBuilder()
19                    .WithClientId("PDF_SERVICES_CLIENT_ID")
20                    .WithClientSecret("PDF_SERVICES_CLIENT_SECRET")
21                    .Build();
22 
23                // Create an ExecutionContext using credentials.
24                ExecutionContext executionContext = ExecutionContext.Create(credentials);
25 
26                // Create a new operation instance
27                InsertPagesOperation insertPagesOperation = InsertPagesOperation.CreateNew();
28 
29                // Set operation base input from a source file.
30                FileRef baseSourceFile = FileRef.CreateFromLocalFile(@"baseInput.pdf");
31                insertPagesOperation.SetBaseInput(baseSourceFile);
32 
33                // Create a FileRef instance using a local file.
34                FileRef firstFileToInsert = FileRef.CreateFromLocalFile(@"firstFileToInsertInput.pdf");
35                PageRanges pageRanges = GetPageRangeForFirstFile();
36 
37                // Adds the pages (specified by the page ranges) of the input PDF file to be inserted at
38                // the specified page of the base PDF file.
39                insertPagesOperation.AddPagesToInsertAt(firstFileToInsert, pageRanges, 2);
40 
41                // Create a FileRef instance using a local file.
42                FileRef secondFileToInsert = FileRef.CreateFromLocalFile(@"secondFileToInsertInput.pdf");
43 
44                // Adds all the pages of the input PDF file to be inserted at the specified page of the
45                // base PDF file.
46                insertPagesOperation.AddPagesToInsertAt(secondFileToInsert, 3);
47 
48                // Execute the operation.
49                FileRef result = insertPagesOperation.Execute(executionContext);
50 
51                // Save the result to the specified location.
52                result.SaveAs(Directory.GetCurrentDirectory() + "/output/insertPagesOutput.pdf");
53            }
54            catch (ServiceUsageException ex)
55            {
56                log.Error("Exception encountered while executing operation", ex);
57            // Catch more errors here . . .
58        }
59 
60        private static PageRanges GetPageRangeForFirstFile()
61        {
62            // Specify which pages of the first file are to be inserted in the base file.
63            PageRanges pageRanges = new PageRanges();
64            // Add pages 1 to 3.
65            pageRanges.AddRange(1, 3);
66 
67            // Add page 4.
68            pageRanges.AddSinglePage(4);
69 
70            return pageRanges;
71        }
72 
73        static void ConfigureLogging()
74        {
75            ILoggerRepository logRepository = LogManager.GetRepository(Assembly.GetEntryAssembly());
76            XmlConfigurator.Configure(logRepository, new FileInfo("log4net.config"));
77        }
78    }
79  }

// Get the samples from http://www.adobe.com/go/pdftoolsapi_node_sample
// Run the sample:
// node src/insertpages/insert-pdf-pages.js

const {
    ServicePrincipalCredentials,
    PDFServices,
    MimeType,
    PageRanges,
    InsertPagesParams,
    InsertPagesJob,
    InsertPagesResult,
    SDKError,
    ServiceUsageError,
    ServiceApiError
} = require("@adobe/pdfservices-node-sdk");
const fs = require("fs");

(async () => {
    let baseReadStream;
    let firstReadStreamToInsert;
    let secondReadStreamToInsert;
    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
        baseReadStream = fs.createReadStream("./baseInput.pdf");
        firstReadStreamToInsert = fs.createReadStream("./firstFileToInsertInput.pdf");
        secondReadStreamToInsert = fs.createReadStream("./secondFileToInsertInput.pdf");
        const [baseAsset, firstAssetToInsert, secondAssetToInsert] = await pdfServices.uploadAssets({
            streamAssets: [{
                readStream: baseReadStream,
                mimeType: MimeType.PDF
            }, {
                readStream: firstReadStreamToInsert,
                mimeType: MimeType.PDF
            }, {
                readStream: secondReadStreamToInsert,
                mimeType: MimeType.PDF
            }]
        });

        // Create parameters for the job
        const params = new InsertPagesParams(baseAsset)
            // Add the first asset as input to the params, along with its page ranges and base page
            .addPagesToInsertAt({
                inputAsset: firstAssetToInsert,
                pageRanges: getPageRangesForFirstFile(),
                basePage: 2
            })
            // Add the second asset as input to the params, along with base page
            .addPagesToInsertAt({
                inputAsset: secondAssetToInsert,
                basePage: 3
            });

        // Create a new job instance
        const job = new InsertPagesJob({params});

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

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

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

        const outputStream = fs.createWriteStream(outputFilePath);
        streamAsset.readStream.pipe(outputStream);
    } 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 {
        baseReadStream?.destroy();
        firstReadStreamToInsert?.destroy();
        secondReadStreamToInsert?.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/insertpages/insert-pdf-pages.js
4
5const {
6    ServicePrincipalCredentials,
7    PDFServices,
8    MimeType,
9    PageRanges,
10    InsertPagesParams,
11    InsertPagesJob,
12    InsertPagesResult,
13    SDKError,
14    ServiceUsageError,
15    ServiceApiError
16} = require("@adobe/pdfservices-node-sdk");
17const fs = require("fs");
18
19(async () => {
20    let baseReadStream;
21    let firstReadStreamToInsert;
22    let secondReadStreamToInsert;
23    try {
24        // Initial setup, create credentials instance
25        const credentials = new ServicePrincipalCredentials({
26            clientId: process.env.PDF_SERVICES_CLIENT_ID,
27            clientSecret: process.env.PDF_SERVICES_CLIENT_SECRET
28        });
29
30        // Creates a PDF Services instance
31        const pdfServices = new PDFServices({credentials});
32
33        // Creates an asset(s) from source file(s) and upload
34        baseReadStream = fs.createReadStream("./baseInput.pdf");
35        firstReadStreamToInsert = fs.createReadStream("./firstFileToInsertInput.pdf");
36        secondReadStreamToInsert = fs.createReadStream("./secondFileToInsertInput.pdf");
37        const [baseAsset, firstAssetToInsert, secondAssetToInsert] = await pdfServices.uploadAssets({
38            streamAssets: [{
39                readStream: baseReadStream,
40                mimeType: MimeType.PDF
41            }, {
42                readStream: firstReadStreamToInsert,
43                mimeType: MimeType.PDF
44            }, {
45                readStream: secondReadStreamToInsert,
46                mimeType: MimeType.PDF
47            }]
48        });
49
50        // Create parameters for the job
51        const params = new InsertPagesParams(baseAsset)
52            // Add the first asset as input to the params, along with its page ranges and base page
53            .addPagesToInsertAt({
54                inputAsset: firstAssetToInsert,
55                pageRanges: getPageRangesForFirstFile(),
56                basePage: 2
57            })
58            // Add the second asset as input to the params, along with base page
59            .addPagesToInsertAt({
60                inputAsset: secondAssetToInsert,
61                basePage: 3
62            });
63
64        // Create a new job instance
65        const job = new InsertPagesJob({params});
66
67        // Submit the job and get the job result
68        const pollingURL = await pdfServices.submit({job});
69        const pdfServicesResponse = await pdfServices.getJobResult({
70            pollingURL,
71            resultType: InsertPagesResult
72        });
73
74        // Get content from the resulting asset(s)
75        const resultAsset = pdfServicesResponse.result.asset;
76        const streamAsset = await pdfServices.getContent({asset: resultAsset});
77
78        // Creates an output stream and copy result asset's content to it
79        const outputFilePath = "./insertPagesOutput.pdf";
80        console.log(`Saving asset at ${outputFilePath}`);
81
82        const outputStream = fs.createWriteStream(outputFilePath);
83        streamAsset.readStream.pipe(outputStream);
84    } catch (err) {
85        if (err instanceof SDKError || err instanceof ServiceUsageError || err instanceof ServiceApiError) {
86            console.log("Exception encountered while executing operation", err);
87        } else {
88            console.log("Exception encountered while executing operation", err);
89        }
90    } finally {
91        baseReadStream?.destroy();
92        firstReadStreamToInsert?.destroy();
93        secondReadStreamToInsert?.destroy();
94    }
95})();

// Please refer our REST API docs for more information 
// https://developer.adobe.com/document-services/docs/apis/#tag/Combine-PDF

curl --location --request POST 'https://pdf-services.adobe.io/operation/combinepdf' \
--header 'x-api-key: {{Placeholder for client_id}}' \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer {{Placeholder for token}}' \
--data-raw '{
    "assets": [
        {
            "assetID": "urn:aaid:AS:UE1:23c30ee0-2e4d-46d6-87f2-087832fca718",
            "pageRanges": [
                {
                    "start": 1,
                    "end": 1
                }
            ]
        },
        {
            "assetID": "urn:aaid:AS:UE1:23c30ee0-2e4d-46d6-87f2-087832fca718",
            "pageRanges": [
                {
                    "start": 4
                }
            ]
        },
        {
            "assetID": "urn:aaid:AS:UE1:23c30ee0-2e4d-46d6-87f2-087832fca718",
            "pageRanges": [
                {
                    "start": 1
                }
            ]
        },
        {
            "assetID": "urn:aaid:AS:UE1:23c30ee0-2e4d-46d6-87f2-087832fca718",
            "pageRanges": [
                {
                    "start": 2
                }
            ]
        }
    ]
}'
CopyCopied to your clipboard
1// Please refer our REST API docs for more information 
2// https://developer.adobe.com/document-services/docs/apis/#tag/Combine-PDF
3
4curl --location --request POST 'https://pdf-services.adobe.io/operation/combinepdf' \
5--header 'x-api-key: {{Placeholder for client_id}}' \
6--header 'Content-Type: application/json' \
7--header 'Authorization: Bearer {{Placeholder for token}}' \
8--data-raw '{
9    "assets": [
10        {
11            "assetID": "urn:aaid:AS:UE1:23c30ee0-2e4d-46d6-87f2-087832fca718",
12            "pageRanges": [
13                {
14                    "start": 1,
15                    "end": 1
16                }
17            ]
18        },
19        {
20            "assetID": "urn:aaid:AS:UE1:23c30ee0-2e4d-46d6-87f2-087832fca718",
21            "pageRanges": [
22                {
23                    "start": 4
24                }
25            ]
26        },
27        {
28            "assetID": "urn:aaid:AS:UE1:23c30ee0-2e4d-46d6-87f2-087832fca718",
29            "pageRanges": [
30                {
31                    "start": 1
32                }
33            ]
34        },
35        {
36            "assetID": "urn:aaid:AS:UE1:23c30ee0-2e4d-46d6-87f2-087832fca718",
37            "pageRanges": [
38                {
39                    "start": 2
40                }
41            ]
42        }
43    ]
44}'