How to Get Annotations from PDF in C# - Extract Comments & Markup

Introduction

Ever received a PDF covered in sticky notes, highlights, and reviewer comments, only to realize you need to extract all that feedback programmatically? You’re not alone. Thousands of developers face this challenge daily when building document review systems, compliance tools, or collaborative platforms.

The problem? Most PDF libraries either don’t support annotation extraction at all, or they require you to parse low-level PDF structures manually (nobody wants to debug PDF syntax at 2 AM). That’s where GroupDocs.Watermark for .NET comes in—it handles the heavy lifting so you can focus on building features your users actually care about.

In this guide, you’ll learn how to extract every type of PDF annotation (comments, highlights, sticky notes, drawings—the works) using clean, production-ready C# code. We’ll cover common pitfalls, performance optimization, and real-world scenarios you’ll actually encounter.

What You’ll Learn:

• Why you’d want to extract PDF annotations (spoiler: it’s not just for fun)
• Setting up GroupDocs.Watermark the right way
• Step-by-step code to extract annotation details
• How to handle edge cases like password-protected PDFs
• Performance tips for processing thousands of documents

Let’s dive in.

Why Extract PDF Annotations? (Real Use Cases)

Before we get into the code, here’s why developers actually need this functionality:

1. Document Review Workflows Your legal team marks up contracts with comments and highlights. You need to extract these annotations to track changes, generate review reports, or migrate feedback to a database.

2. Compliance & Audit Trails Regulatory requirements often mandate preserving who made what comments when. Extracting annotations with metadata creates an audit trail that auditors (and your future self) will thank you for.

3. Collaborative Platforms Building a document collaboration tool? You’ll need to sync annotations across users, convert PDF comments to your internal format, or merge feedback from multiple reviewers.

4. E-Learning Systems Students highlight and annotate course materials. Extract those annotations to analyze which sections need clarification or to provide personalized feedback.

5. Migration Projects Moving from an old document management system? Extract annotations before they’re lost forever during the PDF version upgrade.

Now that you know why this matters, let’s set things up.

Prerequisites

To follow along, you’ll need:

• Required Libraries: GroupDocs.Watermark for .NET (latest stable version recommended—seriously, update your NuGet packages)
• Environment Setup:
  • A .NET development environment (Visual Studio 2019+ or VS Code with C# extensions)
  • Basic C# knowledge (if you can write a foreach loop, you’re good)
  • .NET Framework 4.6.1+ or .NET Core 3.1+ / .NET 5+

Quick version check: Run dotnet --version in your terminal to confirm you’re on a supported runtime.

Setting Up GroupDocs.Watermark for .NET

Installation

You’ve got three ways to install GroupDocs.Watermark. Pick whichever fits your workflow:

.NET CLI (My personal favorite for new projects)

dotnet add package GroupDocs.Watermark

Package Manager Console (Classic Visual Studio approach)

Install-Package GroupDocs.Watermark

NuGet Package Manager UI (For the point-and-click crowd) Search for “GroupDocs.Watermark” in Visual Studio’s NuGet browser and hit Install. Easy.

Pro tip: Pin your version in production. Annotation APIs rarely break, but you don’t want surprises during a Friday deployment.

License Acquisition

Here’s the deal with licensing (because nothing in enterprise software is truly “free”):

• Free Trial: Download and test for 30 days. Perfect for proof-of-concepts or convincing your manager this solution works.
• Temporary License: Need more time? Request a temporary license for extended evaluation. It’s free and takes 5 minutes.
• Purchase: Ready for production? Buy a license based on your deployment model (developer licenses, site licenses, etc.).

Important: The trial version adds watermarks to outputs and has page limitations. That’s fine for testing, but don’t deploy it to production and wonder why your users complain.

Basic Initialization

Let’s make sure everything’s wired up correctly. Here’s the “Hello World” of PDF annotation extraction:

using GroupDocs.Watermark;
using System;

namespace PdfAnnotationExtractor
{
    class Program
    {
        static void Main(string[] args)
        {
            // Initialize Watermarker with a PDF document path
            // (Replace "sample.pdf" with your actual file path)
            using (Watermarker watermarker = new Watermarker("sample.pdf"))
            {
                Console.WriteLine("GroupDocs.Watermark initialized successfully!");
                // If you see this message, you're ready to rock
            }
        }
    }
}

What’s happening here:

• The using statement ensures proper disposal (no memory leaks, yay!)
• Watermarker is your main entry point for all PDF operations
• If this throws an exception, check your file path and license setup

Common gotcha: If you get a “file not found” error, make sure your PDF is in the bin/Debug folder or use an absolute path during testing.

Implementation Guide - Extracting Annotations Step-by-Step

Alright, let’s get to the good stuff. Here’s how to actually extract annotation data from your PDFs.

Understanding PDF Annotations

Before you start extracting, here’s what you’re dealing with. PDFs support multiple annotation types:

• Text annotations: Sticky notes, comments, text boxes
• Markup annotations: Highlights, underlines, strikethroughs
• Stamp annotations: “Approved,” “Confidential” stamps
• Ink annotations: Freehand drawings (yes, people still do this)
• Shape annotations: Circles, rectangles drawn on the document

GroupDocs.Watermark lets you extract details for all these types. You’ll get:

• Annotation type (so you know what you’re dealing with)
• Text content (the actual comment or note)
• Position & dimensions (where it appears on the page)
• Page number (critical for multi-page documents)
• Author metadata (if available—depends on how the PDF was created)
• Associated images (for image-based annotations)

Step 1: Initialize the Watermarker

First, create your Watermarker instance. This is your gateway to the PDF:

using (Watermarker watermarker = new Watermarker("sample.pdf"))
{
    // All your annotation extraction code goes inside this using block
    // The using block ensures the PDF is properly closed when you're done
}

Why using? PDFs lock files while they’re open. The using statement guarantees the file handle is released, even if an exception occurs. Trust me, you don’t want to debug “file is locked by another process” errors.

Step 2: Access the PDF Content

Now you need to tell GroupDocs you want to work with PDF-specific content (not just generic watermark operations):

using (Watermarker watermarker = new Watermarker("sample.pdf"))
{
    // Get PDF-specific content
    PdfContent pdfContent = watermarker.GetContent<PdfContent>();
    
    // Access the annotations collection
    PdfAnnotationCollection annotations = pdfContent.Annotations;
    
    Console.WriteLine($"Found {annotations.Count} annotations in this PDF");
}

What’s happening:

• GetContent<PdfContent>() gives you strongly-typed access to PDF features
• Annotations is a collection of all annotations across all pages
• This is a read operation—your original PDF stays untouched

Performance note: This loads annotation metadata, not the entire PDF into memory. Even large PDFs (500+ pages) handle this efficiently.

Step 3: Iterate and Extract Annotation Details

Now loop through each annotation and extract the juicy details:

foreach (PdfAnnotation annotation in annotations)
{
    // Basic annotation info
    Console.WriteLine($"\n--- Annotation {annotations.IndexOf(annotation) + 1} ---");
    Console.WriteLine($"Type: {annotation.AnnotationType}");
    Console.WriteLine($"Page Number: {annotation.PageIndex}");
    
    // Text content (if available)
    if (!string.IsNullOrEmpty(annotation.Text))
    {
        Console.WriteLine($"Text: {annotation.Text}");
    }
    
    // Position and size
    Console.WriteLine($"Position: X={annotation.X}, Y={annotation.Y}");
    Console.WriteLine($"Dimensions: Width={annotation.Width}, Height={annotation.Height}");
    
    // Author info (if metadata was preserved)
    if (!string.IsNullOrEmpty(annotation.Author))
    {
        Console.WriteLine($"Author: {annotation.Author}");
    }
}

Real talk: Not every annotation has every property. Highlights don’t have “text” in the same way sticky notes do. Always check for null or empty values before using properties.

Pro tip: Use annotation.PageIndex to correlate annotations with specific pages. Page indices are zero-based (first page = 0), which can trip you up if you’re displaying to users who think in 1-based page numbers.

Step 4: Handle Different Annotation Types

Different annotation types have different properties. Here’s how to handle them intelligently:

foreach (PdfAnnotation annotation in annotations)
{
    switch (annotation.AnnotationType)
    {
        case PdfAnnotationType.Text:
            // Sticky notes, text comments
            Console.WriteLine($"Comment: {annotation.Text}");
            break;
            
        case PdfAnnotationType.Highlight:
            // Highlighted text
            Console.WriteLine($"Highlighted area on page {annotation.PageIndex + 1}");
            // Note: The actual highlighted text isn't in annotation.Text
            // You'd need to extract text from the coordinates separately
            break;
            
        case PdfAnnotationType.Stamp:
            // Stamps like "Approved", "Confidential"
            Console.WriteLine($"Stamp: {annotation.Text}");
            break;
            
        case PdfAnnotationType.Ink:
            // Freehand drawings
            Console.WriteLine("Ink annotation (drawing) detected");
            // Ink annotations store path data, not text
            break;
            
        default:
            Console.WriteLine($"Other annotation type: {annotation.AnnotationType}");
            break;
    }
}

Why this matters: If you try to read .Text from a highlight annotation expecting the highlighted content, you’ll be disappointed. Highlights store coordinates, not the text itself. You’d need additional logic to extract text from those regions.

Step 5: Extract Image Annotations (Advanced)

Some annotations contain images (like rubber stamps with logos). Here’s how to handle them:

foreach (PdfAnnotation annotation in annotations)
{
    // Check if this annotation has image data
    if (annotation.AnnotationType == PdfAnnotationType.Stamp && annotation.ImageData != null)
    {
        Console.WriteLine("Image-based stamp detected");
        
        // You can save the image data to a file
        string imagePath = $"annotation_{annotations.IndexOf(annotation)}.png";
        System.IO.File.WriteAllBytes(imagePath, annotation.ImageData);
        Console.WriteLine($"Saved stamp image to {imagePath}");
    }
}

Use case: Extracting company logos from approval stamps or signature images from signed PDFs.

Step 6: Error Handling (Don’t Skip This)

Production code needs robust error handling. Here’s what to watch for:

try
{
    using (Watermarker watermarker = new Watermarker("sample.pdf"))
    {
        PdfContent pdfContent = watermarker.GetContent<PdfContent>();
        
        // Your annotation extraction code here
    }
}
catch (System.IO.FileNotFoundException)
{
    Console.WriteLine("Error: PDF file not found. Check your file path.");
}
catch (GroupDocs.Watermark.Exceptions.InvalidPasswordException)
{
    Console.WriteLine("Error: PDF is password-protected. Provide the correct password.");
}
catch (GroupDocs.Watermark.Exceptions.IncorrectPasswordException)
{
    Console.WriteLine("Error: Incorrect password provided.");
}
catch (Exception ex)
{
    Console.WriteLine($"Unexpected error: {ex.Message}");
    // Log the full exception in production for debugging
}

Common exceptions you’ll encounter:

• FileNotFoundException: Wrong path or file doesn’t exist
• InvalidPasswordException: PDF requires a password
• UnsupportedFileTypeException: Not a valid PDF or corrupted
• OutOfMemoryException: PDF is too large (rare, but possible with huge files)

Common Pitfalls & How to Avoid Them

Pitfall 1: Ignoring Password-Protected PDFs

The problem: Your code crashes when it hits a password-protected PDF in a batch process.

The solution: Check for password protection and handle it gracefully:

try
{
    using (Watermarker watermarker = new Watermarker("protected.pdf", 
        new LoadOptions { Password = "your-password" }))
    {
        // Process annotations
    }
}
catch (InvalidPasswordException)
{
    Console.WriteLine("This PDF requires a password.");
    // Skip it, log it, or prompt the user—your choice
}

Pro tip: In batch processing scenarios, keep a separate list of password-protected PDFs and handle them in a second pass.

Pitfall 2: Assuming All Annotations Have Text

The problem: You try to read .Text from every annotation and get null reference exceptions.

The solution: Always check before accessing text properties:

if (!string.IsNullOrEmpty(annotation.Text))
{
    Console.WriteLine($"Text: {annotation.Text}");
}
else
{
    Console.WriteLine("This annotation has no text content");
}

Highlights, ink drawings, and shape annotations often have no text. That’s normal.

Pitfall 3: Memory Leaks in Batch Processing

The problem: Processing 10,000 PDFs causes your app to run out of memory and crash.

The solution: Always use using statements and process in batches:

string[] pdfFiles = Directory.GetFiles("pdf-folder", "*.pdf");

foreach (string pdfFile in pdfFiles)
{
    using (Watermarker watermarker = new Watermarker(pdfFile))
    {
        // Extract annotations
        // Watermarker is disposed automatically after each iteration
    }
    
    // Optional: Force garbage collection every 100 files
    if (Array.IndexOf(pdfFiles, pdfFile) % 100 == 0)
    {
        GC.Collect();
    }
}

Why this works: The using statement releases file handles and memory immediately. Without it, you’re relying on the garbage collector, which might not kick in fast enough.

Pitfall 4: Coordinate System Confusion

The problem: Annotation positions don’t match what you see in PDF viewers.

The reality: PDF coordinates start at the bottom-left corner (Y=0 is the bottom), but most developers think in top-left terms (Y=0 is the top).

The solution: If you need to convert to screen coordinates:

// PDF page height is needed for conversion
double pageHeight = pdfContent.Pages[annotation.PageIndex].Height;

// Convert PDF coordinates to screen coordinates
double screenY = pageHeight - annotation.Y - annotation.Height;

Console.WriteLine($"Screen position: X={annotation.X}, Y={screenY}");

This comes up when you’re overlaying annotations on a web-based PDF viewer.

Real-World Scenarios

Let’s look at how you’d actually use this in production applications.

Scenario 1: Building a Document Review Dashboard

Goal: Extract all reviewer comments and display them in a web dashboard grouped by page.

var reviewComments = new Dictionary<int, List<string>>();

using (Watermarker watermarker = new Watermarker("contract-review.pdf"))
{
    PdfContent pdfContent = watermarker.GetContent<PdfContent>();
    
    foreach (PdfAnnotation annotation in pdfContent.Annotations)
    {
        if (annotation.AnnotationType == PdfAnnotationType.Text && 
            !string.IsNullOrEmpty(annotation.Text))
        {
            int pageNumber = annotation.PageIndex + 1; // 1-based for display
            
            if (!reviewComments.ContainsKey(pageNumber))
            {
                reviewComments[pageNumber] = new List<string>();
            }
            
            string comment = $"{annotation.Author}: {annotation.Text}";
            reviewComments[pageNumber].Add(comment);
        }
    }
}

// Now you can serialize reviewComments to JSON and send to your frontend

Why this is useful: Legal teams, content reviewers, and QA departments love having comments extracted and organized. Beats scrolling through a 200-page PDF manually.

Scenario 2: Compliance Audit Trail

Goal: Generate a report showing who made what changes and when.

using (Watermarker watermarker = new Watermarker("financial-report.pdf"))
{
    PdfContent pdfContent = watermarker.GetContent<PdfContent>();
    
    Console.WriteLine("=== Audit Trail Report ===\n");
    
    foreach (PdfAnnotation annotation in pdfContent.Annotations)
    {
        if (!string.IsNullOrEmpty(annotation.Author))
        {
            Console.WriteLine($"Page {annotation.PageIndex + 1}:");
            Console.WriteLine($"  Author: {annotation.Author}");
            Console.WriteLine($"  Type: {annotation.AnnotationType}");
            Console.WriteLine($"  Content: {annotation.Text ?? "[No text]"}");
            
            // If your PDF has creation dates (not all do)
            if (annotation.CreationDate != null)
            {
                Console.WriteLine($"  Date: {annotation.CreationDate}");
            }
            Console.WriteLine();
        }
    }
}

Pro tip: Combine this with your authentication system to cross-reference PDF annotations with your user database.

Scenario 3: E-Learning Analytics

Goal: Analyze which sections of course materials students highlight most.

var highlightHeatmap = new Dictionary<int, int>(); // Page -> Highlight count

using (Watermarker watermarker = new Watermarker("course-material.pdf"))
{
    PdfContent pdfContent = watermarker.GetContent<PdfContent>();
    
    foreach (PdfAnnotation annotation in pdfContent.Annotations)
    {
        if (annotation.AnnotationType == PdfAnnotationType.Highlight)
        {
            int pageNumber = annotation.PageIndex + 1;
            
            if (!highlightHeatmap.ContainsKey(pageNumber))
            {
                highlightHeatmap[pageNumber] = 0;
            }
            
            highlightHeatmap[pageNumber]++;
        }
    }
}

// Find pages with most highlights
var topPages = highlightHeatmap.OrderByDescending(x => x.Value).Take(5);

Console.WriteLine("Top 5 most-highlighted pages:");
foreach (var page in topPages)
{
    Console.WriteLine($"  Page {page.Key}: {page.Value} highlights");
}

Insight: Pages with the most highlights might indicate either confusing content (students marking for review) or particularly important concepts. Context matters!

Performance Considerations

Processing Large Documents

Question: How fast is annotation extraction?

Answer: It depends on file size and annotation count, but here are ballpark figures:

• Small PDFs (< 10 pages, < 50 annotations): ~100-300ms
• Medium PDFs (50-100 pages, 200-500 annotations): ~1-3 seconds
• Large PDFs (500+ pages, 1000+ annotations): ~5-15 seconds

Optimization tips:

1. Process in parallel (if handling multiple files):

var pdfFiles = Directory.GetFiles("pdf-folder", "*.pdf");

Parallel.ForEach(pdfFiles, new ParallelOptions { MaxDegreeOfParallelism = 4 }, 
    pdfFile =>
{
    using (Watermarker watermarker = new Watermarker(pdfFile))
    {
        // Extract annotations
    }
});

2. Cache results if processing the same PDFs repeatedly:

// Store extracted annotations in a database or cache
// Only re-extract if PDF modification date changes

3. Filter annotations upfront if you only need specific types:

// Only process text annotations
var textAnnotations = pdfContent.Annotations
    .Where(a => a.AnnotationType == PdfAnnotationType.Text);

Memory Management

Best practices:

• Always use using statements (seriously, can’t emphasize this enough)
• Process files sequentially if memory is tight
• Call GC.Collect() periodically in long-running batch processes (but sparingly—overusing it hurts performance)

Red flag: If your app’s memory usage keeps climbing during batch processing, you’re likely missing using statements or holding references to Watermarker objects.

Troubleshooting FAQ

Q1: “I get an exception about missing a license. What do I do?”

A: You’re running the library without a valid license. Options:

• Apply for a free trial or temporary license
• Purchase a license for production use
• The trial works but adds watermarks—acceptable for testing

Q2: “Can I extract annotations from password-protected PDFs?”

A: Yes, but you need to provide the password:

using (Watermarker watermarker = new Watermarker("protected.pdf", 
    new LoadOptions { Password = "secret123" }))
{
    // Now you can access annotations
}

Q3: “Why is annotation.Text always empty for highlights?”

A: Highlight annotations store coordinate data, not the highlighted text itself. The text is part of the page content. To get the actual highlighted text, you’d need to:

1. Get the highlight coordinates
2. Extract text from that region using a separate text extraction method

GroupDocs.Watermark focuses on annotation metadata, not full text extraction.

Q4: “How do I handle different PDF versions (1.4, 1.7, 2.0)?”

A: GroupDocs.Watermark handles this automatically. You don’t need to worry about PDF version compatibility—just load the file normally.

Q5: “What’s the maximum PDF size I can process?”

A: Technically, there’s no hard limit, but:

• Practical limit: PDFs up to 500MB usually process fine on standard hardware
• Bottleneck: Your system’s available RAM, not the library
• Recommendation: If processing multi-GB PDFs regularly, consider splitting them or upgrading your server RAM

Q6: “Can I modify annotations, not just extract them?”

A: Yes! GroupDocs.Watermark supports adding, modifying, and removing annotations:

// Add a new text annotation
var newAnnotation = new PdfTextAnnotation
{
    Text = "This is a new comment",
    X = 100,
    Y = 100,
    PageIndex = 0
};
pdfContent.Annotations.Add(newAnnotation);

// Save the modified PDF
watermarker.Save("modified.pdf");

That’s beyond the scope of this extraction guide, but it’s totally possible.

Q7: “I’m processing 10,000 PDFs. Any tips?”

A: Batch processing at scale requires strategy:

• Use parallel processing (4-8 threads typically)
• Implement retry logic for corrupted PDFs
• Log failures separately for manual review
• Consider async/await patterns for non-blocking operations
• Monitor memory usage and add GC.Collect() every N files
• Store results in a database incrementally (don’t hold everything in memory)

Q8: “Does this work with scanned PDFs (image-based)?”

A: If the PDF contains annotations (added after scanning), yes. If you’re asking about extracting handwritten notes from scanned images, no—that requires OCR and image processing, which is outside GroupDocs.Watermark’s scope.

Conclusion

You now know how to extract PDF annotations in C# using GroupDocs.Watermark. Here’s what you learned:

• ✅ Setting up the library and handling licenses
• ✅ Extracting annotation details (type, text, position, author)
• ✅ Handling different annotation types intelligently
• ✅ Avoiding common pitfalls (passwords, null values, memory leaks)
• ✅ Real-world scenarios (document review, compliance, analytics)
• ✅ Performance optimization for large-scale processing

Resources

• Documentation: GroupDocs.Watermark for .NET Docs
• API Reference: Complete API Documentation
• Download: Get the Latest Release
• Free Support: Community Forum
• Temporary License: Request Extended Trial
• Purchase: Buy a License