Extract Annotations from PDF Documents Leave feedback

Extract Annotations from PDF Documents is a GroupDocs.Parser capability for Java that reads reviewer comments, sticky notes, and other markup left on a PDF file and returns them as structured data. The guide below shows how to turn that markup into something you can actually use, whether you need a flat dump of every comment, a page‑by‑page breakdown, or a combined text‑plus‑annotations transcript.

Publishing and legal teams routinely pass a PDF through several reviewers before it’s finalized. Each reviewer leaves comments directly in the file instead of writing a separate summary, which means the feedback is easy to miss unless someone opens every page in a PDF viewer. Pulling the annotations out programmatically turns that scattered feedback into a checklist the editor can work through.

Consider a 40‑page release note that went through three reviewers: manually scrolling through it to find every sticky note can take longer than actually addressing the feedback. Extracting the annotations in a few lines of code turns that into a two‑minute job.

Annotations are the only record of who asked for a change and why, since the final rendered PDF usually hides that context once comments are resolved or the file is flattened. Reading them programmatically lets you:

• Build a checklist of open review comments without opening the file.
• Archive reviewer feedback alongside the document for future audits.
• Feed comments into a ticketing system automatically.

GroupDocs.Parser for Java extracts annotations via the getAnnotations method. See Extract Annotations from PDF Documents in Java for the API overview.

• A JDK supported by GroupDocs.Parser for Java (see System Requirements) and Maven.
• A temporary license key (valid for 30 days) from the GroupDocs portal Temp License.
• GroupDocs.Parser for Java 26.10 or later.
• A PDF with existing annotations, e.g., document-with-annotations.pdf.

Add the GroupDocs repository and the GroupDocs.Parser dependency to your pom.xml:

<repositories>
    <repository>
        <id>GroupDocsJavaAPI</id>
        <name>GroupDocs Java API</name>
        <url>https://releases.groupdocs.com/java/repo/</url>
    </repository>
</repositories>

<dependencies>
    <dependency>
        <groupId>com.groupdocs</groupId>
        <artifactId>groupdocs-parser</artifactId>
        <version>26.10</version>
    </dependency>
</dependencies>

See Installation for other installation options.

The snippets below are written as small static methods so you can copy‑paste them into your own project without pulling in unnecessary dependencies:

The snippets use the following imports:

import com.groupdocs.parser.Parser;
import com.groupdocs.parser.data.AnnotationItem;
import com.groupdocs.parser.data.TextReader;
import com.groupdocs.parser.options.IDocumentInfo;
import com.groupdocs.parser.options.TextOptions;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;

Not every file format supports annotations, and getAnnotations returns null when it doesn’t. Checking getFeatures().isAnnotations() upfront lets you fail fast with a clear message instead of guarding every call with a null check.

public static boolean checkAnnotationSupport(String path) {
    try (Parser parser = new Parser(path)) {
        return parser.getFeatures().isAnnotations();
    }
}

How it works: Parser.getFeatures() returns a Features object whose isAnnotations() method reflects whether the loaded document format supports annotation extraction.

Use the parameterless getAnnotations() overload when you just need every comment in the file, regardless of which page it’s on.

public static List<String> extractAllAnnotations(String path) {
    List<String> result = new ArrayList<>();
    try (Parser parser = new Parser(path)) {
        Iterable<AnnotationItem> annotations = parser.getAnnotations();
        if (annotations == null) {
            return result;
        }

        for (AnnotationItem item : annotations) {
            result.add(item.getValue());
        }
    }
    return result;
}

Key points:

• getAnnotations() returns null when annotation extraction isn’t supported, and an empty collection when the document simply has no annotations — the two cases are distinguishable.
• Each AnnotationItem exposes its text through the getValue() method.
• Best for a quick “does this file have open comments at all?” check.

When you need to know which page a comment belongs to, call getAnnotations(pageIndex) in a loop driven by getDocumentInfo().getPageCount(). The page index is stored in a small record class together with the annotation text:

public static class AnnotationRecord {
    private final int pageIndex;
    private final String value;

    public AnnotationRecord(int pageIndex, String value) {
        this.pageIndex = pageIndex;
        this.value = value;
    }

    public int getPageIndex() { return pageIndex; }
    public String getValue() { return value; }
}

public static List<AnnotationRecord> extractAnnotationsByPage(String path) {
    List<AnnotationRecord> result = new ArrayList<>();
    try (Parser parser = new Parser(path)) {
        if (!parser.getFeatures().isAnnotations()) {
            return result;
        }

        IDocumentInfo info = parser.getDocumentInfo();
        if (info == null || info.getPageCount() == 0) {
            return result;
        }

        for (int pageIndex = 0; pageIndex < info.getPageCount(); pageIndex++) {
            Iterable<AnnotationItem> pageAnnotations = parser.getAnnotations(pageIndex);
            if (pageAnnotations == null) {
                continue;
            }

            for (AnnotationItem item : pageAnnotations) {
                result.add(new AnnotationRecord(pageIndex, item.getValue()));
            }
        }
    }
    return result;
}

Why use it: The output is a flat list of page → comment pairs, which is exactly the shape a CSV or JSON export needs.

Sometimes it’s more useful to see a comment in the flow of the surrounding text rather than as a separate list. Calling setIncludeAnnotations(true) on TextOptions folds annotation text into the regular getText output.

