Insurance Document and ACORD Form Data Extraction

Apryse Server SDK recovers page structure from insurance packets and ACORD forms on a deterministic foundation. Purpose-built AI in Smart Data Extraction then reads the fields. The SDK runs inside your own infrastructure.

Extracting Data from Insurance Documents

Apryse Server SDK recovers the structure of an insurance file first. Page geometry, headers, and tables come from a deterministic foundation, so the same page produces the same structure on every run. Purpose-built AI in Smart Data Extraction then reads that structure and returns key-value pairs, form fields, and page categories, each with a confidence score.

The ACORD forms list decides your route. Fixed-layout forms such as ACORD 25, 125, 126, 130, and 140, plus loss notices ACORD 1 through 4, fit template extraction, where you define each field once. Claims packets with no consistent layout fit template-free key-value extraction. Your application owns routing, thresholds, and the claims system. The Apryse Server SDK processes documents inside your infrastructure.

Support Matrix

Copied to clipboard

Each column is a separately obtained component. Match the column to the document you receive.

Fact	Smart Data Extraction	Barcode Module	Template Extraction
Surface	Apryse Server SDK add-on module, self-hosted	Apryse Server SDK add-on module, self-hosted, separate module download	Separate library for .NET and Java, not part of the Apryse Server SDK
Platforms	Windows and Linux, x64 only. macOS is not supported.	Windows and Linux, x64 only. macOS is not supported.	Create templates in the Template Designer, a Windows application. Templates then work across platforms.
Licensing	Add-on license required. Trial keys have unlimited access, but trial output is capped at 100 pages per extraction operation and includes a watermark page.	Its own add-on license is required. The Smart Data Extraction license does not cover it. Trial keys have unlimited access.	A free trial is available from the Template Extraction capability page.
Required Gate	PDFNet.initialize() before any extraction call, then AddResourceSearchPath to the folder that holds the module's Lib directory. Initialization casing follows your language binding.	PDFNet.initialize() before any barcode call, then AddResourceSearchPath to the folder that holds the module's Lib directory. Initialization casing follows your language binding.	Builders take a templates source, a runtime folder, and a license.
Confidence Scores	Form field identification, key-value extraction, and document classification each return a confidence score. Table extraction does not.	Not documented for the Barcode Module.	Every extracted field carries a confidence score. Classification returns confidence level reports.
Docs	Smart Data Extraction guide	Barcode guide	Template Extraction overview

A claims packet is one file holding several documents. A first notice of loss, a repair estimate, a police report, and a fax cover sheet arrive together, each from a different sender with its own layout. Two carriers describe the same loss with different labels, field order, and page counts.

Scanned and faxed pages hold pixels, not text. The OCR Module, a separate add-on, converts image-based PDFs into searchable text with position data. Handwritten annotations need the Handwriting ICR Module, a separate add-on that reads handwriting and returns text with position data as JSON. Both run inside your infrastructure.

Mixed document types in one file break any extractor that assumes one layout per file. Template matching handles the forms with fixed layouts. The rest of the packet needs template-free reading, plus page-level classification so your code can see which pages belong together.

ACORD Forms

Copied to clipboard

ACORD is the Association for Cooperative Operations Research and Development, the non-profit standards body for the insurance industry. It publishes two things that people both call ACORD: numbered forms, and data standards.

The ACORD Forms List

Copied to clipboard

This page works with the forms below. Each is a fixed-layout form: the printed fields sit where the form defines them, and a scan can shift or skew them.

Form	Name	Group
ACORD 25	Certificate of Liability Insurance	Certificates
ACORD 125	Commercial Insurance Application, Applicant Information Section	Commercial lines
ACORD 126	Commercial General Liability Section	Commercial lines
ACORD 130	Workers Compensation Application	Commercial lines
ACORD 140	Property Section	Commercial lines
ACORD 1	Property Loss Notice	Loss notices
ACORD 2	Automobile Loss Notice	Loss notices
ACORD 3	General Liability Notice of Occurrence / Claim	Loss notices
ACORD 4	Workers Compensation First Report of Injury or Illness	Loss notices

ACORD revises its forms by edition date. Treat each edition you receive as its own template.

The ACORD Data Model

Copied to clipboard

