← Agent Frameworks 🕐 18 min read

Agent Frameworks

Bedrock Data Automation Cost Patterns — Document Intelligence Pipelines (2026)

Executive Summary · March 2026

Amazon Bedrock Data Automation (BDA), generally available since March 2025, is AWS's managed multimodal document intelligence service.

Amazon Bedrock Data Automation (BDA), generally available since March 2025, is AWS’s managed multimodal document intelligence service. It replaces the common DIY pattern of Textract OCR + Claude prompt chaining with a single API that handles classification, extraction, normalization, and structured output. The flat per-page pricing model ($0.010/page standard, $0.040/page custom) trades volume discounts for operational simplicity. Enterprise buyers running more than 50,000 pages/month of standardized documents should model a hybrid routing architecture before committing — BDA is not always the cheapest path, but it is nearly always the fastest path to production.

1. Bedrock Data Automation Pricing — Current Rate Card (us-east-1, us-west-2)

BDA prices by content unit, not by model token. As of mid-2026:

Documents and Images

Content Type	Standard Output	Custom Output (≤30 fields)	Custom Output per additional field above 30
Document (per page)	$0.0100	$0.0400	+$0.0005/field/page
Image (per image)	$0.0050	$0.0050	same incremental

Media

Content Type	Standard Output
Audio	$0.006 per minute
Video	$0.050 per minute

Blueprint Complexity Surcharge Example

A custom blueprint with 40 defined fields processes a 10-page PDF:

Base custom rate: 10 pages × $0.040 = $0.40
Surcharge for 10 extra fields: 10 pages × 10 fields × $0.0005 = $0.05
Total: $0.45 per document

This surcharge matters for complex contracts or medical records where schemas routinely exceed 30 fields. Keep blueprints at 30 fields or below where possible, splitting complex schemas across multiple blueprint invocations only if the document warrants it.

What Is Included in the Per-Page Rate

The BDA per-page charge covers:

Automatic document classification (multi-document PDFs split at logical boundaries)
OCR and text extraction
Table and figure detection
Entity normalization and transformation
Structured JSON output
Confidence scores per extracted field
S3 output delivery

What is not included:

S3 storage for input and output buckets (standard S3 rates apply)
Lambda or Step Functions invocations in the surrounding orchestration layer
CloudWatch logging costs
Any downstream Bedrock inference calls (retrieval, generation) if the output feeds a RAG pipeline
Knowledge Base vector storage if BDA feeds a Bedrock KB

Regional Availability Constraint

As of June 2026, BDA is available in us-east-1 and us-west-2 only. Workloads in EU or APAC regions must either transfer data cross-region (adding latency and data transfer cost) or defer BDA adoption. Data transfer from us-east-1 to eu-west-1 runs approximately $0.02/GB — negligible for text-heavy PDFs but worth modeling for image-dense or high-volume pipelines.

2. Comparison to DIY: Textract + Claude vs. BDA

The canonical alternative to BDA is a two-stage pipeline: Amazon Textract for OCR, then a Bedrock FM call (Claude Sonnet or Haiku) for semantic extraction. The cost math depends heavily on document type and volume tier.

Textract Rate Card (us-east-1)

Textract API	Cost per 1,000 pages
DetectDocumentText (basic OCR)	$1.50
AnalyzeDocument (forms + tables)	$15.00
AnalyzeExpense (invoices)	$10.00
AnalyzeID (identity docs)	$25.00
Volume discount (>1M pages/month)	~40% reduction

Concrete Cost Model — 100 Documents, Mixed Types

AWS blog benchmarks (June 2025, 100 documents, us-east-1):

Pipeline	100 × 20-page financial docs	100 × 1-page emails
BDA (standard output)	$20.11	$1.11
Bedrock FM direct (Claude Sonnet, image-converted pages)	$1.90	$0.20
Textract AnalyzeDocument + Claude Sonnet	$31.36	$1.67

Key observations:

BDA at standard output is 6–7× cheaper than Textract + FM for multi-page financial documents. The Textract AnalyzeDocument API at $15/1,000 pages dominates the DIY cost for structured extraction.
Bedrock FM direct (converting PDF pages to images and passing them to a multimodal model) is the cheapest option at scale but carries the highest operational burden: no built-in classification, no confidence scores, manual prompt engineering, manual output validation.
For single-page, high-volume, standardized documents (email receipts, W-2s, driver’s licenses), BDA at $0.010/page and Textract AnalyzeID at $0.025/page cross at low volumes — Textract wins above ~50,000 pages/month with volume discounts applied.

Decision Matrix

Scenario	Recommended Path
Variable layouts, mixed document types, <50K pages/month	BDA standard output
Complex semantic extraction, 30+ fields, custom reasoning	BDA custom output with optimized blueprint
High-volume standardized forms (W-2, receipts, consistent invoices), >50K pages/month	Textract specialized API + volume discount
Research/exploration, minimal infra, cost is paramount	Bedrock FM direct (Claude Sonnet multimodal)
Compliance-grade deterministic extraction, audit trail required	Textract (deterministic) + BDA for exceptions
Mixed incoming document portfolio with unpredictable formats	Hybrid: lightweight routing call → Textract or BDA

Hybrid Routing Architecture

A routing layer adds negligible cost (a Claude Haiku classification call costs ~$0.00025 per document) while enabling per-document service selection. The Gallitelli hybrid analysis shows a 54% cost reduction vs. all-BDA for a portfolio where 60% of documents are standardized forms:

All-BDA: $4,000/month at 400,000 pages
Hybrid (standardized → Textract, variable → BDA): $1,825/month

The routing call itself costs ~$25/month at that volume — well within the savings margin.

3. Use Cases — Which Document Types Justify the BDA Premium

BDA’s value proposition is highest where document layouts vary unpredictably and where building and maintaining Textract + prompt chains would require ongoing prompt engineering overhead.

High-ROI Document Types for BDA

Medical Records and Clinical Documentation Variable layouts across providers, structured and unstructured sections, embedded lab tables, physician notes. BDA’s multimodal parsing handles mixed text/image content. At $0.010/page standard, a 25-page hospital discharge summary costs $0.25 to parse — far below the cost of manual abstraction (~$15–40/document for offshore teams). Custom output blueprints for HL7 FHIR field mapping can exceed 30 fields; plan for the surcharge.

Contracts and Legal Agreements Clause extraction, party identification, obligation mapping, date extraction across 20–150 page documents. BDA classifies multi-document packages (e.g., a PDF containing MSA + SOW + exhibit) at ingest. Custom blueprints for contract analytics commonly run 35–50 fields — budget $0.050–$0.065/page at the surcharge tier. At 1,000 contracts/month averaging 40 pages, this is $2,000–$2,600/month vs. an estimated $4,000–6,000/month for a human review team to handle misclassified documents.

Financial Statements and SEC Filings Annual reports, 10-Ks, earnings supplements with embedded charts, footnotes, and XBRL references. BDA’s table extraction handles multi-column layouts that defeat simple OCR. Standard output at $0.010/page for a 120-page 10-K = $1.20/filing. At 500 filings/month, total BDA cost is $600 — a rounding error vs. analyst time.

Insurance Claims and Benefits Processing EOB documents, HCFA forms, UB-04 forms. Mixed structured and handwritten fields. AWS has published a sample accelerator for benefits claims processing using BDA. Catalog blueprints cover common insurance form types — no custom schema needed, keeping costs at $0.010/page.

Invoice and AP Processing For standardized invoices from a known supplier base (consistent layout), Textract AnalyzeExpense at $0.010/page is cost-equivalent to BDA standard, with higher determinism. For multi-supplier AP with variable layouts, BDA wins on maintenance cost: no per-supplier prompt tuning required.

Lower-ROI Scenarios

Plain text documents (emails, meeting notes, markdown): The default Bedrock Knowledge Base parser handles these at zero incremental cost. Routing plain text through BDA wastes $0.010/page.
Highly standardized government forms (I-9, W-4, tax forms with fixed field positions): Textract AnalyzeDocument with a field mapping layer is cheaper and more deterministic.
Image-only scans at high volume: At $0.005/image, BDA is competitive, but a Textract DetectDocumentText call at $0.0015/page is 3× cheaper for pure OCR needs.

