Full Working Example to Remove Annotation Objects from PDF with REST in Node.JS

This example demonstrates how to upload a PDF, delete all its annotations, and download the cleaned file using the GroupDocs.Annotation SDK.

const fs = require('fs');
const path = require('path');
const GroupDocsAnnotationCloud = require("@groupdocs/annotation-cloud");

// ==== Authentication =========================================================
const clientId = "YOUR_CLIENT_ID";
const clientSecret = "YOUR_CLIENT_SECRET";

const config = new GroupDocsAnnotationCloud.Configuration(clientId, clientSecret);
const annotationsApi = new GroupDocsAnnotationCloud.AnnotationsApi(config);
const storageApi = new GroupDocsAnnotationCloud.StorageApi(config);

// ==== Local & Remote file definitions =======================================
const localInputPath = path.resolve(__dirname, "input.pdf");
const localOutputPath = path.resolve(__dirname, "output.pdf");
const remoteFilePath = "input.pdf";

// ==== Main workflow ==========================================================
(async () => {
    // 1. Upload PDF to GroupDocs Cloud storage
    const fileBytes = fs.readFileSync(localInputPath);
    const uploadRequest = new GroupDocsAnnotationCloud.UploadFileRequest({
        path: remoteFilePath,
        file: fileBytes
    });
    await storageApi.uploadFile(uploadRequest);

    // 2. Build FileInfo object for the uploaded PDF
    const fileInfo = new GroupDocsAnnotationCloud.FileInfo({
        filePath: remoteFilePath
    });

    // 3. Retrieve all existing annotations
    const getAnnotationsRequest = new GroupDocsAnnotationCloud.GetAnnotationsRequest({
        fileInfo: fileInfo
    });
    const annotationsResult = await annotationsApi.getAnnotations(getAnnotationsRequest);
    const annotationIds = (annotationsResult.annotations || []).map(a => a.id);

    // 4. Delete all annotations (if any)
    if (annotationIds.length > 0) {
        const deleteRequest = new GroupDocsAnnotationCloud.DeleteAnnotationsRequest({
            fileInfo: fileInfo,
            annotationIds: annotationIds
        });
        await annotationsApi.deleteAnnotations(deleteRequest);
    }

    // 5. Download the cleaned PDF back to local storage
    const downloadRequest = new GroupDocsAnnotationCloud.DownloadFileRequest({
        path: remoteFilePath
    });
    const fileStream = await storageApi.downloadFile(downloadRequest);
    fs.writeFileSync(localOutputPath, fileStream);
    console.log(`All annotations removed. Clean file saved to ${localOutputPath}`);
})();

Note: This code example demonstrates the core functionality. Before using it in your project, make sure to update any file paths and configuration values to match your actual environment, verify that all required dependencies are properly installed, and test thoroughly in your development environment. If you encounter any issues, please refer to the official documentation or reach out to the support team for assistance.

Delete PDF Annotations via REST API Using cURL

Below are the cURL commands that perform the same annotation removal workflow through the GroupDocs.Annotation Cloud REST endpoints.

# 1. Obtain an access token
curl -X POST "https://api.groupdocs.cloud/v2.0/auth/token" \
     -H "Content-Type: application/json" \
     -d "{\"client_id\":\"YOUR_CLIENT_ID\",\"client_secret\":\"YOUR_CLIENT_SECRET\"}"

# 2. Upload the source PDF
curl -X PUT "https://api.groupdocs.cloud/v2.0/storage/file/input.pdf" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -H "Content-Type: application/pdf" \
     --data-binary "@input.pdf"

# 3. Retrieve annotation IDs
curl -X GET "https://api.groupdocs.cloud/v2.0/annotation/annotations?filePath=input.pdf" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

# 4. Delete all retrieved annotations
curl -X DELETE "https://api.groupdocs.cloud/v2.0/annotation/annotations?filePath=input.pdf" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -H "Content-Type: application/json" \
     -d "{\"annotationIds\":[\"id1\",\"id2\"]}"

# 5. Download the cleaned PDF
curl -X GET "https://api.groupdocs.cloud/v2.0/storage/file/input.pdf" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -o output.pdf

For a complete list of endpoints and parameters, see the official API documentation.