The ACORD Data Model is a different asset from a form. It is a logical entity-relationship structure, generated from ACORD's Information Model, that you can use to design physical data models and data warehouses. ACORD's XML, JSON, and AL3 standards carry insurance data between systems as messages.

Reading a form produces values. Your code maps each value to your own schema, or to an ACORD message format if your carriers expect one.

Fixed-Layout Forms with Template Extraction

Fixed layout is where template extraction fits. You define a form's fields once in the Template Designer, a Windows application. Your code then classifies each incoming scan against a collection of templates and extracts the fields the matched template defines.

Classification works at form level and page level, and a template can span several pages. Extraction tolerates deformation between the template layout and the scan, and recognition boxes define which part of the page each field reads. Field types include text, OMR, image, and barcode. Results come back typed as text, checkbox, image, barcode, blank, table, or table row, and every extracted field carries a confidence score.

Template Extraction is a separate library for .NET and Java. It is not part of the Apryse Server SDK, and your data stays on-premises. Check out the following resources:

Visit the template extraction page
Read ACORD form extraction in .NET for a .NET walkthrough that builds a template and classifies a scan
Lastly, template extraction for ACORD forms overviews exporting extracted fields to JSON inside a document management system.

Worked Example 1: Named ACORD Fields

Copied to clipboard

This example uses C# and the Template Extraction library. It classifies a scanned ACORD 25 against your templates, extracts the fields the matched template defines, and writes each named field with its confidence score as JSON. The Template Extraction samples include a Java version.

// Classify a scanned ACORD 25, extract its template fields, and write each field as JSON

using System.Text.Json;

using Apryse.TemplateExtraction;

string templatesFolder = "./templates";

string inputFile = "./acord25_scan.tif";

// Template Extraction takes a two-entry license array. Fill both entries from your trial license.

string[] license = ["YOUR_LICENSE_ENTRY_1", "YOUR_LICENSE_ENTRY_2"];

using TemplatesCollection templates = new TemplatesCollection.Builder()
    .FromSourceFolder(templatesFolder)
    .Build();

using TemplateClassifier classifier = new TemplateClassifier.Builder()
    .SetTemplatesSource(templates)
    .SetRuntimeFolder("./runtimes")
    .SetLicense(license)
    .Build();

using TemplateExtractor extractor = new TemplateExtractor.Builder()
    .SetTemplatesSource(templates)
    .SetRuntimeFolder("./runtimes")
    .SetLicense(license)
    .Build();

using FileStream fileStream = new FileStream(inputFile, FileMode.Open, FileAccess.Read, FileShare.Read);

InputStream inputStream = new InputStream(fileStream);

Result<ClassifyResult> classifyResult = classifier.Classify(inputStream);

Result<ExtractResult> extractResult = extractor.Extract(inputStream);

var fields = new List<object>();

foreach (ExtractedPage page in extractResult.Value.Pages)
{
    foreach (ExtractedText field in page.Fields)
    {
        fields.Add(new { field = field.Id, value = field.Text, confidence = Math.Round(field.Confidence, 2) });
    }
}

var output = new { template = classifyResult.Value.ClassName, fields };

Console.WriteLine(JsonSerializer.Serialize(output, new JsonSerializerOptions { WriteIndented = true }));

The field names come from your template, and the values below are illustrative:

{
  "template": "ACORD25",
  "fields": [
    { "field": "insured_name", "value": "Northwind Traders LLC", "confidence": 0.97 },
    { "field": "policy_number", "value": "GL-4471902", "confidence": 0.95 },
    { "field": "policy_effective_date", "value": "09/01/2026", "confidence": 0.93 }
  ]
}

Claims Packets and First Notice of Loss

Copied to clipboard

A claims packet takes three steps in your code: classify, split, extract. Classification assigns each page one of 24 fixed categories with a confidence score. Your code groups consecutive pages by category, then splits the file with the Server SDK page manipulation API. Extraction then runs on each resulting document.

Document classification works at page level, which fits packets that mix document types. The category set is fixed. Check the classification docs for the list before you map categories to your packet's document types.

Claim documents with no consistent layout go to key-value extraction. It identifies label and value pairs with no template setup, such as a policy number beside its value. Each pair returns a confidence score, and every result carries page numbers and bounding boxes.

Flat PDFs with printed fields go through form field identification. It detects visual fields and returns them as JSON or as fillable PDF fields, each with a confidence score.