public static String extractTextWithAnnotations(String path) throws IOException {
    try (Parser parser = new Parser(path)) {
        TextOptions options = new TextOptions(false);
        options.setIncludeAnnotations(true);

        try (TextReader reader = parser.getText(options)) {
            return reader == null ? "" : reader.readToEnd();
        }
    }
}

When it shines: Generating a single transcript‑style document that a reviewer can read top to bottom, comments and all, without cross‑referencing a separate list.

A CSV export lets reviewers open the comment list directly in Excel or feed it into a tracking spreadsheet. The exporter iterates over the page‑tagged records built in step 3 and writes a two‑column file (page,value).

public static void exportAnnotationsToCsv(List<AnnotationRecord> records, String outputPath) throws IOException {
    StringBuilder sb = new StringBuilder();
    sb.append("page,value").append(System.lineSeparator());

    for (AnnotationRecord record : records) {
        sb.append(record.getPageIndex()).append(',')
          .append(csvEscape(record.getValue()))
          .append(System.lineSeparator());
    }

    Files.write(Paths.get(outputPath), sb.toString().getBytes(StandardCharsets.UTF_8));
}

private static String csvEscape(String value) {
    if (value == null) {
        return "";
    }
    return "\"" + value.replace("\"", "\"\"") + "\"";
}

JSON is a better fit when a downstream service needs to consume the comments directly, without parsing a spreadsheet. The exporter builds a simple array of { page, value } objects.

public static void exportAnnotationsToJson(List<AnnotationRecord> records, String outputPath) throws IOException {
    StringBuilder sb = new StringBuilder();
    sb.append("[").append(System.lineSeparator());

    for (int i = 0; i < records.size(); i++) {
        String comma = i < records.size() - 1 ? "," : "";
        sb.append(String.format("  { \"page\": %d, \"value\": \"%s\" }%s",
                records.get(i).getPageIndex(), jsonEscape(records.get(i).getValue()), comma))
          .append(System.lineSeparator());
    }

    sb.append("]").append(System.lineSeparator());
    Files.write(Paths.get(outputPath), sb.toString().getBytes(StandardCharsets.UTF_8));
}

private static String jsonEscape(String value) {
    if (value == null) {
        return "";
    }
    return value.replace("\\", "\\\\")
                .replace("\"", "\\\"")
                .replace("\r", "\\r")
                .replace("\n", "\\n");
}

Both exporters can be called immediately after extractAnnotationsByPage completes.

Start with the whole‑document extraction to confirm a file has comments worth acting on, then switch to page‑by‑page extraction once you need to route feedback to the right section.

• Treating null and an empty collection the same way – getAnnotations returns null when the format doesn’t support annotations, and an empty Iterable when it does but the document has none. Logging these differently saves confusing debugging sessions later.
• Skipping the feature check – Calling getAnnotations on a format without annotation support is safe (it just returns null), but checking getFeatures().isAnnotations() first makes the intent of your code explicit.
• Forgetting try-with-resources – Parser holds file handles and other resources; always close it via a try-with-resources statement, especially when extracting from many files in a batch.
• Assuming annotation extraction works for every format – in GroupDocs.Parser for Java annotation extraction is supported for PDF documents, word processing documents (except plain text) and presentations; other formats return null.
• Mixing whole‑document and per‑page results – AnnotationItem doesn’t report a page number, so don’t try to reconcile the getAnnotations() output with the page‑tagged list; pick one extraction strategy per use case.

• Wrap every Parser usage in a try-with-resources statement to release file handles promptly.
• Re‑use the page‑tagged records from extractAnnotationsByPage as the single source of truth for both CSV and JSON exports, so the two outputs never drift apart.
• Store the temporary license key in an environment variable rather than hard‑coding it.
• For large batches, parallelize extraction across files but keep the export step sequential to avoid file‑write collisions.
• Combine annotation extraction with getText in raw mode when you only need a fast sanity check on comment volume.

A: getAnnotations() returns an empty collection, not null. Your iteration code runs normally and simply produces zero results — no extra null‑checking is required beyond the initial support check.

A: Yes, as long as you supply the correct password when loading the document (pass a LoadOptions object with the password to the Parser constructor), the same way you would for any other extraction operation. See Password-protected documents.

A: Yes. Besides getValue(), AnnotationItem exposes getAuthorName(), getTimestamp() and getAnnotationType(). These methods return null when the document doesn’t store the corresponding information. PDF annotations don’t store author initials, so getAuthorInitials() returns null for PDF documents.

A: Yes — call setIncludeAnnotations(true) on TextOptions and pass it to getText. This avoids a second pass over the document when you just want one combined transcript.

GroupDocs.Parser for Java gives you a direct, programmatic way to pull reviewer comments out of a PDF instead of scrolling through the file by hand. Whether you need a quick yes/no check, a page‑tagged report, or a combined text‑and‑annotations transcript, the sample methods above cover the most common review workflows. Export the results to CSV or JSON, wire them into your ticketing system, and stop losing feedback in a PDF nobody re‑opens.

• Extract Annotations from PDF Documents in Java
• getAnnotations API Reference
• Temporary License Request
• Sample Projects Repository
• Parser Blog Category