How Remove Annotation Objects from PDF with REST in Node.JS Works

1. Authentication Setup - The Configuration class is instantiated with your clientId and clientSecret, creating an authenticated context for all subsequent API calls.

   const config = new GroupDocsAnnotationCloud.Configuration(clientId, clientSecret);
   

2. File Upload - UploadFileRequest sends the local PDF bytes to GroupDocs Cloud storage. The storageApi.uploadFile method handles the transfer.

   const uploadRequest = new GroupDocsAnnotationCloud.UploadFileRequest({
       path: remoteFilePath,
       file: fileBytes
   });
   await storageApi.uploadFile(uploadRequest);
   

3. Retrieve Annotations - GetAnnotationsRequest builds a request object with a FileInfo reference. The annotationsApi.getAnnotations call returns a collection of annotation objects, from which IDs are extracted.

   const getAnnotationsRequest = new GroupDocsAnnotationCloud.GetAnnotationsRequest({
       fileInfo: fileInfo
   });
   const annotationsResult = await annotationsApi.getAnnotations(getAnnotationsRequest);
   

4. Delete Annotations - If any IDs exist, DeleteAnnotationsRequest is populated and passed to annotationsApi.deleteAnnotations, which permanently removes the annotations from the stored PDF.

   const deleteRequest = new GroupDocsAnnotationCloud.DeleteAnnotationsRequest({
       fileInfo: fileInfo,
       annotationIds: annotationIds
   });
   await annotationsApi.deleteAnnotations(deleteRequest);
   

5. Download Clean PDF - Finally, DownloadFileRequest fetches the updated file, and fs.writeFileSync writes it to the local filesystem.

   const downloadRequest = new GroupDocsAnnotationCloud.DownloadFileRequest({
       path: remoteFilePath
   });
   const fileStream = await storageApi.downloadFile(downloadRequest);
   fs.writeFileSync(localOutputPath, fileStream);
   

For detailed class and method definitions, refer to the API reference.

Installing and Configuring GroupDocs.Annotation Cloud SDK for Node.js

The SDK is distributed as an npm package. Install it with the command below and then require it in your project.

npm install groupdocs-annotation-cloud

You can also download the latest package directly from the GitHub releases page or the official download URL.

After installation, import the library and create a configuration object as shown in the code example:

const GroupDocsAnnotationCloud = require("@groupdocs/annotation-cloud");
const config = new GroupDocsAnnotationCloud.Configuration("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET");

Make sure your runtime environment meets the Node.js version requirements and that you have a valid GroupDocs account to obtain the client credentials.

Annotation Removal Options and Settings

The SDK exposes several parameters you can tune:

• clientId / clientSecret - Credentials for OAuth authentication. Set them in the Configuration constructor.
• fileInfo.filePath - The path of the PDF in GroupDocs Cloud storage. Adjust this if you store files in a different folder.
• annotationIds - An array of IDs returned by GetAnnotations. Supplying a subset allows selective deletion.

Additional settings such as request timeouts and proxy configuration are available in the SDK documentation; see the official documentation for the full list.

Best Practices for Removing PDF Annotations via REST

• Validate Annotation IDs - Always check that the IDs you intend to delete exist; attempting to delete non‑existent IDs can cause a 404 error.
• Use HTTPS - All API calls must be made over HTTPS to protect your credentials and document data.
• Handle Large Files with Chunked Uploads - For PDFs larger than 100 MB, prefer the multipart upload endpoint to avoid timeouts.
• Log API Responses - Store request IDs and responses for audit trails and easier troubleshooting.
• Reuse Access Tokens - Cache the OAuth token until it expires to reduce authentication overhead.

Common Questions

• How do I authenticate with GroupDocs.Annotation Cloud API?
  Obtain a client ID and secret from your GroupDocs account, then request an access token via the OAuth endpoint. See the official documentation for details.

• Can I delete specific annotations instead of all?
  Yes, provide the IDs of the annotations you want to remove in the DeleteAnnotationsRequest. The SDK returns the list of annotation IDs after a GetAnnotations call.

• How can I remove Annotation objects from PDF with REST in Node.JS?
  Use the GroupDocs.Annotation Cloud SDK for Node.js to call the DeleteAnnotations endpoint after retrieving annotation IDs. The full workflow is demonstrated in the code example and cURL section of this guide.