A confidence score is a measure per result, not a verdict. Your code sets the threshold and decides what happens below it.

Worked Example 2: A Claim Field with Its Confidence Score

Copied to clipboard

This example uses C# on Windows or Linux x64. It needs the Smart Data Extraction add-on module, a separate download from the base Apryse Server SDK. See the modules documentation for download and installation. The code extracts key-value pairs from a claim packet and keeps the pairs at or above a confidence threshold that you set.

// Extract key-value pairs from a claim packet and keep pairs at or above your confidence threshold

using System.Linq;
using System.Text.Json;
using pdftron;
using pdftron.PDF;

const double minimumConfidence = 0.80;

// Initialize PDFNet before any extraction call
PDFNet.Initialize(Environment.GetEnvironmentVariable("APRYSE_LICENSE_KEY"));

try
{
    // Point the SDK at the folder that holds the module's Lib directory
    PDFNet.AddResourceSearchPath("./Lib/");

    if (!DataExtractionModule.IsModuleAvailable(DataExtractionModule.DataExtractionEngine.e_generic_key_value))
    {
        Console.WriteLine("Smart Data Extraction module not available.");
        return;
    }

    string json = DataExtractionModule.ExtractData("claim_packet.pdf", DataExtractionModule.DataExtractionEngine.e_generic_key_value);

    using JsonDocument document = JsonDocument.Parse(json);

    var claimFields = new List<object>();

    foreach (JsonElement page in document.RootElement.GetProperty("pages").EnumerateArray())
    {
        int pageNumber = page.GetProperty("properties").GetProperty("pageNumber").GetInt32();

        foreach (JsonElement pair in page.GetProperty("keyValueElements").EnumerateArray())
        {
            double confidence = pair.GetProperty("confidence").GetDouble();

            if (confidence < minimumConfidence) continue;

            claimFields.Add(new
            {
                page = pageNumber,
                key = JoinWords(pair.GetProperty("key")),
                value = JoinWords(pair),
                confidence = Math.Round(confidence, 2)
            });
        }
    }

    Console.WriteLine(JsonSerializer.Serialize(claimFields, new JsonSerializerOptions { WriteIndented = true }));
}
finally
{
    PDFNet.Terminate();
}

// Join the words of a key or a value into one string
static string JoinWords(JsonElement element) =>
    element.TryGetProperty("words", out JsonElement words)
        ? string.Join(" ", words.EnumerateArray().Select(w => w.GetProperty("content").GetString()))
        : string.Empty;

The Smart Data Extraction output reports each pair's page, bounding box, and a confidence between 0.0 and 1.0. The code above reduces it to the claim fields your application stores. The values below are illustrative:

[
  { "page": 1, "key": "Policy Number", "value": "GL-4471902", "confidence": 0.96 },
  { "page": 1, "key": "Date of Loss", "value": "09/14/2026", "confidence": 0.93 },
  { "page": 1, "key": "Claimant Name", "value": "Dana Whitfield", "confidence": 0.89 }
]

Policy Documents and Loss Runs

Copied to clipboard

Policy documents are long and structured: declarations, coverage forms, endorsements. Document structure recognition parses headers, footers, lists, images, paragraphs, and styling into JSON with page numbers and bounding boxes. Markdown output keeps heading levels, lists, and tables for retrieval pipelines over policy wording.

Loss runs and schedules arrive as tables. Table extraction recovers rows, columns, and table structure, including merged cells, multi-row headers, nested tables, and tables that continue across pages. It works on PDF and scanned documents and exports to JSON or Excel.

Table results do not include a confidence score. Validate them in your own code, for example by checking that loss run line items sum to the stated total.

Loss Run Tables as JSON

Copied to clipboard

Each table cell in the JSON reports its zero-based row and column start, optional row and column spans, and a bounding box. Header cells and data cells carry different types, so your code can tell a column label from a loss run line. The table extraction guide documents the call, and the table JSON specification documents the cell structure.

Reading Barcodes and Claim Fields from the Same Document

Copied to clipboard

Claims cover sheets often carry a barcode that identifies the claim or policy. The Barcode Module detects barcodes in PDF documents, returns each barcode's location and bounding box, and decodes its content. It reads over 100 barcode types, including QR, DataMatrix, PDF417, Code 128, GS1-128, USPS 4-State, and Royal Mail 4-State. Extraction profiles tune the read for low-quality scans, small barcodes, and skewed barcodes. Read barcode extraction for the capability. The module is a separate add-on for the Apryse Server SDK and requires its own add-on license.