4. Batch Processing Economics

BDA Batch API

BDA exposes an asynchronous InvokeDataAutomationAsync API, not a traditional batch submission endpoint like Bedrock Batch Inference. Key operational characteristics:

Jobs are submitted per-document; parallelism is achieved at the orchestration layer (Step Functions Map State, Lambda concurrency, or SQS-driven workers)
No native multi-document batch manifest file (unlike Bedrock Batch Inference which accepts JSONL files)
Results are written to S3 on completion; the caller polls GetDataAutomationStatus or uses EventBridge to receive completion events
Maximum document size: 20 pages for custom attribute extraction (as of June 2025); standard output supports longer documents
Supported formats: PDF, JPG, PNG, TIFF, DOC, DOCX, audio (MP3, WAV), video (MP4)

Bedrock Batch Inference vs. BDA Async

Bedrock Batch Inference (the 50% discount tier) applies to model inference jobs — submitting prompt-response pairs to Claude or other foundation models via JSONL batches. It does not apply to BDA document processing jobs. These are separate billing lines in CUR.

If using Bedrock FM direct (converting PDFs to images and passing them to Claude via Bedrock Batch Inference), the 50% batch discount applies to the Claude token charges. This is worth modeling for high-volume workloads where turnaround time >24 hours is acceptable.

Throughput Limits and Scaling

BDA concurrent job limits are governed by service quotas (requestable via AWS Support). Default quotas as of 2026:

Concurrent asynchronous jobs: varies by account tier (start at 10–50 concurrent, raiseable)
Step Functions Map State with MaxConcurrency set to match your BDA quota prevents throttling and the associated retry cost

A Lambda-based polling pattern with 10-second intervals works at low volume (<100 docs/day). At 10,000+ docs/day, use EventBridge or S3 event notifications on the output bucket prefix to eliminate polling Lambda invocations.

5. CUR Appearance — BDA vs. Bedrock Inference Charges

Product Codes

In AWS Cost and Usage Report 2.0 (CUR 2.0), BDA charges appear under a distinct product code separate from Bedrock model inference:

Bedrock model inference: AmazonBedrock, with usage types following {region}-{model}-{input|output}-tokens
BDA document processing: charges appear under the Bedrock product but with usage types scoped to data automation operations (not token-based usage types)

Usage Type Patterns

BDA processing line items use unit-based (per-page, per-image, per-minute) usage types rather than the *-input-tokens / *-output-tokens pattern. This is the primary distinguishing signal in CUR:

Signal	BDA Line Item	Bedrock Inference Line Item
Unit	Pages, Images, Minutes	Tokens
Usage type suffix	`-pages`, `-images`, `-minutes` (regional prefix)	`-input-tokens`, `-output-tokens`
Operation	DataAutomation	InvokeModel / InvokeModelWithResponseStream
Pricing structure	Flat per unit	Per-token (varies by model)

Cost Attribution Best Practices

Tag IAM roles used by BDA-invoking Lambda functions with team, project, and document-type cost allocation tags. With CUR 2.0 IAM principal attribution (GA April 2026), these tags propagate to BDA line items without custom instrumentation.
Use separate IAM execution roles per document pipeline (invoices vs. contracts vs. medical records) to split BDA costs by use case in Cost Explorer without custom tagging logic.
Enable model invocation logging for any Bedrock FM calls in the same pipeline — log data carries per-request detail that CUR aggregates away. Join log requestId to CUR at the model/usage-type grain for full per-document attribution.

Common Reconciliation Gaps

If your CUR BDA costs don’t match your expected page count × $0.010:

Check for custom output blueprint invocations — they bill at $0.040/page
Check for blueprint field surcharges if any blueprints exceed 30 fields
Check for Knowledge Base sync runs — BDA-as-parser charges accumulate on each sync, including re-syncs of unchanged files if the data source metadata has changed
Separate the Lambda/Step Functions/S3 line items from the BDA line items — they appear in different product codes

6. Custom Output Schema Cost Implications

Schema Complexity → Output Token Volume