• What licensing is required for production use?
  A paid license is needed for production. You can acquire a temporary license from the temporary license page while evaluating.

Further Reading

• Extract or Remove Annotations from PDF using REST API in Node.js
• Strikethrough Text in a PDF with Node.js and REST API
• Remove Annotations from PDF using REST API in Python

Before You Start: Prerequisites and Installation

Before you begin, ensure you have the following:

• Node.js 14 or later installed on your development machine.
• An active GroupDocs Cloud account with client ID and client secret.
• Access to the PDF files you want to combine, stored in GroupDocs Cloud storage.

Install the SDK via npm and download the latest package:

npm install groupdocs-merger-cloud

You can also retrieve the SDK from the official release page: Download SDK. After installation, you are ready to start coding.

Step-by-Step Guide to Merge PDF in Node.JS

Step 1: Install SDK and Import Required Classes

First, import the classes you will need for merging PDFs.

const { MergeApi, MergeOptions, FileInfo, Configuration } = require("@groupdocs/merger-cloud");

This import gives you access to the core API, configuration objects, and file descriptors.

Step 2: Configure Your GroupDocs Credentials

Create a configuration object with your client credentials.

const config = new Configuration({
    clientId: "YOUR_CLIENT_ID",
    clientSecret: "YOUR_CLIENT_SECRET"
});

Providing the correct credentials lets the library authenticate your requests.

Step 3: Define the PDF Files to Merge

List the PDF documents you want to combine. This step prepares you to merge PDF in Node.JS efficiently.

const filesToMerge = [
    new FileInfo({ filePath: "input1.pdf" }),
    new FileInfo({ filePath: "input2.pdf" })
];

Each FileInfo points to a file stored in your GroupDocs Cloud storage.

Step 4: Set Merge Options

Configure the output location and attach the file list to the merge request.

const mergeOptions = new MergeOptions();
mergeOptions.fileInfos = filesToMerge;
mergeOptions.outputPath = "merged_output.pdf";

These settings control how you merge PDF in Node.JS and where the result will be saved.

Step 5: Execute the Merge Operation

Create the API instance, call the merge method, and handle the response.

const mergeApi = new MergeApi(config);

try {
    const result = await mergeApi.mergeDocuments(mergeOptions);
    console.log("Merge completed. Output file stored at:", result.path);
} catch (error) {
    console.error("Error during PDF merge:", error);
}

The async call returns the path of the merged document if the operation succeeds.

Full Implementation Example for Merging PDFs in Node.JS

The following code demonstrates the complete workflow from configuration to result handling.

const { MergeApi, MergeOptions, FileInfo, Configuration } = require("@groupdocs/merger-cloud");

// Configure the SDK (replace with your actual credentials)
const config = new Configuration({
    clientId: "YOUR_CLIENT_ID",
    clientSecret: "YOUR_CLIENT_SECRET"
});

async function mergePdfFiles() {
    // Initialize the Merge API
    const mergeApi = new MergeApi(config);

    // Define the PDF files to be merged (must exist in GroupDocs Cloud storage)
    const filesToMerge = [
        new FileInfo({ filePath: "input1.pdf" }),
        new FileInfo({ filePath: "input2.pdf" })
    ];

    // Set merge options
    const mergeOptions = new MergeOptions();
    mergeOptions.fileInfos = filesToMerge;
    mergeOptions.outputPath = "merged_output.pdf";

    try {
        // Perform the merge operation
        const result = await mergeApi.mergeDocuments(mergeOptions);
        console.log("Merge completed. Output file stored at:", result.path);
    } catch (error) {
        console.error("Error during PDF merge:", error);
    }
}

// Execute the merge
mergePdfFiles();

Note: This code example demonstrates the core functionality. Before using it in your project, make sure to update any file paths and configuration values to match your actual environment, verify that all required dependencies are properly installed, and test thoroughly in your development environment. If you encounter any issues, please refer to the official documentation or reach out to the support team for assistance.

Merging PDFs via REST API Using cURL

If you prefer a pure REST approach, the same operation can be performed with cURL commands.

First, obtain an access token:

curl -X POST "https://api.groupdocs.cloud/v2.0/oauth2/token" \
     -H "Content-Type: application/json" \
     -d '{"client_id":"YOUR_CLIENT_ID","client_secret":"YOUR_CLIENT_SECRET","grant_type":"client_credentials"}'

Upload the source PDFs to your storage (replace YOUR_ACCESS_TOKEN with the token from the previous step):

curl -X POST "https://api.groupdocs.cloud/v2.0/storage/file/upload?path=input1.pdf" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -F "file=@/local/path/input1.pdf"

Repeat the upload for input2.pdf. Then request the merge operation:

curl -X POST "https://api.groupdocs.cloud/v2.0/merger/merge" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{
           "fileInfos": [
               {"filePath":"input1.pdf"},
               {"filePath":"input2.pdf"}
           ],
           "outputPath":"merged_output.pdf"
         }'

Finally, download the merged file:

curl -X GET "https://api.groupdocs.cloud/v2.0/storage/file/download?path=merged_output.pdf" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -o merged_output.pdf

For a complete list of endpoints and parameters, see the API reference.

Configuring Merge Options

The SDK exposes several options that let you fine‑tune the merge process:

• outputPath - Destination path for the merged PDF. Adjust this to control where the result is stored.
• fileInfos - An array of FileInfo objects that define the source PDFs and their order.

You can also set additional properties such as pages to merge specific page ranges, or password for encrypted PDFs. Refer to the official documentation for the full list of configurable fields.

Performance Considerations for Merging PDFs

When merging large or many PDF files, keep these tips in mind:

• Use async/await to avoid blocking the event loop, especially for big documents.
• Batch uploads: upload source PDFs in parallel before invoking the merge to reduce overall latency.
• Streamed processing: for extremely large PDFs, consider storing intermediate results in cloud storage and merging them in smaller chunks.
• Encrypted PDFs: provide passwords in the FileInfo objects; processing encrypted files adds overhead, so merge them after decryption when possible.

Applying these practices helps you merge PDF in Node.JS efficiently while minimizing memory consumption.

Questions You Might Have

• How do I merge PDF files in Node.JS using GroupDocs?
  Use the GroupDocs.Merger Cloud SDK for Node.js to create a MergeApi instance, configure MergeOptions with your source PDFs, and call mergeDocuments. The full code example in this guide demonstrates the process.

• Can I merge encrypted PDF files in Node.JS?
  Yes, the SDK supports merging encrypted PDFs. Provide the correct passwords in the FileInfo objects before calling mergeDocuments. See the official documentation for details.

• What are the licensing options for GroupDocs.Merger?
  GroupDocs offers flexible pricing plans. For testing, you can request a temporary license to evaluate the library before purchasing a full subscription.

• Where can I find more examples and support?
  Additional samples are available on the GitHub repository. For help, visit the support forum.

Further Reading

• Split PDF into Multiple PDF in Node.JS
• Lock PDF Documents with Passwords using REST API in Node.js
• How to Merge PDF Files in C# using REST API

Add Image Watermark to PDF Documents in Java in 5 Steps

1. Initialize the API client: Create an ApiClient instance with your client ID and secret.

   ApiClient apiClient = new ApiClient("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET");
   WatermarkApi watermarkApi = new WatermarkApi(apiClient);
   

   This step connects your Java code to the GroupDocs.Watermark Cloud service. See the API reference for more details.

2. Specify the source PDF file: Build a FileInfo object that points to the PDF you want to watermark.

   FileInfo fileInfo = new FileInfo();
   fileInfo.setFilePath("input.pdf");
   

   The file must be uploaded to your GroupDocs storage before the request.

3. Configure the image watermark: Define the image path, opacity, scale factor, rotation and alignment.

   ImageWatermark imageWatermark = new ImageWatermark();
   imageWatermark.setImagePath("watermark.png");
   imageWatermark.setOpacity(0.5);
   imageWatermark.setScaleFactor(0.3);
   imageWatermark.setHorizontalAlignment(HorizontalAlignment.CENTER);
   imageWatermark.setVerticalAlignment(VerticalAlignment.CENTER);
   imageWatermark.setMargin(new Margin(10, 10, 10, 10));
   

   Adjust these values to achieve the desired appearance opacity controls transparency, while scaleFactor determines the size relative to the page.