Reading barcodes through a device camera is a Scanbot SDK use case, not a Barcode Module use case. The BarcodeTest sample ships in the main SDK download, and the barcode guide documents the call.

Worked Example 3: A Barcode and Claim Fields from the Same PDF

Copied to clipboard

This example uses C# on Windows or Linux x64. It needs the Smart Data Extraction add-on module and the Barcode Module, each a separate download from the base Apryse Server SDK. The code runs both modules on one PDF and returns a single record: the decoded barcode and the claim fields.

Both modules report positions in the same coordinate system, with the same origin, units, and page reference. Your code can compare a barcode's position with a field's position and match them without converting coordinates.

// Read the cover-sheet barcode and the claim fields from the same PDF, then write one JSON record

using System.Linq;
using System.Text.Json;
using pdftron;
using pdftron.PDF;

const double minimumConfidence = 0.80;

string packetPath = "claim_packet.pdf";

string barcodePath = "claim_packet_barcodes.json";

// Initialize PDFNet before any module call
PDFNet.Initialize(Environment.GetEnvironmentVariable("APRYSE_LICENSE_KEY"));

try
{
    // Point the SDK at the folder that holds the modules' Lib directory
    PDFNet.AddResourceSearchPath("./Lib/");

    if (!BarcodeModule.IsModuleAvailable() ||
        !DataExtractionModule.IsModuleAvailable(DataExtractionModule.DataExtractionEngine.e_generic_key_value))
    {
        Console.WriteLine("Barcode Module or Smart Data Extraction module not available.");
        return;
    }

    // Barcode Module: write the detected barcodes to a JSON file
    BarcodeModule.ExtractBarcodes(packetPath, barcodePath);

    using JsonDocument barcodeDocument = JsonDocument.Parse(File.ReadAllText(barcodePath));

    var barcodes = new List<object>();

    foreach (JsonElement barcode in barcodeDocument.RootElement.EnumerateArray())
    {
        // Decoded barcodes use the text field. Barcodes that cannot be decoded use Base64 in the data field.
        string? text = barcode.TryGetProperty("text", out JsonElement value) ? value.GetString() : null;

        barcodes.Add(new { text });
    }

    // Smart Data Extraction: key-value pairs from the same PDF
    string json = DataExtractionModule.ExtractData(packetPath, DataExtractionModule.DataExtractionEngine.e_generic_key_value);

    using JsonDocument fieldDocument = JsonDocument.Parse(json);

    var claimFields = new List<object>();

    foreach (JsonElement page in fieldDocument.RootElement.GetProperty("pages").EnumerateArray())
    {
        int pageNumber = page.GetProperty("properties").GetProperty("pageNumber").GetInt32();

        foreach (JsonElement pair in page.GetProperty("keyValueElements").EnumerateArray())
        {
            double confidence = pair.GetProperty("confidence").GetDouble();

            if (confidence < minimumConfidence) continue;

            claimFields.Add(new { page = pageNumber, key = JoinWords(pair.GetProperty("key")), value = JoinWords(pair), confidence = Math.Round(confidence, 2) });
        }
    }

    var record = new { document = packetPath, barcodes, claimFields };

    Console.WriteLine(JsonSerializer.Serialize(record, new JsonSerializerOptions { WriteIndented = true }));
}
finally
{
    PDFNet.Terminate();
}

// Join the words of a key or a value into one string
static string JoinWords(JsonElement element) =>
    element.TryGetProperty("words", out JsonElement words)
        ? string.Join(" ", words.EnumerateArray().Select(w => w.GetProperty("content").GetString()))
        : string.Empty;

The record joins the decoded barcode to the claim fields from the same document. The values below are illustrative:

{
  "document": "claim_packet.pdf",
  "barcodes": [
    { "text": "CLM-2026-0048213" }
  ],
  "claimFields": [
    { "page": 1, "key": "Policy Number", "value": "GL-4471902", "confidence": 0.96 },
    { "page": 1, "key": "Date of Loss", "value": "09/14/2026", "confidence": 0.93 }
  ]
}

Structured Output into a Claims or Policy Admin System

Copied to clipboard

