Azure AI Document Intelligence for .NET: Setup, Usage & Best Practices

Document processing is foundational to enterprise automation—invoices need routing, receipts require expense categorization, contracts demand field extraction. Azure AI Document Intelligence (formerly Form Recognizer) provides production-ready OCR and document understanding through prebuilt models for common document types and custom models for domain-specific forms.

For .NET developers building document workflows, this SDK delivers enterprise-grade extraction without requiring machine learning expertise or manual rule engineering.

What This Skill Does

The Document Intelligence SDK provides two client types serving different needs. DocumentIntelligenceClient handles document analysis—extracting text, tables, and structured fields from PDFs, images, and Office documents. DocumentIntelligenceAdministrationClient manages model lifecycle—building custom models from training data, composing models, and managing classifiers.

Prebuilt models cover common business documents without training. The invoice model extracts vendor details, line items, totals, and dates. The receipt model pulls merchant names, transaction amounts, and timestamps. ID document models parse passports and driver's licenses. Tax form models handle W-2s and other standardized forms. Each model understands document structure and semantic meaning, not just OCR text.

Custom model training handles domain-specific documents. Feed the SDK examples of your forms from Blob Storage, and it learns to extract your specific fields. Template mode works for fixed-layout documents like purchase orders. Neural mode handles variable-layout documents like contracts where field positions shift.

Document classification routes mixed document streams automatically. Train a classifier on different document types, then analyze unknown documents to determine their type before routing to appropriate processing pipelines.

Getting Started

Installation requires the Azure.AI.DocumentIntelligence and Azure.Identity packages via NuGet. The service has reached general availability, so you're using production-stable APIs, not previews.

You'll need a Document Intelligence resource from the Azure Portal. Critical: for Entra ID authentication (DefaultAzureCredential), your resource must have a custom subdomain, not a regional endpoint. Custom subdomains look like https://your-resource.cognitiveservices.azure.com/, not https://eastus.api.cognitive.microsoft.com/.

Client creation uses the standard Azure SDK builder pattern. For production, always use DefaultAzureCredential which discovers managed identities automatically. For quick prototyping, API keys work but lack the security and operational benefits of identity-based authentication.

The typical workflow starts with AnalyzeDocumentAsync, passing a model ID and document URI. The method returns an operation that you poll until complete. The result contains pages (text, tables, figures), documents (extracted fields), and metadata (language, confidence scores).

Key Features

Comprehensive Prebuilt Models: The SDK includes models optimized for specific document types. Invoice extraction goes beyond OCR—it understands vendor information versus customer information, distinguishes line item descriptions from quantities, and separates subtotals from totals. Receipt parsing handles varied receipt formats, extracting structured transaction data regardless of layout differences.

Custom Model Training: For domain-specific forms, training custom models requires just a Blob Storage container with 5-15 example documents and a SAS URL. The SDK handles feature extraction, model training, and versioning. Template mode provides fast, accurate extraction for fixed layouts. Neural mode handles documents where field positions vary—contracts, medical forms, or multi-page reports.

Document Classification: Multi-document workflows benefit from automatic classification. Train a classifier by providing examples of each document type you handle. The classifier routes incoming documents to appropriate models or business processes based on learned characteristics.

Comprehensive Field Types: Extracted fields have strongly-typed values. DocumentFieldType.String for text, DocumentFieldType.Date for dates (parsed and validated), DocumentFieldType.Currency for monetary amounts with currency symbols, DocumentFieldType.List for repeated items like invoice line items, and DocumentFieldType.Dictionary for nested structures.

Layout Extraction: Beyond fields, the SDK extracts document structure. Pages include lines and words with bounding polygons for precise location. Tables are recognized and parsed with row/column positions. Selection marks (checkboxes) are detected and evaluated. This structural understanding enables sophisticated downstream processing.

Usage Examples

Invoice analysis demonstrates typical patterns. Call AnalyzeDocumentAsync with the prebuilt-invoice model and document URL. The operation polls automatically when using WaitUntil.Completed. Results include documents with fields like VendorName, InvoiceTotal, and Items (a list). Check field types before accessing values to avoid type mismatches.

Layout extraction focuses on structure rather than semantic fields. The prebuilt-layout model returns pages, lines, words, tables, and selection marks without attempting field interpretation. This works well for reformatting documents, extracting tables for data analysis, or preprocessing before custom field extraction.

Custom model building starts with a Blob Storage container SAS URL. Specify DocumentBuildMode.Template for forms with consistent layouts or DocumentBuildMode.Neural for variable layouts. The SDK returns model details including field schema and confidence thresholds. Use your model ID in subsequent AnalyzeDocumentAsync calls just like prebuilt models.

Classifier training groups document types with distinct Blob Storage prefixes. Map type names to storage locations with example documents. The classifier learns visual and semantic characteristics distinguishing each type. Classify unknown documents with ClassifyDocumentAsync, which returns document type and confidence.

Best Practices

Use DefaultAzureCredential consistently across environments. It discovers credentials from managed identities in Azure, Azure CLI during development, and environment variables in containers. This eliminates credential management code and security risks from hardcoded keys.

Reuse client instances throughout your application. Clients are thread-safe and expensive to instantiate due to HTTP connection setup. Create them once during application startup and share across requests.

Handle long-running operations appropriately. Document analysis can take seconds for simple documents, minutes for complex multi-page forms. Structure your application to poll asynchronously rather than blocking request threads. Use WaitUntil.Completed for simplicity in background jobs, but consider custom polling with delays in user-facing applications.

Always check field confidence scores. Document Intelligence provides confidence for every extracted field. Set confidence thresholds appropriate for your use case—high thresholds for financial data requiring accuracy, lower thresholds for non-critical fields where false negatives cost more than false positives.

Version your custom models explicitly when training. Name models descriptively and maintain version history. This enables A/B testing new models before replacing production versions and provides rollback capability when model updates introduce regressions.

When to Use This Skill

This skill excels for any .NET application processing business documents—AP automation extracting invoice data, expense management parsing receipts, HR systems processing tax forms, or lending platforms analyzing financial statements.

Document digitization workflows leverage layout extraction to convert paper documents to searchable, structured formats. The comprehensive table extraction preserves data relationships, critical for compliance, archival, and data migration scenarios.

Multi-source document processing benefits from classification. When documents arrive via email, upload, or API from various sources in mixed formats, classification routes them appropriately before field extraction.

Custom forms with consistent structure but unavailable prebuilt models—internal forms, industry-specific documents, or regional variations—are prime candidates for custom model training.

When NOT to Use This Skill

For simple OCR without field extraction, specialized OCR libraries might be faster and cheaper. Document Intelligence adds most value when extracting structured data, not just text.

If you're not using .NET, the Python and Java SDKs provide equivalent functionality. Don't adopt .NET solely for this SDK.

Extremely high-volume batch processing (millions of documents daily) might require cost optimization strategies beyond the SDK's simple API. Consider batch service endpoints, request consolidation, or parallel processing architectures.

Real-time latency requirements under 100ms are challenging with network round trips to Azure. Local inference or edge processing might be necessary, though you'd sacrifice managed model updates and Azure's infrastructure scale.

Related Skills

• azure-ai-formrecognizer-java - Java equivalent for JVM environments
• azure-ai-contentunderstanding-py - Multimodal content extraction
• azure-ai-vision-imageanalysis-py - General image analysis

Source

This skill is maintained by Microsoft. View on GitHub