4. Set watermark options and output path: Combine the file info and watermark into a WatermarkOptions object.

   WatermarkOptions options = new WatermarkOptions();
   options.setFileInfo(fileInfo);
   options.setImageWatermark(imageWatermark);
   options.setOutputPath("output.pdf");
   

   The outputPath tells the service where to store the resulting PDF.

5. Execute the request: Build an AddWatermarkRequest and call the API. Handle success or error responses.

   AddWatermarkRequest request = new AddWatermarkRequest(options);
   try {
       AddWatermarkResponse response = watermarkApi.addWatermark(request);
       System.out.println("Watermark added successfully. Output file: " + response.getPath());
   } catch (Exception e) {
       System.err.println("Error adding watermark: " + e.getMessage());
   }
   

   After execution, the watermarked PDF is available at the location you specified.

Complete Code Example: Add Image Watermark to PDF Documents in Java

The following example demonstrates the full implementation from client initialization to saving the watermarked PDF.

import com.groupdocs.cloud.watermark.api.WatermarkApi;
import com.groupdocs.cloud.watermark.client.ApiClient;
import com.groupdocs.cloud.watermark.model.AddWatermarkRequest;
import com.groupdocs.cloud.watermark.model.AddWatermarkResponse;
import com.groupdocs.cloud.watermark.model.FileInfo;
import com.groupdocs.cloud.watermark.model.ImageWatermark;
import com.groupdocs.cloud.watermark.model.Margin;
import com.groupdocs.cloud.watermark.model.WatermarkOptions;
import com.groupdocs.cloud.watermark.model.enums.HorizontalAlignment;
import com.groupdocs.cloud.watermark.model.enums.VerticalAlignment;