BDA custom output schemas (blueprints) define a JSON extraction target. More fields mean more structured output generated per document, which drives the higher $0.040/page rate and the field surcharge above 30. The surcharge is per-field-per-page, so a 50-field blueprint on a 100-page contract costs:

Base: 100 × $0.040 = $4.00
Surcharge (20 extra fields): 100 × 20 × $0.0005 = $1.00
Total: $5.00 per contract

Blueprint Design Optimization Patterns

Group fields into parent objects rather than flat lists. BDA counts top-level fields for the surcharge threshold. Nested objects with sub-fields may count as a single field depending on schema interpretation — verify against the AWS pricing FAQ for your schema design.

Split document types into separate blueprints. Rather than one 60-field universal contract blueprint, use a 25-field MSA blueprint and a 20-field SOW blueprint routed by BDA’s automatic document classification. Both stay under the 30-field threshold.

Use standard output as a pre-filter. Run standard output first ($0.010/page) to extract full text and document type. Invoke custom output ($0.040/page) only on pages that contain the target sections (e.g., signature blocks, financial schedules). BDA does not currently support page-range extraction natively — this requires splitting documents at the Lambda layer before BDA invocation.

Reduce field count via post-processing. Some derived fields (e.g., calculated totals, formatted date strings) can be computed cheaply in Lambda from raw extracted values rather than defined in the blueprint schema.

Confidence Score Economics

Every custom output field carries a confidence score (0–1.0). Routing low-confidence fields (<0.7 threshold is a common starting point) to human review via Amazon A2I prevents downstream data quality failures. The cost model:

BDA extraction: $0.040/page (paid regardless of confidence)
A2I human review: ~$0.012–$0.036/task (Amazon Mechanical Turk pricing)
Cost of not catching errors: depends on use case (AP mispostings, compliance failures)

At a 5% low-confidence rate on a 10,000-page/month pipeline, A2I adds ~$60–$180/month — negligible vs. the error correction cost in most enterprise contexts.

7. Storage Costs — S3 Input/Output Buckets

Baseline S3 Cost Model

BDA requires S3 input and output buckets. Storage is billed at standard S3 rates, not included in the BDA per-page charge.

Cost Component	Rate
S3 Standard storage	$0.023/GB-month
S3 PUT (input upload)	$0.005/1,000 requests
S3 GET (BDA reading input)	$0.0004/1,000 requests
S3 GET (caller reading output)	$0.0004/1,000 requests

For a 10,000-page/month pipeline processing 5 MB PDFs (average 0.5 MB/page compressed):

Input storage: 10,000 pages × 0.5 MB = 5 GB → $0.115/month
Output JSON (avg 50 KB/document, 100-page docs = 100 documents): 100 × 50 KB = 5 MB → negligible
S3 PUT requests: 100 × $0.005/1,000 = $0.0005/month

S3 storage is a rounding error vs. BDA processing cost at most enterprise scales. The exception: video processing. A 1-hour video at 4K resolution might be 50 GB — storing it for a month costs $1.15 vs. BDA video processing at $0.050/min × 60 min = $3.00. Lifecycle policies to delete or transition inputs to S3 Intelligent-Tiering after processing are worth implementing.

Data Lifecycle Recommendations

Input bucket: S3 lifecycle rule to expire raw documents after 30 days (or immediately after BDA job completion if the source system retains originals)
Output bucket: Structured JSON output is small — retain indefinitely or until the downstream data store confirms ingest
Prefix structure: Organize by {pipeline}/{date}/{document-id}/ to simplify per-pipeline cost tagging via S3 Storage Lens and to enable targeted lifecycle policies per document type

8. Error Handling Cost — Avoiding Payment for Bad Extractions

BDA Job Status Model

BDA async jobs return one of three terminal states:

Success — processing completed, output written to S3
ServiceError — AWS-side failure (not billed per AWS convention for service errors)
ClientError — invalid input (malformed PDF, unsupported format, document too large) — billing behavior: test with AWS Support to confirm, but ClientErrors are typically not charged

Cost-Avoidance Patterns

Pre-validation before BDA invocation. Run a lightweight Lambda check before submitting to BDA:

Verify PDF is not password-protected (opens with PyPDF2 without decryption — encrypted PDFs fail as ClientError)
Check page count against the 20-page limit for custom extraction (split at the Lambda layer)
Validate file format (reject non-PDF/image formats before they reach BDA)
Check minimum file size (0-byte files are malformed)

Pre-validation adds ~50ms and ~$0.000002 Lambda cost per document — pays for itself by preventing ClientError submissions that waste API round-trips and potentially incur charges.

Quality threshold gating. After BDA extraction, evaluate aggregate confidence across required fields before writing results downstream. If required fields fall below threshold (e.g., <0.6 confidence on critical financial figures), route to human review or re-submission with a modified prompt rather than silently accepting low-quality output.

Retry with backoff, not retry with fresh submission. If a BDA job returns ServiceError, poll the original job ID before creating a new submission — AWS may retry internally. Submitting duplicate jobs for a transient ServiceError doubles processing cost.

Page-range splitting for oversized documents. Documents >20 pages for custom extraction should be split into 20-page chunks before BDA invocation. A 60-page contract requires 3 BDA invocations at $0.040/page = $2.40 total. This is the same cost as a single 60-page invocation if pricing were linear, but page-range splitting at the Lambda layer is the only path through the 20-page limit for custom output.

9. Integration with Bedrock Knowledge Bases — Combined Pipeline TCO

BDA as KB Ingestion Parser

When Bedrock Knowledge Bases is configured with BDA as the parsing layer, BDA parses all PDF files in the data source during each sync, regardless of whether the document has changed since the last sync. The Knowledge Base native default parser handles plain text files at zero incremental cost.

Cost trigger: Every StartIngestionJob call re-processes all PDFs in the data source that have been modified or are new. Unmodified PDFs are not re-parsed if the data source metadata indicates no change — verify this behavior with your specific connector type.

Knowledge Base Combined TCO — 1,000-Document Corpus, Monthly Sync

Assumptions: 1,000 PDFs, average 10 pages each, 10% modified per month:

Component	Calculation	Monthly Cost
BDA initial ingest (10,000 pages)	10,000 × $0.010	$100.00 (one-time)
BDA re-parse (1,000 modified pages/month)	1,000 × $0.010	$10.00
Titan Embeddings (10,000 pages × ~1,500 tokens/page)	15M tokens × $0.0001/1K	$1.50 (initial)
OpenSearch Serverless vector storage	varies by ACU	~$50–$200/month
KB retrieval (1,000 queries/day × $0.0001)	30,000 × $0.0001	$3.00

BDA parsing cost is modest relative to vector storage for knowledge base workloads. The OpenSearch Serverless minimum charge (0.5 ACU indexing + 0.5 ACU search × $0.24/ACU-hour) runs ~$175/month regardless of document count.

Parser Selection Decision

Choose BDA as KB parser when:

Documents contain tables, charts, figures, or images that need to be queryable
Per-page cost ($0.010) is acceptable relative to the quality uplift over the default text parser

Choose foundation model parser (Claude Haiku as parser) when:

You need to customize the parsing prompt (e.g., inject domain context)
Documents are structured but contain specialized terminology requiring contextual interpretation
Cost is less important than extraction precision on a small corpus

Choose default parser (free) when:

Documents are plain text, markdown, HTML, or Word documents with no embedded visuals
Budget constraints are tight and visual content is absent

10. Re-Processing Costs — Partial vs. Full Re-Run Economics

When Re-Processing Is Triggered

BDA itself is stateless — it processes what it receives. Re-processing cost is governed by the upstream orchestration layer:

Schema changes: If you modify a custom blueprint (add/remove fields), all previously processed documents must be re-run through BDA to get output conforming to the new schema. At 10,000 pages with a schema change every quarter, this is $400/quarter in re-processing cost — budget for it explicitly.
Quality remediation: If a batch of documents was processed with incorrect blueprint assignment (wrong document type classified), targeted re-processing by document ID is cheaper than full corpus re-run. Build document ID → BDA job ID tracking in DynamoDB or RDS to enable surgical re-runs.
Knowledge Base re-sync: Full data source re-sync re-parses all documents regardless of change status (depends on connector behavior). For S3 connectors, KB tracks ETag/LastModified to skip unchanged files — enabling incremental sync reduces re-processing cost significantly vs. forcing full re-sync.
Source document updates: If the underlying PDF changes (e.g., contract amendment uploaded as a new version), BDA must re-process the new version. Version-controlled S3 prefixes (using S3 Object Versioning) allow rollback without re-processing the original if the amendment is rejected.

