> For the complete documentation index, see [llms.txt](https://docs.apryse.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.apryse.com/core/get-started/samples/pdfpagetest.md).

# PDF Page Manipulation - Merge, Copy, Delete, Rearrange - PDFPage

Sample code for using Apryse SDK to copy pages from one document to another, delete and rearrange pages, and use ImportPages() method for very efficient copy and merge operations.  Sample code provide

Sample code for using Apryse SDK to copy pages from one document to another, delete and rearrange pages, and use ImportPages() method for very efficient copy and merge operations. Sample code provided in Python, C++, C#, Java, Node.js (JavaScript), PHP, Ruby and VB.

Learn more about our [Server SDK](/core/get-started/get-started.md) and [PDF Editing & Manipulation Library](/core/page-manipulation/manipulation.md).

{% tabs %}
{% tab title="C#" %}
{% code lineNumbers="true" %}

```csharp
//
// Copyright (c) 2001-2024 by Apryse Software Inc. All Rights Reserved.
//

using System;
using System.IO;
using System.Collections;
using pdftron;
using pdftron.Common;
using pdftron.Filters;
using pdftron.SDF;
using pdftron.PDF;

namespace PDFPageTestCS
{
	/// <summary>
	/// Summary description for Class1.
	/// </summary>
	class Class1
	{
		private static pdftron.PDFNetLoader pdfNetLoader = pdftron.PDFNetLoader.Instance();
		static Class1() {}
		
		/// <summary>
		/// The main entry point for the application.
		/// </summary>
		[STAThread]
		static void Main(string[] args)
		{
			PDFNet.Initialize(PDFTronLicense.Key);

			// Relative path to the folder containing test files.
			string input_path =  "../../../../TestFiles/";
			string output_path = "../../../../TestFiles/Output/";
			
			// Sample 1 - Split a PDF document into multiple pages
			try
			{
				Console.WriteLine("_______________________________________________");
				Console.WriteLine("Sample 1 - Split a PDF document into multiple pages...");
				Console.WriteLine("Opening the input pdf...");

				using (PDFDoc in_doc = new PDFDoc(input_path + "newsletter.pdf"))
				{
					in_doc.InitSecurityHandler();

					int page_num = in_doc.GetPageCount();
					for (int i = 1; i <= page_num; ++i) 
					{
						using (PDFDoc new_doc = new PDFDoc()) 
						{
							new_doc.InsertPages(0, in_doc, i, i, PDFDoc.InsertFlag.e_none);
							new_doc.Save(output_path + "newsletter_split_page_" + i + ".pdf", SDFDoc.SaveOptions.e_remove_unused);
							Console.WriteLine("Done. Result saved in newsletter_split_page_" + i + ".pdf");
						}
					}
				}
			}
			catch (Exception e)
			{
				Console.WriteLine("Exception caught:\n{0}", e);
			}

			// Sample 2 - Merge several PDF documents into one
			try
			{
				Console.WriteLine("_______________________________________________");
				Console.WriteLine("Sample 2 - Merge several PDF documents into one...");

				using (PDFDoc new_doc = new PDFDoc()) 
				{
					new_doc.InitSecurityHandler();
					int page_num = 15;
					for (int i = 1; i <= page_num; ++i) 
					{
						Console.WriteLine("Opening newsletter_split_page_" + i + ".pdf");
						using (PDFDoc in_doc = new PDFDoc(output_path + "newsletter_split_page_" + i + ".pdf")) 
						{
							new_doc.InsertPages(i, in_doc, 1, in_doc.GetPageCount(), PDFDoc.InsertFlag.e_none);
						}
					}
					new_doc.Save(output_path + "newsletter_merge_pages.pdf", SDFDoc.SaveOptions.e_remove_unused);
				}
				Console.WriteLine("Done. Result saved in newsletter_merge_pages.pdf");
			}
			catch (Exception e)
			{
				Console.WriteLine("Exception caught:\n{0}", e);
			}


			// Sample 3 - Delete every second page
			try	
			{
				Console.WriteLine("_______________________________________________");
				Console.WriteLine("Sample 3 - Delete every second page...");
				Console.WriteLine("Opening the input pdf...");

				using (PDFDoc in_doc = new PDFDoc(input_path +  "newsletter.pdf"))
				{
					in_doc.InitSecurityHandler();

					int page_num = in_doc.GetPageCount();
					PageIterator itr;
					while (page_num>=1)
					{
						itr = in_doc.GetPageIterator(page_num);
						in_doc.PageRemove(itr);
						page_num -= 2;
					}		

					in_doc.Save(output_path +  "newsletter_page_remove.pdf", 0);
				}
				Console.WriteLine("Done. Result saved in newsletter_page_remove.pdf...");
			}
			catch(Exception e)
			{
				Console.WriteLine("Exception caught:\n{0}", e);
			}

			// Sample 4 - Inserts a page from one document at different
			// locations within another document                       
			try   
			{	 
				Console.WriteLine("_______________________________________________");
				Console.WriteLine("Sample 4 - Insert a page at different locations...");
				Console.WriteLine("Opening the input pdf...");

				using (PDFDoc in1_doc = new PDFDoc(input_path +  "newsletter.pdf"))
				using (PDFDoc in2_doc = new PDFDoc(input_path + "fish.pdf"))
				{
					in1_doc.InitSecurityHandler();
					in2_doc.InitSecurityHandler();

					Page src_page = in2_doc.GetPage(1);
					PageIterator dst_page = in1_doc.GetPageIterator(1);
					int page_num = 1;
					while (dst_page.HasNext()) {
						if (page_num++ % 3 == 0) {
							in1_doc.PageInsert(dst_page, src_page);
						}
						dst_page.Next();
					}

					in1_doc.Save(output_path +  "newsletter_page_insert.pdf", 0);
					Console.WriteLine("Done. Result saved in newsletter_page_insert.pdf...");
				}
			}
			catch(Exception e)
			{
				Console.WriteLine("Exception caught:\n{0}", e);
			}

			// Sample 5 - Replicate pages within a single document
			try	
			{
				Console.WriteLine("_______________________________________________");
				Console.WriteLine("Sample 5 - Replicate pages within a single document...");
				Console.WriteLine("Opening the input pdf...");
				using (PDFDoc doc = new PDFDoc(input_path +  "newsletter.pdf")) 
				{
					doc.InitSecurityHandler();

					// Replicate the cover page three times (copy page #1 and place it before the 
					// seventh page in the document page sequence)
					Page cover = doc.GetPage(1);
					PageIterator p7 = doc.GetPageIterator(7);
					doc.PageInsert(p7, cover);
					doc.PageInsert(p7, cover);
					doc.PageInsert(p7, cover);

					// Replicate the cover page two more times by placing it before and after
					// existing pages.
					doc.PagePushFront(cover);
					doc.PagePushBack(cover);

					doc.Save(output_path +  "newsletter_page_clone.pdf", 0);
					Console.WriteLine("Done. Result saved in newsletter_page_clone.pdf...");
				}
			}
			catch(Exception e)
			{
				Console.WriteLine("Exception caught:\n{0}", e);
			}

			// Sample 6 - Use ImportPages() in order to copy multiple pages at once    
			// in order to preserve shared resources between pages (e.g. images, fonts,
			// colorspaces, etc.)
			try	
			{    
				Console.WriteLine("_______________________________________________");
				Console.WriteLine("Sample 6 - Preserving shared resources using ImportPages...");
				Console.WriteLine("Opening the input pdf...");
				using (PDFDoc in_doc = new PDFDoc(input_path +  "newsletter.pdf")) 
				{
					in_doc.InitSecurityHandler();
					using (PDFDoc new_doc = new PDFDoc()) 
					{
						ArrayList copy_pages = new ArrayList(); 
						for (PageIterator itr = in_doc.GetPageIterator(); itr.HasNext(); itr.Next()) {
							copy_pages.Add(itr.Current());
						}

						ArrayList imported_pages = new_doc.ImportPages(copy_pages);
						for (int i=0; i!=imported_pages.Count; ++i) {
							new_doc.PagePushFront((Page)imported_pages[i]); // Order pages in reverse order. 
							// Use PagePushBack() if you would like to preserve the same order.
						}
					
						new_doc.Save(output_path +  "newsletter_import_pages.pdf", 0);
						Console.WriteLine("Done. Result saved in newsletter_import_pages.pdf...");
						Console.WriteLine();
						Console.WriteLine("Note that the output file size is less than half the size"); 
						Console.WriteLine("of the file produced using individual page copy operations");
						Console.WriteLine("between two documents");
					}
				}
			}
			catch(Exception e)
			{
				Console.WriteLine("Exception caught:\n{0}", e);
			}
			PDFNet.Terminate();
		}
	}
}
```

{% endcode %}
{% endtab %}

{% tab title="C++" %}
{% code lineNumbers="true" %}

```cpp
//---------------------------------------------------------------------------------------
// Copyright (c) 2001-2024 by Apryse Software Inc. All Rights Reserved.
// Consult legal.txt regarding legal and license information.
//---------------------------------------------------------------------------------------
#include <PDF/PDFNet.h>
#include <PDF/PDFDoc.h>
#include <PDF/PDFDocInfo.h>
#include <iostream>
#include "../../LicenseKey/CPP/LicenseKey.h"

using namespace std;

using namespace pdftron;
using namespace SDF;
using namespace PDF;
using namespace Filters;


int main(int argc, char *argv[])
{
	int ret = 0;
	PDFNet::Initialize(LicenseKey);

	// Relative path to the folder containing test files.
	string input_path =  "../../TestFiles/";
	string output_path = "../../TestFiles/Output/";

	// Sample 1 - Split a PDF document into multiple pages
	try
	{
		cout << "_______________________________________________" << endl;
		cout << "Sample 1 - Split a PDF document into multiple pages..." << endl;
		cout << "Opening the input pdf..." << endl;
		PDFDoc in_doc((input_path +  "newsletter.pdf").c_str());
		in_doc.InitSecurityHandler();

		int page_num = in_doc.GetPageCount();
		for (int i=1; i<=page_num; ++i)
		{
			PDFDoc new_doc;
			char fname[256];
			sprintf(fname, "newsletter_split_page_%d.pdf", i);
			string output_file(output_path + fname);
			new_doc.InsertPages(0, in_doc, i, i, PDFDoc::e_none);
			new_doc.Save(output_file, SDFDoc::e_remove_unused, 0);
			cout << "Done. Result saved in " << fname << endl;
		}
	}
	catch(Common::Exception& e)
	{
		cout << e << endl;
		ret = 1;
	}
	catch(...)
	{
		cout << "Unknown Exception" << endl;
		ret = 1;
	}

	// Sample 2 - Merge several PDF documents into one
	try
	{
		cout << "_______________________________________________" << endl;
		cout << "Sample 2 - Merge several PDF documents into one..." << endl;
		PDFDoc new_doc;
		new_doc.InitSecurityHandler();

		int page_num = 15;
		for (int i=1; i<=page_num; ++i)
		{
			char fname[256];
			sprintf(fname, "newsletter_split_page_%d.pdf", i);
			string input_file(output_path + fname);
			cout << "Opening " << fname << endl;
			PDFDoc in_doc(input_file);
			new_doc.InsertPages(i, in_doc, 1, in_doc.GetPageCount(), PDFDoc::e_none);
		}
		new_doc.Save(output_path + "newsletter_merge_pages.pdf", SDFDoc::e_remove_unused, 0);
		cout << "Done. Result saved in newsletter_merge_pages.pdf" << endl;
	}
	catch(Common::Exception& e)
	{
		cout << e << endl;
		ret = 1;
	}
	catch(...)
	{
		cout << "Unknown Exception" << endl;
		ret = 1;
	}


	// Sample 3 - Delete every second page
	try	
	{
		cout << "_______________________________________________" << endl;
		cout << "Sample 3 - Delete every second page..." << endl;
		cout << "Opening the input pdf..." << endl;
		PDFDoc in_doc((input_path +  "newsletter.pdf").c_str());
		in_doc.InitSecurityHandler();
		
		int page_num = in_doc.GetPageCount();
		while (page_num>=1)
		{
			PageIterator itr = in_doc.GetPageIterator(page_num);
			in_doc.PageRemove(itr);
			page_num -= 2;
		}		
		
		in_doc.Save((output_path +  "newsletter_page_remove.pdf").c_str(), 0, 0);
		cout << "Done. Result saved in newsletter_page_remove.pdf..." << endl;
	}
	catch(Common::Exception& e)
	{
		cout << e << endl;
		ret = 1;
	}
	catch(...)
	{
		cout << "Unknown Exception" << endl;
		ret = 1;
	}
	
	// Sample 4 - Inserts a page from one document at different 
	// locations within another document
	try
	{	 
		cout << "_______________________________________________" << endl;
		cout << "Sample 4 - Insert a page at different locations..." << endl;
		cout << "Opening the input pdf..." << endl;
		
		PDFDoc in1_doc((input_path +  "newsletter.pdf").c_str());
		in1_doc.InitSecurityHandler();

		PDFDoc in2_doc((input_path + "fish.pdf").c_str());
		in2_doc.InitSecurityHandler(); 
		
		PageIterator src_page = in2_doc.GetPageIterator();
		PageIterator dst_page = in1_doc.GetPageIterator();
		int page_num = 1;
		while (dst_page.HasNext()) {
			if (page_num++ % 3 == 0) {
				in1_doc.PageInsert(dst_page, src_page.Current());
			}
			dst_page.Next();
		}
		in1_doc.Save((output_path +  "newsletter_page_insert.pdf").c_str(), 0 , NULL);
		cout << "Done. Result saved in newsletter_page_insert.pdf..." << endl;
	}
	catch(Common::Exception& e)
	{
		cout << e << endl;
		ret = 1;
	}
	catch(...)
	{
		cout << "Unknown Exception" << endl;
		ret = 1;
	}

	// Sample 5 - Replicate pages within a single document
	try	
	{
		cout << "_______________________________________________" << endl;
		cout << "Sample 5 - Replicate pages within a single document..." << endl;
		cout << "Opening the input pdf..." << endl;
		PDFDoc doc((input_path +  "newsletter.pdf").c_str());
		doc.InitSecurityHandler();
		
		// Replicate the cover page three times (copy page #1 and place it before the 
		// seventh page in the document page sequence)
		Page cover = doc.GetPage(1);
		PageIterator p7 = doc.GetPageIterator(7);
		doc.PageInsert(p7, cover);
		doc.PageInsert(p7, cover);
		doc.PageInsert(p7, cover);
		
		// Replicate the cover page two more times by placing it before and after
		// existing pages.
		doc.PagePushFront(cover);
		doc.PagePushBack(cover);
		
		doc.Save((output_path +  "newsletter_page_clone.pdf").c_str(), 0, NULL);
		cout << "Done. Result saved in newsletter_page_clone.pdf..." << endl;
	}
	catch(Common::Exception& e)
	{
		cout << e << endl;
		ret = 1;
	}
	catch(...)
	{
		cout << "Unknown Exception" << endl;
		ret = 1;
	}
	
	// Sample 6 - Use ImportPages() in order to copy multiple pages at once 
	// in order to preserve shared resources between pages (e.g. images, fonts, 
	// colorspaces, etc.)
	try
	{
		cout << "_______________________________________________" << endl;
		cout << "Sample 6 - Preserving shared resources using ImportPages..." << endl;
		cout << "Opening the input pdf..." << endl;
		PDFDoc in_doc((input_path +  "newsletter.pdf").c_str());
		in_doc.InitSecurityHandler();

		PDFDoc new_doc;
		
		vector<Page> copy_pages; 
		for (PageIterator itr=in_doc.GetPageIterator(); itr.HasNext(); itr.Next())
		{
			copy_pages.push_back(itr.Current());
		}
		
		vector<Page> imported_pages = new_doc.ImportPages(copy_pages);
		vector<Page>::iterator i;
		for (i=imported_pages.begin(); i!=imported_pages.end(); ++i)
		{
			new_doc.PagePushFront(*i); // Order pages in reverse order. 
			// Use PagePushBack() if you would like to preserve the same order.
		}		
		
		new_doc.Save((output_path +  "newsletter_import_pages.pdf").c_str(), 0, NULL);
		cout << "Done. Result saved in newsletter_import_pages.pdf..." << endl << endl
			<<	"Note that the output file size is less than half the size" << endl 
			<< "of the file produced using individual page copy operations" << endl 
			<< "between two documents" << endl;
	}
	catch(Common::Exception& e)
	{
		cout << e << endl;
		ret = 1;
	}
	catch(...)
	{
		cout << "Unknown Exception" << endl;
		ret = 1;
	}

	PDFNet::Terminate();
	return ret;
}
```

{% endcode %}
{% endtab %}

{% tab title="Go" %}
{% code lineNumbers="true" %}

```go
//---------------------------------------------------------------------------------------
// Copyright (c) 2001-2021 by PDFTron Systems Inc. All Rights Reserved.
// Consult LICENSE.txt regarding license information.
//---------------------------------------------------------------------------------------

package main
import (
	"fmt"
	"strconv"
	. "pdftron"
)

import  "pdftron/Samples/LicenseKey/GO"

func main(){
	PDFNetInitialize(PDFTronLicense.Key)
    
    // Relative path to the folder containing the test files.
    inputPath := "../../TestFiles/"
    outputPath := "../../TestFiles/Output/"
    
	// Sample 1 - Split a PDF document into multiple pages    
    fmt.Println("_______________________________________________")
    fmt.Println("Sample 1 - Split a PDF document into multiple pages...")
    fmt.Println("Opening the input pdf...")
    inDoc := NewPDFDoc(inputPath + "newsletter.pdf")
    inDoc.InitSecurityHandler()
	
    pageNum := inDoc.GetPageCount()
	for i := 1; i <= pageNum; i++ {
		iStr := strconv.Itoa(i)
        newDoc := NewPDFDoc()
        newDoc.InsertPages(0, inDoc, i, i, PDFDocE_none)
        newDoc.Save(outputPath + "newsletter_split_page_" + iStr + ".pdf", uint(SDFDocE_remove_unused))
        fmt.Println("Done. Result saved in newsletter_split_page_" + iStr + ".pdf")
        newDoc.Close()
    }
    // Close the open document to free up document memory sooner than waiting for the
    // garbage collector    
    inDoc.Close()
    
    // Sample 2 - Merge several PDF documents into one    
    fmt.Println("_______________________________________________")
    fmt.Println("Sample 2 - Merge several PDF documents into one...")
    newDoc := NewPDFDoc()
    newDoc.InitSecurityHandler()
    
    pageNum = 15
    
	for i := 1; i <= pageNum; i ++ {
        fmt.Println("Opening newsletter_split_page_" + strconv.Itoa(i) + ".pdf")
        inDoc = NewPDFDoc(outputPath + "newsletter_split_page_" + strconv.Itoa(i) + ".pdf")
        newDoc.InsertPages(i, inDoc, 1, inDoc.GetPageCount(), PDFDocE_none)
        inDoc.Close()
    }  
    newDoc.Save(outputPath + "newsletter_merge_pages.pdf", uint(SDFDocE_remove_unused))
    fmt.Println("Done. Result saved in newsletter_merge_pages.pdf");
	
    // Close the open document to free up document memory sooner than waiting for the
    // garbage collector   
    inDoc.Close()
    
    // Sample 3 - Delete every second page    
    fmt.Println("_______________________________________________")
    fmt.Println("Sample 3 - Delete every second page...")
    fmt.Println("Opening the input pdf...")
    inDoc = NewPDFDoc(inputPath +  "newsletter.pdf")
    inDoc.InitSecurityHandler();
    pageNum = inDoc.GetPageCount()
    
	for pageNum >= 1 {
        itr := inDoc.GetPageIterator(uint(pageNum))
        inDoc.PageRemove(itr)
        pageNum = pageNum - 2
	}

    inDoc.Save(outputPath +  "newsletter_page_remove.pdf", uint(0))
    fmt.Println("Done. Result saved in newsletter_page_remove.pdf...")
    
    // Close the open document to free up document memory sooner than waiting for the
    // garbage collector
    inDoc.Close()
       
    // Sample 4 - Inserts a page from one document at different 
    // locations within another document
    fmt.Println("_______________________________________________")
    fmt.Println("Sample 4 - Insert a page at different locations...")
    fmt.Println("Opening the input pdf...")
    
    in1Doc := NewPDFDoc(inputPath +  "newsletter.pdf")
    in1Doc.InitSecurityHandler()
    in2Doc := NewPDFDoc(inputPath +  "fish.pdf")
    in2Doc.InitSecurityHandler()
    
    srcPage := in2Doc.GetPageIterator()
    dstPage := in1Doc.GetPageIterator()
    pageNum = 1
    for dstPage.HasNext(){
        if (pageNum % 3 == 0){
            in1Doc.PageInsert(dstPage, srcPage.Current())
		}
        pageNum = pageNum + 1
        dstPage.Next()
	}
    in1Doc.Save(outputPath +  "newsletter_page_insert.pdf", uint(0))
    fmt.Println("Done. Result saved in newsletter_page_insert.pdf...")
    
    // Close the open document to free up document memory sooner than waiting for the
    // garbage collector
    in1Doc.Close()
    in2Doc.Close()
    
    // Sample 5 - Replicate pages within a single document
    fmt.Println("_______________________________________________")
    fmt.Println("Sample 5 - Replicate pages within a single document...")
    fmt.Println("Opening the input pdf...")
    
    doc := NewPDFDoc(inputPath + "newsletter.pdf")
    doc.InitSecurityHandler()
    
    // Replicate the cover page three times (copy page //1 and place it before the 
    // seventh page in the document page sequence)
    cover := doc.GetPage(1)
    p7 := doc.GetPageIterator(uint(7))
    doc.PageInsert(p7, cover)
    doc.PageInsert(p7, cover)
    doc.PageInsert(p7, cover)
    
    // Replicate the cover page two more times by placing it before and after
    // existing pages.
    doc.PagePushFront(cover);
    doc.PagePushBack(cover)
    
    doc.Save(outputPath +  "newsletter_page_clone.pdf", uint(0))
    fmt.Println("Done. Result saved in newsletter_page_clone.pdf...")
    doc.Close()
    
    // Sample 6 - Use ImportPages() in order to copy multiple pages at once 
    // in order to preserve shared resources between pages (e.g. images, fonts, 
    // colorspaces, etc.)
    fmt.Println("_______________________________________________")
    fmt.Println("Sample 6 - Preserving shared resources using ImportPages...")
    fmt.Println("Opening the input pdf...")
    inDoc = NewPDFDoc(inputPath +  "newsletter.pdf")
    inDoc.InitSecurityHandler()
    newDoc = NewPDFDoc()
	copyPages := NewVectorPage()
    itr := inDoc.GetPageIterator()
    for itr.HasNext(){
        copyPages.Add(itr.Current())
        itr.Next()
    }

    importedPages := newDoc.ImportPages(copyPages)
	for i := 0; i < int(importedPages.Size()); i ++{
		newDoc.PagePushFront(importedPages.Get(i))
	}
    newDoc.Save(outputPath +  "newsletter_import_pages.pdf", uint(0))
    
    // Close the open document to free up document memory sooner than waiting for the
    // garbage collector
    inDoc.Close()
    newDoc.Close()
    
    PDFNetTerminate()
    fmt.Println("Done. Result saved in newsletter_import_pages.pdf...\n")
    fmt.Println("Note that the output file size is less than half the size")
    fmt.Println("of the file produced using individual page copy operations")
    fmt.Println("between two documents")
}
```

{% endcode %}
{% endtab %}

{% tab title="Java" %}
{% code lineNumbers="true" %}

```java
//---------------------------------------------------------------------------------------
// Copyright (c) 2001-2024 by Apryse Software Inc. All Rights Reserved.
// Consult legal.txt regarding legal and license information.
//---------------------------------------------------------------------------------------

import com.pdftron.pdf.*;
import com.pdftron.sdf.*;
import com.pdftron.common.PDFNetException;

public class PDFPageTest {

    public static void main(String[] args) {
        PDFNet.initialize(PDFTronLicense.Key());

        // Relative path to the folder containing test files.
        String input_path = "../../TestFiles/";
        String output_path = "../../TestFiles/Output/";

        // Sample 1 - Split a PDF document into multiple pages
        System.out.println("_______________________________________________");
        System.out.println("Sample 1 - Split a PDF document into multiple pages...");
        System.out.println("Opening the input pdf...");
        try (PDFDoc in_doc = new PDFDoc(input_path + "newsletter.pdf")) {
            in_doc.initSecurityHandler();

            int page_num = in_doc.getPageCount();
            for (int i = 1; i <= page_num; ++i) {
                try (PDFDoc new_doc = new PDFDoc()) {
                    new_doc.insertPages(0, in_doc, i, i, PDFDoc.InsertBookmarkMode.NONE, null);
                    String fname = "newsletter_split_page_" + i + ".pdf";
                    new_doc.save(output_path + fname, SDFDoc.SaveMode.REMOVE_UNUSED, null);
                    // output PDF new_doc
                    System.out.println("Done. Result saved in newsletter_split_page_" + i + ".pdf");
                }
            }
        } catch (Exception e2) {
            System.out.println(e2);
        }

        // Sample 2 - Merge several PDF documents into one
        System.out.println("_______________________________________________");
        System.out.println("Sample 2 - Merge several PDF documents into one...");
        try (PDFDoc new_doc = new PDFDoc()) {
            new_doc.initSecurityHandler();

            int page_num = 15;
            for (int i = 1; i <= page_num; ++i) {
                System.out.println("Opening newsletter_split_page_" + i + ".pdf");
                String fname = "newsletter_split_page_" + i + ".pdf";
                try (PDFDoc in_doc = new PDFDoc(output_path + fname)) {
                    new_doc.insertPages(i, in_doc, 1, in_doc.getPageCount(), PDFDoc.InsertBookmarkMode.NONE, null);
                }
            }
            new_doc.save(output_path + "newsletter_merge_pages.pdf", SDFDoc.SaveMode.REMOVE_UNUSED, null);
            System.out.println("Done. Result saved in newsletter_merge_pages.pdf");
        } catch (Exception e2) {
            System.out.println(e2);
        }

        // Sample 3 - Delete every second page
        System.out.println("_______________________________________________");
        System.out.println("Sample 3 - Delete every second page...");
        System.out.println("Opening the input pdf...");
        try (PDFDoc in_doc = new PDFDoc(input_path + "newsletter.pdf")) {
            in_doc.initSecurityHandler();

            int page_num = in_doc.getPageCount();
            while (page_num >= 1) {
                PageIterator itr = in_doc.getPageIterator(page_num);
                in_doc.pageRemove(itr);
                page_num -= 2;
            }

            in_doc.save(output_path + "newsletter_page_remove.pdf", SDFDoc.SaveMode.NO_FLAGS, null);
            System.out.println("Done. Result saved in newsletter_page_remove.pdf...");

        } catch (Exception e2) {
            System.out.println(e2);
        }

        // Sample 4 - Inserts a page from one document at different
        // locations within another document
        System.out.println("_______________________________________________");
        System.out.println("Sample 4 - Insert a page at different locations...");
        System.out.println("Opening the input pdf...");
        try (PDFDoc in1_doc = new PDFDoc((input_path + "newsletter.pdf"))) {
            in1_doc.initSecurityHandler();
            try (PDFDoc in2_doc = new PDFDoc((input_path + "fish.pdf"))) {
                in2_doc.initSecurityHandler();

                PageIterator src_page_itr = in2_doc.getPageIterator();
                Page src_page = src_page_itr.next();
                PageIterator dst_page_itr = in1_doc.getPageIterator();
                int page_num = 1;
                while (dst_page_itr.hasNext()) {
                  if (page_num++ % 3 == 0) {
                    in1_doc.pageInsert(dst_page_itr, src_page);
                }
                dst_page_itr.next();
               }

               in1_doc.save(output_path + "newsletter_page_insert.pdf", SDFDoc.SaveMode.NO_FLAGS, null);
               // output PDF in1_doc
               System.out.println("Done. Result saved in newsletter_page_insert.pdf...");
            }
        } catch (Exception e) {
              System.out.println(e);
        }

        // Sample 5 - Replicate pages within a single document
        System.out.println("_______________________________________________");
        System.out.println("Sample 5 - Replicate pages within a single document...");
        System.out.println("Opening the input pdf...");
        try (PDFDoc doc = new PDFDoc((input_path + "newsletter.pdf"))) {
            doc.initSecurityHandler();

            // Replicate the cover page three times (copy page #1 and place it before the
            // seventh page in the document page sequence)
            Page cover = doc.getPage(1);
            PageIterator p7 = doc.getPageIterator(7);
            doc.pageInsert(p7, cover);
            doc.pageInsert(p7, cover);
            doc.pageInsert(p7, cover);

            // Replicate the cover page two more times by placing it before and after
            // existing pages.
            doc.pagePushFront(cover);
            doc.pagePushBack(cover);

            doc.save(output_path + "newsletter_page_clone.pdf", SDFDoc.SaveMode.NO_FLAGS, null);
            System.out.println("Done. Result saved in newsletter_page_clone.pdf...");
            
        } catch (Exception e2) {
            System.out.println(e2);
        }

        // Sample 6 - Use ImportPages() in order to copy multiple pages at once
        // in order to preserve shared resources between pages (e.g. images, fonts,
        // colorspaces, etc.)
        System.out.println("_______________________________________________");
        System.out.println("Sample 6 - Preserving shared resources using ImportPages...");
        System.out.println("Opening the input pdf...");
        try (PDFDoc in_doc = new PDFDoc((input_path + "newsletter.pdf"))) {
            in_doc.initSecurityHandler();

            try (PDFDoc new_doc = new PDFDoc()) {

                Page[] copy_pages = new Page[in_doc.getPageCount()];
                int j = 0;
                for (PageIterator itr = in_doc.getPageIterator(); itr.hasNext(); j++) {
                    copy_pages[j] = itr.next();
                }

                Page[] imported_pages = new_doc.importPages(copy_pages);
                for (int i = 0; i < imported_pages.length; ++i) {
                    new_doc.pagePushFront(imported_pages[i]); // Order pages in reverse order.
                    // Use pushBackPage() if you would like to preserve the same order.
                }

                new_doc.save(output_path + "newsletter_import_pages.pdf", SDFDoc.SaveMode.NO_FLAGS, null);

                System.out.println("Done. Result saved in newsletter_import_pages.pdf...");
                System.out.println();
                System.out.println("Note that the output file size is less than half the size");
                System.out.println("of the file produced using individual page copy operations");
                System.out.println("between two documents");
            }
        } catch (Exception e1) {
            System.out.println(e1);
        }

        PDFNet.terminate();
    }
}
```

{% endcode %}
{% endtab %}

{% tab title="JavaScript" %}
{% code lineNumbers="true" %}

```js
//---------------------------------------------------------------------------------------
// Copyright (c) 2001-2024 by Apryse Software Inc. All Rights Reserved.
// Consult legal.txt regarding legal and license information.
//---------------------------------------------------------------------------------------

const { PDFNet } = require('@pdftron/pdfnet-node');
const PDFTronLicense = require('../LicenseKey/LicenseKey');

((exports) => {

  exports.runPDFPageTest = () => {

    const main = async () => {
      // Relative path to the folder containing test files.
      const inputPath = '../TestFiles/';
      const outputPath = inputPath + 'Output/';

      // Sample 1 - Split a PDF document into multiple pages
      try {
        console.log('_______________________________________________');
        console.log('Sample 1 - Split a PDF document into multiple pages...');
        console.log('Opening the input pdf...');
        const inDoc = await PDFNet.PDFDoc.createFromFilePath(inputPath + 'newsletter.pdf');
        inDoc.initSecurityHandler();

        const pageCount = await inDoc.getPageCount();
        for (let i = 1; i <= pageCount; ++i) {
          const newDoc = await PDFNet.PDFDoc.create();
          const filename = 'newsletter_split_page_' + i + '.pdf';
          newDoc.insertPages(0, inDoc, i, i, PDFNet.PDFDoc.InsertFlag.e_none);
          await newDoc.save(outputPath + filename, PDFNet.SDFDoc.SaveOptions.e_remove_unused);
          console.log('Done. Result saved in ' + filename);
        }
      } catch (err) {
        // console.log(err);
        console.log(err.stack);
      }

      // Sample 2 - Merge several PDF documents into one
      try {
        console.log('_______________________________________________');
        console.log('Sample 2 - Merge several PDF documents into one...');

        // start stack-based deallocation with startDeallocateStack. Later on when endDeallocateStack is called,
        // all objects in memory that were initialized since the most recent startDeallocateStack call will be
        // cleaned up. Doing this makes sure that memory growth does not get too high.
        await PDFNet.startDeallocateStack();
        const newDoc = await PDFNet.PDFDoc.create();
        newDoc.initSecurityHandler();

        const pageNum = 15
        for (let i = 1; i <= pageNum; ++i) {
          const fname = 'newsletter_split_page_' + i + '.pdf';
          console.log('Opening ' + fname);
          const currDoc = await PDFNet.PDFDoc.createFromFilePath(outputPath + fname);
          const currDocPageCount = await currDoc.getPageCount();
          newDoc.insertPages(i, currDoc, 1, currDocPageCount, PDFNet.PDFDoc.InsertFlag.e_none);
        }
        await newDoc.save(outputPath + 'newsletter_merge_pages.pdf', PDFNet.SDFDoc.SaveOptions.e_remove_unused);
        console.log('Done. Result saved in newsletter_merge_pages.pdf');
        await PDFNet.endDeallocateStack();
      } catch (err) {
        // console.log(err);
        console.log(err.stack);
        ret = 1;
      }

      // Sample 3 - Delete every second page
      try {
        console.log('_______________________________________________');
        console.log('Sample 3 - Delete every second page...');
        console.log('Opening the input pdf...');
        await PDFNet.startDeallocateStack();
        const inDoc = await PDFNet.PDFDoc.createFromFilePath(inputPath + 'newsletter.pdf');
        inDoc.initSecurityHandler();

        let pageNum = await inDoc.getPageCount();

        while (pageNum >= 1) {
          const itr = await inDoc.getPageIterator(pageNum);
          inDoc.pageRemove(itr);
          pageNum -= 2;
        }

        await inDoc.save(outputPath + 'newsletter_page_remove.pdf', 0);
        console.log('Done. Result saved in newsletter_page_remove.pdf...');
        await PDFNet.endDeallocateStack();
      } catch (err) {
        console.log(err);
        ret = 1;
      }

      // Sample 4 - Inserts a page from one document at different 
      // locations within another document
      try {
        console.log('_______________________________________________');
        console.log('Sample 4 - Insert a page at different locations...');
        console.log('Opening the input pdf...');
        await PDFNet.startDeallocateStack();
        const in1Doc = await PDFNet.PDFDoc.createFromFilePath(inputPath + 'newsletter.pdf');
        in1Doc.initSecurityHandler();

        const in2Doc = await PDFNet.PDFDoc.createFromFilePath(inputPath + 'fish.pdf');
        in2Doc.initSecurityHandler();

        const srcPage = await in2Doc.getPageIterator();
        const dstPage = await in1Doc.getPageIterator();
        let pageNum = 1;
        while (await dstPage.hasNext()) {
          if (pageNum++ % 3 === 0) {
            in1Doc.pageInsert(dstPage, await srcPage.current());
          }
          dstPage.next();
        }

        await in1Doc.save(outputPath + 'newsletter_page_insert.pdf', 0);
        console.log('Done. Result saved in newsletter_page_insert.pdf...');
        await PDFNet.endDeallocateStack();
      } catch (err) {
        console.log(err.stack);
        ret = 1;
      }

      // Sample 5 - Replicate pages within a single document
      try {
        console.log('_______________________________________________');
        console.log('Sample 5 - Replicate pages within a single document...');
        console.log('Opening the input pdf...');
        await PDFNet.startDeallocateStack();
        const doc = await PDFNet.PDFDoc.createFromFilePath(inputPath + 'newsletter.pdf');
        doc.initSecurityHandler();

        // Replicate the cover page three times (copy page #1 and place it before the
        // seventh page in the document page sequence)
        const cover = await doc.getPage(1);
        const p7 = await doc.getPageIterator(7);
        doc.pageInsert(p7, cover);
        doc.pageInsert(p7, cover);
        doc.pageInsert(p7, cover);
        // replicate cover page two more times by placing it before and after existing pages
        doc.pagePushFront(cover);
        doc.pagePushBack(cover);

        await doc.save(outputPath + 'newsletter_page_clone.pdf', 0);
        console.log('Done. Result saved in newsletter_page_clone.pdf...');
        await PDFNet.endDeallocateStack();
      } catch (err) {
        console.log(err.stack);
        ret = 1;
      }

      // Sample 6 - Use ImportPages() in order to copy multiple pages at once 
      // in order to preserve shared resources between pages (e.g. images, fonts, 
      // colorspaces, etc.)
      try {
        console.log('_______________________________________________');
        console.log('Sample 6 - Preserving shared resources using ImportPages...');
        console.log('Opening the input pdf...');
        const in_doc = await PDFNet.PDFDoc.createFromFilePath(inputPath + 'newsletter.pdf');
        in_doc.initSecurityHandler();

        const new_doc = await PDFNet.PDFDoc.create();

        const copy_pages = [];
        for (const itr = await in_doc.getPageIterator(); await itr.hasNext(); await itr.next()) {
          copy_pages.push(await itr.current());
        }

        const imported_pages = await new_doc.importPages(copy_pages);
        for (var i = 0; i < imported_pages.length; ++i) {
          new_doc.pagePushFront(imported_pages[i]); // Order pages in reverse order. 
          // Use PagePushBack() if you would like to preserve the same order.
        }

        await new_doc.save(outputPath + 'newsletter_import_pages.pdf', 0);
        console.log('Done. Result saved in newsletter_import_pages.pdf...\n');
        console.log('Note that the output file size is less than half the size\n'
         + 'of the file produced using individual page copy operations\n'
          + 'between two documents');
      } catch (err) {
        console.log(err.stack);
      }
    };

    PDFNet.runWithCleanup(main, PDFTronLicense.Key).catch(function (error) { console.log('Error: ' + JSON.stringify(error)); }).then(function () { return PDFNet.shutdown(); });
  };
  exports.runPDFPageTest();
})(exports);
// eslint-disable-next-line spaced-comment
//# sourceURL=PDFPageTest.js
```

{% endcode %}
{% endtab %}

{% tab title="PHP" %}
{% code lineNumbers="true" %}

```php
<?php
//---------------------------------------------------------------------------------------
// Copyright (c) 2001-2023 by Apryse Software Inc. All Rights Reserved.
// Consult LICENSE.txt regarding license information.
//---------------------------------------------------------------------------------------
if(file_exists("../../../PDFNetC/Lib/PDFNetPHP.php"))
include("../../../PDFNetC/Lib/PDFNetPHP.php");
include("../../LicenseKey/PHP/LicenseKey.php");

// Relative path to the folder containing the test files.
$input_path = getcwd()."/../../TestFiles/";
$output_path = $input_path."Output/";

	PDFNet::Initialize($LicenseKey);
	PDFNet::GetSystemFontList();    // Wait for fonts to be loaded if they haven't already. This is done because PHP can run into errors when shutting down if font loading is still in progress.

	// Sample 1 - Split a PDF document into multiple pages
	
	echo nl2br("_______________________________________________\n");
	echo nl2br("Sample 1 - Split a PDF document into multiple pages...\n");
	echo nl2br("Opening the input pdf...\n");
	$in_doc = new PDFDoc($input_path."newsletter.pdf");
	$in_doc->InitSecurityHandler();

	$page_num = $in_doc->GetPageCount();
	for ($i = 1; $i <= $page_num; ++$i)
	{	
		$new_doc = new PDFDoc();
		$new_doc->InsertPages(0, $in_doc, $i, $i, PDFDoc::e_none);
		$new_doc->Save($output_path."newsletter_split_page_".$i.".pdf", SDFDoc::e_remove_unused);
		echo nl2br("Done. Result saved in newsletter_split_page_".$i.".pdf\n");
		$new_doc->Close();
	}
	$in_doc->Close();

	// Sample 2 - Merge several PDF documents into one
	
	echo nl2br("_______________________________________________\n");
	echo nl2br("Sample 2 - Merge several PDF documents into one...\n");
	$new_doc = new PDFDoc();
	$new_doc->InitSecurityHandler();

	$page_num = 15;
	for ($i = 1; $i <= $page_num; ++$i)
	{	
		echo nl2br("Opening newsletter_split_page_".$i.".pdf\n");
		$in_doc = new PDFDoc($output_path."newsletter_split_page_".$i.".pdf");
		$new_doc->InsertPages($i, $in_doc, 1, $in_doc->GetPageCount(), PDFDoc::e_none);
		$in_doc->Close();
	}
	$new_doc->Save($output_path."newsletter_merge_pages.pdf", SDFDoc::e_remove_unused);
	echo nl2br("Done. Result saved in newsletter_merge_pages.pdf\n");
	$in_doc->Close();

	// Sample 3 - Delete every second page
	
	echo nl2br("_______________________________________________\n");
	echo nl2br("Sample 3 - Delete every second page...\n");
	echo nl2br("Opening the input pdf...\n");
	$in_doc = new PDFDoc($input_path."newsletter.pdf");
	$in_doc->InitSecurityHandler();
		
	$page_num = $in_doc->GetPageCount();
	while ($page_num>=1)
	{
		$itr = $in_doc->GetPageIterator($page_num);
		$in_doc->PageRemove($itr);
		$page_num -= 2;
	}		
		
	$in_doc->Save($output_path."newsletter_page_remove.pdf", 0);
	echo nl2br("Done. Result saved in newsletter_page_remove.pdf...\n");

	//Close the open document to free up document memory sooner than waiting for the
	//garbage collector
	$in_doc->Close();

	// Sample 4 - Inserts a page from one document at different 
	// locations within another document
		 
	echo nl2br("_______________________________________________\n");
	echo nl2br("Sample 4 - Insert a page at different locations...\n");
	echo nl2br("Opening the input pdf...\n");
		
	$in1_doc = new PDFDoc($input_path."newsletter.pdf");
	$in1_doc->InitSecurityHandler();

	$in2_doc = new PDFDoc($input_path."fish.pdf");
	$in2_doc->InitSecurityHandler(); 
		
	$src_page = $in2_doc->GetPageIterator();
    $dst_page = $in1_doc->GetPageIterator();
	$page_num = 1;
    while ($dst_page->HasNext()) {
        if ($page_num++ % 3 == 0) {
            $in1_doc->PageInsert($dst_page, $src_page->Current());
        }
        $dst_page->Next();
    }
	
	$in1_doc->Save($output_path."newsletter_page_insert.pdf", 0);
	echo nl2br("Done. Result saved in newsletter_page_insert.pdf...\n");

	//Close the open document to free up document memory sooner than waiting for the
	//garbage collector
	$in1_doc->Close();
	$in2_doc->Close();

	// Sample 5 - Replicate pages within a single document
	
	echo nl2br("_______________________________________________\n");
	echo nl2br("Sample 5 - Replicate pages within a single document...\n");
	echo nl2br("Opening the input pdf...\n");
	$doc = new PDFDoc($input_path."newsletter.pdf");
	$doc->InitSecurityHandler();
		
	// Replicate the cover page three times (copy page #1 and place it before the 
	// seventh page in the document page sequence)
	$cover = $doc->GetPage(1);
	$p7 = $doc->GetPageIterator(7);
	$doc->PageInsert($p7, $cover);
	$doc->PageInsert($p7, $cover);
	$doc->PageInsert($p7, $cover);
		
	// Replicate the cover page two more times by placing it before and after
	// existing pages.
	$doc->PagePushFront($cover);
	$doc->PagePushBack($cover);
		
	$doc->Save($output_path."newsletter_page_clone.pdf", 0);
	echo nl2br("Done. Result saved in newsletter_page_clone.pdf...\n");
	$doc->Close();

	// Sample 6 - Use ImportPages() in order to copy multiple pages at once 
	// in order to preserve shared resources between pages (e.g. images, fonts, 
	// colorspaces, etc.)
	
	echo nl2br("_______________________________________________\n");
	echo nl2br("Sample 6 - Preserving shared resources using ImportPages...\n");
	echo nl2br("Opening the input pdf...\n");
	$in_doc = new PDFDoc($input_path."newsletter.pdf");
	$in_doc->InitSecurityHandler();

	$new_doc = new PDFDoc();
	
	$copy_pages = new VectorPage(); 
	for ($itr=$in_doc->GetPageIterator(); $itr->HasNext(); $itr->Next())
	{
		$copy_pages->push($itr->Current());
	}
		
	$imported_pages = $new_doc->ImportPages($copy_pages);
	for ($i=0; $i<$imported_pages->size(); ++$i)
	{
		$new_doc->PagePushFront($imported_pages->get($i)); // Order pages in reverse order. 
		// Use PagePushBack() if you would like to preserve the same order.
	}		
		
	$new_doc->Save($output_path."newsletter_import_pages.pdf", 0);
	PDFNet::Terminate();
	echo nl2br("Done. Result saved in newsletter_import_pages.pdf...\n\n"
		."Note that the output file size is less than half the size\n" 
		."of the file produced using individual page copy operations\n" 
		."between two documents\n");
?>
```

{% endcode %}
{% endtab %}

{% tab title="Python" %}
{% code lineNumbers="true" %}

```python
#---------------------------------------------------------------------------------------
# Copyright (c) 2001-2023 by Apryse Software Inc. All Rights Reserved.
# Consult LICENSE.txt regarding license information.
#---------------------------------------------------------------------------------------

import site
site.addsitedir("../../../PDFNetC/Lib")
import sys
from PDFNetPython import *

sys.path.append("../../LicenseKey/PYTHON")
from LicenseKey import *

def main():
    PDFNet.Initialize(LicenseKey)
    
    # Relative path to the folder containing the test files.
    input_path = "../../TestFiles/"
    output_path = "../../TestFiles/Output/"
    
	# Sample 1 - Split a PDF document into multiple pages    
    print("_______________________________________________")
    print("Sample 1 - Split a PDF document into multiple pages...")
    print("Opening the input pdf...")
    in_doc=PDFDoc(input_path + "newsletter.pdf")
    in_doc.InitSecurityHandler()
	
    page_num = in_doc.GetPageCount()
    i = 1
    while i<=page_num:
        new_doc=PDFDoc()
        new_doc.InsertPages(0, in_doc, i, i, PDFDoc.e_none)
        new_doc.Save(output_path + "newsletter_split_page_" + str(i) + ".pdf", SDFDoc.e_remove_unused)
        print("Done. Result saved in newsletter_split_page_" + str(i) + ".pdf")
        new_doc.Close()
        i = i + 1
    
    # Close the open document to free up document memory sooner than waiting for the
    # garbage collector    
    in_doc.Close()
    
    # Sample 2 - Merge several PDF documents into one    
    print("_______________________________________________")
    print("Sample 2 - Merge several PDF documents into one...")
    new_doc=PDFDoc()
    new_doc.InitSecurityHandler()
    
    page_num = 15
    i = 1
    while i <= page_num:
        print("Opening newsletter_split_page_" + str(i) + ".pdf")
        in_doc=PDFDoc(output_path + "newsletter_split_page_" + str(i) + ".pdf")
        new_doc.InsertPages(i, in_doc, 1, in_doc.GetPageCount(), PDFDoc.e_none)
        in_doc.Close()
        i = i + 1
        
    new_doc.Save(output_path + "newsletter_merge_pages.pdf", SDFDoc.e_remove_unused)
    print("Done. Result saved in newsletter_merge_pages.pdf");
	
    # Close the open document to free up document memory sooner than waiting for the
    # garbage collector   
    in_doc.Close()
    
    # Sample 3 - Delete every second page    
    print("_______________________________________________")
    print("Sample 3 - Delete every second page...")
    print("Opening the input pdf...")
    in_doc = PDFDoc(input_path +  "newsletter.pdf")
    in_doc.InitSecurityHandler();
    page_num = in_doc.GetPageCount()
    
    while page_num >= 1:
        itr = in_doc.GetPageIterator(page_num)
        in_doc.PageRemove(itr)
        page_num = page_num - 2

    in_doc.Save(output_path +  "newsletter_page_remove.pdf", 0)
    print("Done. Result saved in newsletter_page_remove.pdf...")
    
    # Close the open document to free up document memory sooner than waiting for the
    # garbage collector
    in_doc.Close()
       
    # Sample 4 - Inserts a page from one document at different 
    # locations within another document
    print("_______________________________________________")
    print("Sample 4 - Insert a page at different locations...")
    print("Opening the input pdf...")
    
    in1_doc = PDFDoc(input_path +  "newsletter.pdf")
    in1_doc.InitSecurityHandler()
    in2_doc = PDFDoc(input_path +  "fish.pdf")
    in2_doc.InitSecurityHandler()
    
    src_page = in2_doc.GetPageIterator()
    dst_page = in1_doc.GetPageIterator()
    page_num = 1
    while dst_page.HasNext():
        if page_num % 3 == 0:
            in1_doc.PageInsert(dst_page, src_page.Current())
        page_num = page_num + 1
        dst_page.Next()
    in1_doc.Save(output_path +  "newsletter_page_insert.pdf", 0)
    print("Done. Result saved in newsletter_page_insert.pdf...")
    
    # Close the open document to free up document memory sooner than waiting for the
    # garbage collector
    in1_doc.Close()
    in2_doc.Close()
    
    # Sample 5 - Replicate pages within a single document
    print("_______________________________________________")
    print("Sample 5 - Replicate pages within a single document...")
    print("Opening the input pdf...")
    
    doc = PDFDoc(input_path + "newsletter.pdf")
    doc.InitSecurityHandler()
    
    # Replicate the cover page three times (copy page #1 and place it before the 
    # seventh page in the document page sequence)
    cover = doc.GetPage(1)
    p7 = doc.GetPageIterator(7)
    doc.PageInsert(p7, cover)
    doc.PageInsert(p7, cover)
    doc.PageInsert(p7, cover)
    
    # Replicate the cover page two more times by placing it before and after
    # existing pages.
    doc.PagePushFront(cover);
    doc.PagePushBack(cover)
    
    doc.Save(output_path +  "newsletter_page_clone.pdf", 0)
    print("Done. Result saved in newsletter_page_clone.pdf...")
    doc.Close()
    
    # Sample 6 - Use ImportPages() in order to copy multiple pages at once 
    # in order to preserve shared resources between pages (e.g. images, fonts, 
    # colorspaces, etc.)
    print("_______________________________________________")
    print("Sample 6 - Preserving shared resources using ImportPages...")
    print("Opening the input pdf...")
    in_doc = PDFDoc(input_path +  "newsletter.pdf")
    in_doc.InitSecurityHandler()
    new_doc = PDFDoc()
    copy_pages = VectorPage()
    itr = in_doc.GetPageIterator()
    while itr.HasNext():
        copy_pages.push_back(itr.Current())
        itr.Next()
        
    imported_pages = new_doc.ImportPages(copy_pages)
    i = iter(imported_pages)
    for x in i:
        new_doc.PagePushFront(x)    # Order pages in reverse order. 
        # Use PagePushBack() if you would like to preserve the same order.
    
    new_doc.Save(output_path +  "newsletter_import_pages.pdf", 0)
    
    # Close the open document to free up document memory sooner than waiting for the
    # garbage collector
    in_doc.Close()
    new_doc.Close()
    
    PDFNet.Terminate()

    print("Done. Result saved in newsletter_import_pages.pdf...\n")
    print("Note that the output file size is less than half the size")
    print("of the file produced using individual page copy operations")
    print("between two documents")
    
if __name__ == '__main__':
    main()
```

{% endcode %}
{% endtab %}

{% tab title="Ruby" %}
{% code lineNumbers="true" %}

```ruby
#---------------------------------------------------------------------------------------
# Copyright (c) 2001-2023 by Apryse Software Inc. All Rights Reserved.
# Consult LICENSE.txt regarding license information.
#---------------------------------------------------------------------------------------

require '../../../PDFNetC/Lib/PDFNetRuby'
include PDFNetRuby
require '../../LicenseKey/RUBY/LicenseKey'

$stdout.sync = true

	PDFNet.Initialize(PDFTronLicense.Key)
	
	# Relative path to the folder containing the test files.
	input_path = "../../TestFiles/"
	output_path = "../../TestFiles/Output/"

	# Sample 1 - Split a PDF document into multiple pages
	
	puts "_______________________________________________"
	puts "Sample 1 - Split a PDF document into multiple pages..."
	puts "Opening the input pdf..."
	in_doc = PDFDoc.new(input_path + "newsletter.pdf")
	in_doc.InitSecurityHandler
	
	page_num = in_doc.GetPageCount
	i = 1
	while i <= page_num do
		new_doc = PDFDoc.new
		new_doc.InsertPages(0, in_doc, i, i, PDFDoc::E_none)
		new_doc.Save(output_path + "newsletter_split_page_" + i.to_s + ".pdf", SDFDoc::E_remove_unused)
		puts "Done. Result saved in newsletter_split_page_" + i.to_s + ".pdf"
		new_doc.Close
		i = i + 1
	end
		
	# Close the open document to free up document memory sooner than waiting for the
	# garbage collector
	in_doc.Close

	# Sample 2 - Merge several PDF documents into one
	
	puts "_______________________________________________"
	puts "Sample 2 - Merge several PDF documents into one..."
	new_doc = PDFDoc.new
	new_doc.InitSecurityHandler
	
	page_num = 15
	i = 1
	while i <= page_num do
		puts "Opening newsletter_split_page_" + i.to_s + ".pdf"
		in_doc = PDFDoc.new(output_path + "newsletter_split_page_" + i.to_s + ".pdf")
		new_doc.InsertPages(i, in_doc, 1, in_doc.GetPageCount, PDFDoc::E_none)
		in_doc.Close
		i = i + 1
	end
		
	new_doc.Save(output_path + "newsletter_merge_pages.pdf", SDFDoc::E_remove_unused)
	puts "Done. Result saved in newsletter_merge_pages.pdf"

	# Close the open document to free up document memory sooner than waiting for the
	# garbage collector
	in_doc.Close
	
	# Sample 3 - Delete every second page
	
	puts "_______________________________________________"
	puts "Sample 3 - Delete every second page..."
	puts "Opening the input pdf..."
	in_doc = PDFDoc.new(input_path + "newsletter.pdf")
	in_doc.InitSecurityHandler
	page_num = in_doc.GetPageCount
	
	while page_num >= 1 do
		itr = in_doc.GetPageIterator(page_num)
		in_doc.PageRemove(itr)
		page_num = page_num - 2
	end

	in_doc.Save(output_path +  "newsletter_page_remove.pdf", 0)
	puts "Done. Result saved in newsletter_page_remove.pdf..."
	
	# Close the open document to free up document memory sooner than waiting for the
	# garbage collector
	in_doc.Close
	
	# Sample 4 - Inserts a page from one document at different 
	# locations within another document
	puts "_______________________________________________"
	puts "Sample 4 - Insert a page at different locations..."
	puts "Opening the input pdf..."
	
	in1_doc = PDFDoc.new(input_path +  "newsletter.pdf")
	in1_doc.InitSecurityHandler
	in2_doc = PDFDoc.new(input_path +  "fish.pdf")
	in2_doc.InitSecurityHandler
	
	src_page = in2_doc.GetPageIterator
	dst_page = in1_doc.GetPageIterator
	page_num = 1
    while dst_page.HasNext
        if page_num % 3 == 0
            in1_doc.PageInsert(dst_page, src_page.Current)
        end
        page_num = page_num + 1
        dst_page.Next
    end
	in1_doc.Save(output_path +  "newsletter_page_insert.pdf", 0)
	puts "Done. Result saved in newsletter_page_insert.pdf..."
	
	# Close the open document to free up document memory sooner than waiting for the
	# garbage collector
	in1_doc.Close
	in2_doc.Close
	
	# Sample 5 - Replicate pages within a single document
	puts "_______________________________________________"
	puts "Sample 5 - Replicate pages within a single document..."
	puts "Opening the input pdf..."
	
	doc = PDFDoc.new(input_path + "newsletter.pdf")
	doc.InitSecurityHandler
	
	# Replicate the cover page three times (copy page #1 and place it before the 
	# seventh page in the document page sequence)
	cover = doc.GetPage(1)
	p7 = doc.GetPageIterator(7)
	doc.PageInsert(p7, cover)
	doc.PageInsert(p7, cover)
	doc.PageInsert(p7, cover)
	
	# Replicate the cover page two more times by placing it before and after
	# existing pages.
	doc.PagePushFront(cover);
	doc.PagePushBack(cover)
	
	doc.Save(output_path +  "newsletter_page_clone.pdf", 0)
	puts "Done. Result saved in newsletter_page_clone.pdf..."
	doc.Close
	
	# Sample 6 - Use ImportPages in order to copy multiple pages at once 
	# in order to preserve shared resources between pages (e.g. images, fonts, 
	# colorspaces, etc.)
	puts "_______________________________________________"
	puts "Sample 6 - Preserving shared resources using ImportPages..."
	puts "Opening the input pdf..."
	in_doc = PDFDoc.new(input_path +  "newsletter.pdf")
	in_doc.InitSecurityHandler
	new_doc = PDFDoc.new
	copy_pages = VectorPage.new
	itr = in_doc.GetPageIterator
	while itr.HasNext do
		copy_pages << itr.Current
		itr.Next
	end
		
	imported_pages = new_doc.ImportPages(copy_pages)
	for x in imported_pages
		new_doc.PagePushFront(x)	# Order pages in reverse order. 
		# Use PagePushBack if you would like to preserve the same order.
	end
	
	new_doc.Save(output_path +  "newsletter_import_pages.pdf", 0)
	
	# Close the open document to free up document memory sooner than waiting for the
	# garbage collector
	in_doc.Close
	new_doc.Close
	PDFNet.Terminate
	puts "Done. Result saved in newsletter_import_pages.pdf..."
	puts "\nNote that the output file size is less than half the size"
	puts "of the file produced using individual page copy operations"
	puts "between two documents"
```

{% endcode %}
{% endtab %}

{% tab title="VB" %}
{% code lineNumbers="true" %}

```vb
'
' Copyright (c) 2001-2024 by Apryse Software Inc. All Rights Reserved.
'

Imports System
Imports System.Collections

Imports pdftron
Imports pdftron.Common
Imports pdftron.Filters
Imports pdftron.SDF
Imports pdftron.PDF


Module PDFPageTestVB
	Dim pdfNetLoader As PDFNetLoader
	Sub New()
		pdfNetLoader = pdftron.PDFNetLoader.Instance()
	End Sub

	Sub Main()

		PDFNet.Initialize(PDFTronLicense.Key)

		' Relative path to the folder containing test files.
		Dim input_path As String = "../../../../TestFiles/"
		Dim output_path As String = "../../../../TestFiles/Output/"

		Try
			'---------------------------------------------------------------------------------
			' Sample 1 - Split a PDF document into multiple pages

			Console.WriteLine("_______________________________________________")
			Console.WriteLine("Sample 1 - Split a PDF document into multiple pages...")
			Console.WriteLine("Opening the input pdf...")

			Using in_doc As PDFDoc = New PDFDoc(input_path + "newsletter.pdf")
				in_doc.InitSecurityHandler()

				Dim page_num As Integer = in_doc.GetPageCount()
				Dim i As Integer

				For i = 1 To page_num
					Dim new_doc As PDFDoc = New PDFDoc()
					new_doc.InsertPages(0, in_doc, i, i, PDFDoc.InsertFlag.e_none)
					new_doc.Save(output_path + "newsletter_split_page_" + CStr(i) + ".pdf", SDFDoc.SaveOptions.e_remove_unused)
					Console.WriteLine("Done. Result saved in newsletter_split_page_" + CStr(i) + ".pdf")
					new_doc.Close()
				Next i
			End Using

			'---------------------------------------------------------------------------------
			' Sample 2 - Merge several PDF documents into one

			Console.WriteLine("_______________________________________________")
			Console.WriteLine("Sample 2 - Merge several PDF documents into one...")

			Using new1_doc As PDFDoc = New PDFDoc()
				new1_doc.InitSecurityHandler()

				Dim page_num1 As Integer = 15
				Dim i1 As Integer

				For i1 = 1 To page_num1
					Console.WriteLine("Opening newsletter_split_page_" + CStr(i1) + ".pdf")
					Dim in0_doc As PDFDoc = New PDFDoc(output_path + "newsletter_split_page_" + CStr(i1) + ".pdf")
					new1_doc.InsertPages(i1, in0_doc, 1, in0_doc.GetPageCount(), PDFDoc.InsertFlag.e_none)
					in0_doc.Close()
				Next i1

				new1_doc.Save(output_path + "newsletter_merge_pages.pdf", SDFDoc.SaveOptions.e_remove_unused)
				Console.WriteLine("Done. Result saved in newsletter_merge_pages.pdf")
			End Using

			'---------------------------------------------------------------------------------
			' Sample 3 - Delete every second page

			Console.WriteLine("_______________________________________________")
			Console.WriteLine("Sample 3 - Delete every second page...")
			Console.WriteLine("Opening the input pdf...")

			Using in1_doc As PDFDoc = New PDFDoc(input_path + "newsletter.pdf")
				in1_doc.InitSecurityHandler()

				Dim page_num2 As Integer = in1_doc.GetPageCount()
				Dim itr As PageIterator

				While page_num2 >= 1
					itr = in1_doc.GetPageIterator(page_num2)
					in1_doc.PageRemove(itr)
					page_num2 -= 2
				End While

				in1_doc.Save(output_path + "newsletter_page_remove.pdf", 0)
				Console.WriteLine("Done. Result saved in newsletter_page_remove.pdf...")
			End Using

			'---------------------------------------------------------------------------------
			' Sample 4 - Inserts a page from one document at different 
			' locations within another document
			Console.WriteLine("_______________________________________________")
			Console.WriteLine("Sample 4 - Insert a page at different locations...")
			Console.WriteLine("Opening the input pdf...")

			Using in2_doc As PDFDoc = New PDFDoc(input_path + "newsletter.pdf")
				in2_doc.InitSecurityHandler()

				Using in3_doc As PDFDoc = New PDFDoc(input_path + "fish.pdf")
					in3_doc.InitSecurityHandler()

					Dim src_page4 As Page = in3_doc.GetPage(1) ' Get the first page
					Dim dst_page4 As PageIterator = in2_doc.GetPageIterator(1)
					Dim page_num4 As Integer = 1
					While dst_page4.HasNext()
						If page_num4 Mod 3 = 0 Then
							in2_doc.PageInsert(dst_page4, src_page4)
						End If
						page_num4 = page_num4 + 1
						dst_page4.Next()
					End While

					in2_doc.Save(output_path + "newsletter_page_insert.pdf", 0)
					Console.WriteLine("Done. Result saved in newsletter_page_insert.pdf...")
				End Using
			End Using

			'---------------------------------------------------------------------------------
			' Sample 5 - Replicate pages within a single document

			Console.WriteLine("_______________________________________________")
			Console.WriteLine("Sample 5 - Replicate pages within a single document...")
			Console.WriteLine("Opening the input pdf...")
			Using doc5 As PDFDoc = New PDFDoc(input_path + "newsletter.pdf")
				doc5.InitSecurityHandler()

				' Replicate the cover page three times (copy page #1 and place it before the 
				' seventh page in the document page sequence)
				Dim cover As Page = doc5.GetPage(1)
				Dim p7 as PageIterator = doc5.GetPageIterator(7)
				doc5.PageInsert(p7, cover)
				doc5.PageInsert(p7, cover)
				doc5.PageInsert(p7, cover)

				' Replicate the cover page two more times by placing it before and after
				' existing pages.
				doc5.PagePushFront(cover)
				doc5.PagePushBack(cover)

				doc5.Save(output_path + "newsletter_page_clone.pdf", 0)
				Console.WriteLine("Done. Result saved in newsletter_page_clone.pdf...")
			End Using

			'---------------------------------------------------------------------------------
			' Sample 6 - Use ImportPages() in order to copy multiple pages at once 
			' in order to preserve shared resources between pages (e.g. images, fonts, 
			' colorspaces, etc.)
			Console.WriteLine("_______________________________________________")
			Console.WriteLine("Sample 6 - Preserving shared resources using ImportPages...")
			Console.WriteLine("Opening the input pdf...")
			Using in_doc6 As PDFDoc = New PDFDoc(input_path + "newsletter.pdf")
				in_doc6.InitSecurityHandler()

				Using new_doc6 As PDFDoc = New PDFDoc
					Dim copy_pages As ArrayList = New ArrayList
					Dim itr6 As PageIterator = in_doc6.GetPageIterator()
					While itr6.HasNext()
						copy_pages.Add(itr6.Current())
						itr6.Next()
					End While

					Dim imported_pages As ArrayList = new_doc6.ImportPages(copy_pages)
					Dim i6 As Integer
					For i6 = 0 To imported_pages.Count - 1
						new_doc6.PagePushFront(imported_pages(i6))	  ' Order pages in reverse order. 
						' Use PagePushBack() if you would like to preserve the same order.
					Next i6

					new_doc6.Save(output_path + "newsletter_import_pages.pdf", 0)
					Console.WriteLine("Done. Result saved in newsletter_import_pages.pdf...")
					Console.WriteLine()
					Console.WriteLine("Note that the output file size is less than half the size")
					Console.WriteLine("of the file produced using individual page copy operations")
					Console.WriteLine("between two documents")
				End Using
			End Using

		Catch ex As PDFNetException
			Console.WriteLine(ex.Message)
		Catch ex As Exception
			MsgBox(ex.Message)
		End Try
		PDFNet.Terminate()
	End Sub
End Module
```

{% endcode %}
{% endtab %}
{% endtabs %}


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.apryse.com/core/get-started/samples/pdfpagetest.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.