public class AddImageWatermarkExample {
    public static void main(String[] args) {
        // Initialize API client (replace with your actual credentials)
        ApiClient apiClient = new ApiClient("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET");
        WatermarkApi watermarkApi = new WatermarkApi(apiClient);

        // Input PDF file information
        FileInfo fileInfo = new FileInfo();
        fileInfo.setFilePath("input.pdf");

        // Image watermark configuration
        ImageWatermark imageWatermark = new ImageWatermark();
        imageWatermark.setImagePath("watermark.png");          // Path to watermark image
        imageWatermark.setOpacity(0.5);                        // 50% opacity
        imageWatermark.setScaleFactor(0.3);                    // 30% of page size
        imageWatermark.setRotationAngle(0);                    // No rotation
        imageWatermark.setHorizontalAlignment(HorizontalAlignment.CENTER);
        imageWatermark.setVerticalAlignment(VerticalAlignment.CENTER);
        imageWatermark.setMargin(new Margin(10, 10, 10, 10));  // 10 points margin on all sides

        // Watermark options
        WatermarkOptions options = new WatermarkOptions();
        options.setFileInfo(fileInfo);
        options.setImageWatermark(imageWatermark);
        options.setOutputPath("output.pdf"); // Resulting PDF with watermark

        // Create request and call API
        AddWatermarkRequest request = new AddWatermarkRequest(options);
        try {
            AddWatermarkResponse response = watermarkApi.addWatermark(request);
            System.out.println("Watermark added successfully. Output file: " + response.getPath());
        } catch (Exception e) {
            System.err.println("Error adding watermark: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

Note: This code example demonstrates the core functionality. Before using it in your project, make sure to update the file paths (input.pdf, watermark.png, output.pdf) to match your actual file locations, verify that all required dependencies are properly installed, and test thoroughly in your development environment. If you encounter any issues, please refer to the official documentation or reach out to the support team for assistance.

Apply Image Watermark to PDF Documents via cURL and REST API

Below are the REST calls you can use with cURL to achieve the same result without writing Java code.

1. Obtain an access token

   curl -X POST "https://api.groupdocs.cloud/v2.0/auth/token" \
        -H "Content-Type: application/json" \
        -d '{"client_id":"YOUR_CLIENT_ID","client_secret":"YOUR_CLIENT_SECRET"}'
   

   The response contains an access_token used in subsequent calls.

2. Upload the source PDF

   curl -X POST "https://api.groupdocs.cloud/v2.0/storage/upload?path=input.pdf" \
        -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
        -F "file=@/path/to/input.pdf"
   

3. Upload the watermark image

   curl -X POST "https://api.groupdocs.cloud/v2.0/storage/upload?path=watermark.png" \
        -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
        -F "file=@/path/to/watermark.png"
   

4. Add the image watermark

   curl -X POST "https://api.groupdocs.cloud/v2.0/watermark/add" \
        -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
        -H "Content-Type: application/json" \
        -d '{
              "fileInfo": { "filePath": "input.pdf" },
              "imageWatermark": {
                  "imagePath": "watermark.png",
                  "opacity": 0.5,
                  "scaleFactor": 0.3,
                  "horizontalAlignment": "Center",
                  "verticalAlignment": "Center",
                  "margin": { "top": 10, "right": 10, "bottom": 10, "left": 10 }
              },
              "outputPath": "output.pdf"
            }'
   

   This request mirrors the Java code logic, applying the same opacity, scaling and alignment settings.

5. Download the watermarked PDF

   curl -X GET "https://api.groupdocs.cloud/v2.0/storage/download?path=output.pdf" \
        -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
        -o output.pdf
   

For more details on request bodies and supported parameters, see the official API documentation.

Installing and Configuring GroupDocs.Watermark Cloud SDK for Java

Add the Maven dependency to your pom.xml (or the equivalent Gradle snippet). The library is hosted on Maven Central.

<dependency>
    <groupId>com.groupdocs</groupId>
    <artifactId>groupdocs-watermark-cloud</artifactId>
    <version>23.8</version>
</dependency>

You also need a valid GroupDocs Cloud account. Retrieve your Client ID and Client Secret from the GroupDocs portal. No additional runtime installation is required because the SDK communicates with the cloud service.

Fine-Tuning Image Watermark Options for PDF Documents

The SDK exposes several properties that let you control the visual appearance of the watermark.

Adjust Opacity

imageWatermark.setOpacity(0.75); // 75% opacity for a more visible watermark

Opacity values range from 0.0 (fully transparent) to 1.0 (fully opaque).

Change Scale Factor

imageWatermark.setScaleFactor(0.5); // Watermark occupies 50% of the page width

The scale factor determines the watermark size relative to the page dimensions.

Set Alignment and Margins

imageWatermark.setHorizontalAlignment(HorizontalAlignment.RIGHT);
imageWatermark.setVerticalAlignment(VerticalAlignment.BOTTOM);
imageWatermark.setMargin(new Margin(20, 20, 20, 20));

These settings place the watermark in the lower‑right corner with a 20‑point margin.

For a complete list of configurable properties, refer to the API reference.

Conclusion

Adding an image watermark to PDF documents in Java is a straightforward task when you use the GroupDocs.Watermark Cloud SDK for Java. The SDK handles all low‑level PDF manipulation, letting you focus on the visual aspects such as opacity, scaling and positioning. Whether you prefer a native Java implementation or a cloud‑based cURL workflow, the same high‑quality results are achievable without sacrificing performance. Remember to obtain a proper license for production use; pricing details are available on the product page and a temporary license page can be used for evaluation.

FAQs

• How do I add image watermark to PDF in Java without losing quality?
  Use the scaleFactor property to size the watermark relative to the page and keep the original DPI of the source PDF. The SDK preserves the PDF’s resolution, so the watermark appears crisp at any zoom level.

• Can I add multiple watermarks to the same PDF?
  Yes. Create separate ImageWatermark objects with different configurations and add them sequentially by calling addWatermark multiple times or by adding them to a list in the request.

• What are the supported image formats for the watermark?
  The API accepts common image types such as PNG, JPG, BMP, GIF and TIFF. PNG is recommended for lossless quality and transparency support.

• Is there a way to preview the watermark before applying it?
  You can use the GroupDocs.Watermark Cloud SDK for Java to generate a temporary PDF with the watermark and download it for review. This uses the same addWatermark call with an output path pointing to a temporary location.

Read More

• Add Watermark to Images using Java
• Add Watermark to Word in Java - Watermark Creator
• Add Image Watermark to PDF | How to Add Watermark to PDF Documents Using .NET