Cost Comparison: Partial vs. Full Re-Run

For a 100,000-page corpus where 5% of documents need re-processing:

Approach	Pages Processed	Cost
Full corpus re-run	100,000 pages	$1,000
Targeted partial re-run	5,000 pages	$50
Savings from partial re-run		$950 (95%)

Partial re-run requires upstream metadata tracking (document ID → last-processed timestamp → last blueprint version). This metadata infrastructure is worth building for any corpus above ~10,000 documents.

Change Detection Pattern

Implement an S3-backed manifest (or DynamoDB table) with:

Document S3 URI
ETag/MD5 at last BDA invocation
Blueprint version at last BDA invocation
Last processed timestamp

On each pipeline run, diff incoming document ETags against the manifest. Re-submit only documents where ETag or blueprint version has changed. This pattern cuts re-processing cost by 80–95% in mature pipelines where most documents are stable.

11. Cost Benchmarks — Enterprise Pipeline Scenarios

Scenario A: Mid-Market AP Automation (5,000 Invoices/Month)

Document profile: 80% standardized supplier invoices (2–3 pages), 20% complex purchase orders (8–10 pages)
Routing: standardized → Textract AnalyzeExpense ($0.010/page), complex → BDA standard output ($0.010/page)
Monthly volume: 4,000 invoices × 2.5 pages × $0.010 (Textract) + 1,000 invoices × 9 pages × $0.010 (BDA)
BDA cost: $90/month; Textract cost: $100/month; Lambda + Step Functions: ~$20/month
Total: ~$210/month — vs. $350–700/month for a single offshore AP processor

Scenario B: Healthcare Records Abstraction (50,000 Pages/Month)

Document profile: discharge summaries, lab reports, imaging reports (variable layouts, 5–40 pages each)
Pipeline: BDA standard output for all records ($0.010/page), A2I human review for 3% low-confidence fields
BDA cost: 50,000 × $0.010 = $500/month
A2I cost: 1,500 tasks × $0.024/task = $36/month
S3 + Lambda orchestration: ~$30/month
Total: ~$566/month — vs. $8,000–15,000/month for equivalent human medical coders

Scenario C: Legal Contract Analytics (2,000 Contracts/Month)

Document profile: MSAs, SOWs, NDAs (20–80 pages, variable layouts), custom extraction schema 35 fields
Pipeline: BDA custom output, optimized to 30-field blueprint (2 blueprints to avoid surcharge), average 40 pages
BDA cost: 2,000 × 40 pages × $0.040 = $3,200/month (custom output, ≤30 fields per blueprint)
With 35-field single blueprint: $3,200 + (2,000 × 40 × 5 × $0.0005) = $3,200 + $200 = $3,400/month
Savings from blueprint split: $200/month — modest, but illustrates the 30-field optimization
Total: ~$3,200–3,400/month

12. Key Optimization Checklist

Optimization	Estimated Savings	Complexity
Hybrid routing (standardized docs → Textract)	40–54% on mixed portfolios	Medium
Blueprint field count ≤30 (split schemas)	5–15% on custom output	Low
Pre-validation Lambda (filter bad inputs)	Avoid wasted API calls	Low
Incremental KB sync (track ETags)	80–95% on re-processing	Medium
Separate IAM roles per pipeline (CUR attribution)	Visibility, not savings	Low
Plain text → default KB parser (not BDA)	$0.010/page on text-only files	Low
S3 lifecycle rules for input expiry	Storage cost (minor)	Low
EventBridge vs. polling Lambda	Lambda invocation cost	Medium
Document splitting for >20-page custom extraction	Enables feature, no direct savings	Medium
Batch Bedrock FM (50% discount) for non-realtime	50% on FM-direct pipelines	High