Smart Data Extraction returns JSON with page numbers and bounding boxes, and exports tables to Excel. JSON is the hand-off point. Your application reads it, maps it to your claims or policy admin schema, and stores it. Bounding boxes let you draw each value's source location on the page for overlay or annotation.

Apryse supplies building blocks for your own intelligent document processing (IDP) workflow. It is not a turnkey IDP platform.

Getting Started

Install the Smart Data Extraction module for your language:

.NET: expand the module archive into the SDK Lib directory
Node.js: npm install @pdftron/data-extraction
Python, Windows and Linux: pip install --extra-index-url=https://pypi.apryse.com apryse-data-extraction
Java: add the DataExtractionModuleWindows or DataExtractionModuleLinux Maven dependency
C++: expand the module archive into the SDK directory
Template Extraction: .NET API reference and Java API reference

The DataExtractionTest sample ships in the main SDK download. Get your trial key at dev.apryse.com.

Getting Started

For the Technical Evaluator

Sizing a claims intake build comes down to three splits:

Deployment

You host the SDK on your own servers, VMs, or containers, and the support matrix states platforms and licensing.

Scope

The SDK reads documents and returns JSON, and it provides no work queue, job scheduler, or batch orchestration, so your application owns the loop over packets.

Ownership

Your application owns thresholds, review, storage, and the claims system, and Apryse owns the document layer.

Where Documents Are Processed

The Apryse Server SDK is a self-hosted library. It runs on your on-premises servers, in your private cloud, or in containers you manage, and it processes documents locally. Documents are not sent to Apryse or to a third-party service.

Extraction does not require an LLM. Passing results to one is a separate step that you choose to add. For a fully disconnected deployment, confirm activation requirements with Apryse during evaluation. By default the SDK sends limited usage metadata to Apryse: API call names and counts, page counts, SDK version, and SDK language. A no-tracking license key is available on request.

This page covers what you call and what comes back. The outcome, the document types in buyer language, and the compliance story for insurance document workflows live on the industry page.

Frequently Asked Questions

Any fixed-layout ACORD form you can define as a template, including ACORD 25, 125, 126, 130, 140, and loss notices ACORD 1 through 4. You build one template per form edition in the Template Designer. Template Extraction then classifies each scan against your templates before it extracts the fields.

Fixed-layout ACORD forms use a template, which you define once in the Template Designer. Claims packets and other varied-layout documents do not. Key-value extraction identifies label and value pairs with no template setup and returns a confidence score for each pair.

Your code splits it, using page categories from Smart Data Extraction. Document classification assigns each page one of 24 fixed categories with a confidence score. Your code groups consecutive pages by category and splits the PDF with the Server SDK page manipulation API.

Yes, as two operations on the same PDF. Both modules report positions in the same coordinate system, so your code can match a barcode to the fields near it without converting coordinates. The Barcode Module decodes the barcodes and returns their locations, and Smart Data Extraction returns the claim fields. The Barcode Module is a separate add-on that requires its own add-on license.

No. Smart Data Extraction, the Barcode Module, the OCR and Handwriting ICR Modules, and Template Extraction run inside infrastructure you control. The Apryse Server SDK transmits no document content to Apryse. By default it sends limited usage metadata, and a no-tracking license key is available on request.

Run Extraction on Your Own Insurance Documents

Get a trial key and run the Smart Data Extraction samples on your own packets and forms.

Insurance Document and ACORD Form Data Extraction

Support Matrix

ACORD Forms

The ACORD Forms List

The ACORD Data Model

Worked Example 1: Named ACORD Fields

Claims Packets and First Notice of Loss

Worked Example 2: A Claim Field with Its Confidence Score

Policy Documents and Loss Runs

Loss Run Tables as JSON

Reading Barcodes and Claim Fields from the Same Document

Worked Example 3: A Barcode and Claim Fields from the Same PDF

Structured Output into a Claims or Policy Admin System

Getting Started

For the Technical Evaluator

Deployment

Scope

Ownership

Frequently Asked Questions

Which ACORD Forms Can Be Extracted?

Does ACORD Extraction Need a Template?

How Is a Mixed Claims Packet Split into Documents?

Can a Barcode and the Claim Fields Be Read from the Same File?

Does Any Step Send Documents Outside Our Network?

Run Extraction on Your Own Insurance Documents