What Is Amazon Textract? Pricing per Page, Free Tier, Tables, Forms and Queries, Python Tutorial, Invoices and Alternatives

Amazon Textract is AWS's document AI service: it reads scanned and photographed documents (PDFs, TIFFs, JPEGs and PNGs) and returns not just the text, as basic OCR does, but the structure: tables with their rows and columns, form fields as key-value pairs ("Invoice number: 10442"), answers to questions you ask in plain English ("What is the due date?"), signatures, layout, and specialized fields from invoices, receipts, US IDs and mortgage documents. Prices are per page: $1.50 per 1,000 pages for plain text (Detect Document Text), $15 per 1,000 for tables, $15 for queries, $50 for forms, $65 for forms and tables together, $10 for invoices and receipts (Analyze Expense) and $25 for identity documents, with lower rates after the first million pages a month. New customers get a three-month free tier: 1,000 text pages and 100 pages of most analysis features a month. Use Detect Document Text when you only need the words, Analyze Document when you need tables, fields or answers, and Analyze Expense for invoices and receipts. Below: what Textract is and how it works, every API and price with worked examples, the free tier, a Python tutorial for text, tables, forms and queries, multi-page PDFs, invoices and IDs, adapters, accuracy and handwriting, limits and languages, Textract vs Rekognition, Comprehend, Bedrock Data Automation and free OCR, and error fixes.

Every month the furniture store received about 600 supplier invoices, most as PDFs by email and some as photos of paper, plus a few hundred delivery notes signed by customers on a clipboard. The bookkeeper typed the invoice number, date, supplier, total and every line item into the accounts system by hand, and spent the last three days of every month doing nothing else. Jake, watching her squint at a crumpled delivery note, asked whether there was software that could just read the paper. Ethan opened the Textract console and dropped in the crumpled note.

Automating paperwork on AWS? The cards below cover Bedrock Data Automation, free local OCR, Lambda, S3 access and billing alerts, the pieces you will most often combine with Textract.

What is Amazon Textract?

OCR (optical character recognition) turns a picture of text into text you can copy. It has existed for decades, and it is good at one thing: giving you every word on the page, in reading order. What it does not tell you is what those words mean: that "10442" is the invoice number, that "1,240.00" sits in the "Amount" column of the third row, or that the scribble in the box is a signature. Turning documents into data has always meant someone writing fragile templates per supplier, or a person retyping.

Amazon Textract is a machine learning service that reads documents the way a person does. Besides the words and lines, it returns:

• Tables, with rows, columns, merged cells, headers, titles and footers, ready to turn into a spreadsheet.
• Forms, as key-value pairs: "Name: Jane Smith", "Date of birth: 04/12/1988", including check boxes (selected or not).
• Queries: you ask questions in plain English ("What is the policy number?") and Textract returns the answer and where it found it.
• Layout: titles, headers, paragraphs, lists, page numbers and figures, in reading order, which is useful before sending text to a language model.
• Signatures: where on the page someone signed.
• Specialized documents: invoices and receipts (vendor, totals, line items), US passports and driver's licenses, and mortgage document packages.

It works with printed text in English, French, German, Italian, Portuguese and Spanish, and with handwriting in English, on scans, photos and PDFs, with no templates to build. You pay per page, there are no servers, and it scales from one page to millions.

Jake: "So it reads the paper and fills in the spreadsheet."

Ethan: "It reads the paper and tells you which words are the invoice number, which are the total, and which row each item is on. Filling in the spreadsheet is three lines of code."

How Amazon Textract works

1. A document arrives: an image or PDF uploaded to an S3 bucket, or a single image sent straight to the API as bytes.
2. Your code picks an API and features: plain text, or analysis with tables, forms, queries, layout or signatures, or the expense, ID or lending APIs.
3. Single pages run synchronously and answer in a few seconds; multi-page PDFs and TIFFs run asynchronously: you start a job, Textract notifies an SNS topic when it finishes, and you collect the results.
4. Textract returns Blocks: a JSON list of everything it found (pages, lines, words, tables, cells, key-value sets, query results, selection elements), each with a confidence score, a bounding box and links to related blocks.
5. Your code turns Blocks into data: rows for a database, a CSV, fields for an accounting system, or clean text for search and AI. AWS's open-source Textractor library does most of that conversion for you.
6. Low-confidence results go to a person for checking, so mistakes never flow silently into your books.

The confidence score (0 to 100) on every word, cell and field is what makes automation safe: you might accept invoice totals above 95, and send anything lower to the bookkeeper's review screen.

Textract APIs and features: which one to use

You need	API (sync / async)	Returns	Price per 1,000 pages (first 1M)
Just the text	DetectDocumentText / StartDocumentTextDetection	Lines and words with positions	$1.50
Tables	AnalyzeDocument (TABLES) / StartDocumentAnalysis	Rows, columns, cells, headers	$15
Form fields and check boxes	AnalyzeDocument (FORMS)	Key-value pairs, selection marks	$50
Specific answers	AnalyzeDocument (QUERIES)	The answer to each question you ask	$15
Reading order and structure	AnalyzeDocument (LAYOUT)	Titles, headers, paragraphs, lists, figures	$4 (included with Tables)
Where someone signed	AnalyzeDocument (SIGNATURES)	Signature locations	$3.50
Invoices and receipts	AnalyzeExpense / StartExpenseAnalysis	Vendor, dates, totals, tax, line items	$10
US passports and driver's licenses	AnalyzeID	Name, dates, document number, address	$25 (first 100,000)
Mortgage document packages	StartLendingAnalysis	Each page classified and its fields extracted	$70

You can combine features in one AnalyzeDocument call (for example FeatureTypes=["TABLES", "FORMS"]), and you pay the combined price for each page. Ask only for what you use: forms cost more than three times as much as tables, and many documents need only tables and a few queries.

Amazon Textract pricing

US East (N. Virginia) list prices in October 2026, per page, with a lower rate for every page above one million in a month:

Feature	First 1 million pages a month	Over 1 million
Detect Document Text	$0.0015 ($1.50 per 1,000)	$0.0006
Analyze Document: Tables	$0.015	$0.010
Analyze Document: Queries	$0.015	$0.010
Analyze Document: Tables + Queries	$0.020	$0.015
Analyze Document: Forms	$0.050	$0.040
Analyze Document: Forms + Queries	$0.055	$0.045
Analyze Document: Forms + Tables	$0.065	$0.050
Analyze Document: Forms + Tables + Queries	$0.070	$0.055
Analyze Document: Layout	$0.004	$0.003
Analyze Document: Signatures	$0.0035	$0.0014
Custom Queries (with an adapter)	$0.025	$0.015
Analyze Expense (invoices, receipts)	$0.010	$0.008
Analyze ID	$0.025 (first 100,000)	$0.010 (over 100,000)
Analyze Lending	$0.070	$0.055

• Billed per page: a 12-page PDF is 12 pages; a photo is one page; each ID image is one page.
• Synchronous and asynchronous calls cost the same; only the convenience differs.
• Combinations are priced as one bundle per page, not the sum of every feature (Forms + Tables + Queries is $0.07, not $0.08).
• Also on your bill: S3 storage for the documents and results, SNS notifications for async jobs, and Lambda or Step Functions if your pipeline runs there.

Is Amazon Textract free? The free tier

Textract's free tier is short: it lasts three months for new AWS customers, not twelve. Each month during those three months you get:

• Detect Document Text: 1,000 pages.
• Analyze Document: 100 pages each of Forms, Tables, Layout and Queries (and combinations with Queries); 1,000 pages of Signatures on their own. Custom Queries have no free pages.
• Analyze Expense: 100 pages. Analyze ID: 100 pages. Analyze Lending: 2,000 pages.

Accounts created from July 15, 2025 can also use the credit-based Free Tier (up to $200 of credits) on Textract. The console's Try Amazon Textract page processes your uploads with the same billing, so a dozen test documents cost nothing or a few cents.

Worked examples: what Textract really costs

Example 1: the store's supplier invoices. 600 invoices a month averaging 2 pages, through Analyze Expense: 1,200 x $0.01 = $12 a month. The bookkeeper's three days of typing became half a day of checking the low-confidence fields.

Example 2: signed delivery notes. 400 single-page notes a month, checking for a signature and reading the order number with a query: Signatures + Queries, billed as the two features (400 x $0.0035 + 400 x $0.015) = $7.40 a month.

Ethan: "Twelve dollars for the invoices, seven forty for the delivery notes."

Jake: "So under twenty dollars a month to give her three days back."

Example 3: digitizing an archive. 100,000 old letters and reports for full-text search, text only: 100,000 x $0.0015 = $150, one time. Adding Layout for clean reading order: another $400.

Example 4: insurance claim forms at scale. 2 million pages a month with forms and tables: 1,000,000 x $0.065 + 1,000,000 x $0.05 = $115,000 a month. Switching to tables plus five queries per page, if the claims team only needs those fields: 1,000,000 x $0.02 + 1,000,000 x $0.015 = $35,000, less than a third.

Example 5: identity checks. 50,000 US driver's license images a month with Analyze ID: 50,000 x $0.025 = $1,250 a month.

Example 6: a mortgage lender. 100,000 loan package pages a month through Analyze Lending: 100,000 x $0.07 = $7,000 a month, with each page classified (pay stub, bank statement, W-2) and its fields extracted.

Example 7: the expensive mistake. A pipeline that sends every page of every PDF to Forms + Tables + Queries "just in case", when only the first page holds the fields you need, pays $0.07 for pages that a $0.0015 text call (or no call at all) would have covered. Splitting the first page off, or using Layout to find the right page, is often the biggest saving in a Textract bill. Set a billing alert before you point a pipeline at a big archive.

Estimate your Textract bill

The AWS Pricing Calculator has a Textract section where you enter pages per month for each API and feature combination. For a quick estimate, multiply pages by the per-page price of the one combination you request for each document type, and add them up:

Monthly cost = (text pages x $0.0015) + (table pages x $0.015) + (form pages x $0.05) + (invoice pages x $0.01) + ...

Pages per month	Text only	Tables + Queries	Forms + Tables	Invoices (Expense)
1,000	$1.50	$20	$65	$10
10,000	$15	$200	$650	$100
100,000	$150	$2,000	$6,500	$1,000
2,000,000	$2,100	$35,000	$115,000	$18,000

The table shows why the feature choice matters more than the volume: the same 100,000 pages cost $150 or $6,500 depending on what you ask for. Most savings come from requesting fewer features, not from volume tiers.

Textract console, login and permissions

There is no separate Textract login: it is part of your AWS account. Sign in to the AWS Management Console, search for Textract, and the Try Amazon Textract page is ready. For code, give your role or user only the actions it calls (for example textract:AnalyzeExpense or textract:StartDocumentAnalysis and textract:GetDocumentAnalysis), plus s3:GetObject on the input bucket and s3:PutObject on the output prefix if you use OutputConfig. For asynchronous jobs with notifications, Textract also needs a role it can assume to publish to your SNS topic. On AWS compute, use an IAM role rather than access keys.

Two console features help beyond the demo page. Adapters has its own section where you upload sample documents, review Textract's pre-labeled answers and train an adapter without code. And the console's results download (CSV for tables and key-values, JSON for everything) is a quick way to hand a sample of extracted data to the finance or operations team, so they can confirm the fields are right before anyone writes a pipeline.

Try Textract in the console first

1. Sign in to the AWS console and open Amazon Textract, then choose Try Amazon Textract (Analyze Document).
2. Upload a document: a single image, or a PDF of a few pages.
3. Switch between the tabs: Raw text, Layout, Forms, Tables, Queries and Signatures, and watch the boxes appear on the page.
4. Under Queries, type a question such as "What is the invoice number?" and apply it.
5. Try the Analyze Expense and Analyze ID pages with an invoice or a sample ID.
6. Download the results as a ZIP with CSVs for tables and key-values, and the raw JSON, to see exactly what your code will receive.

Ten minutes in the console with your own worst documents (the crumpled, the faxed, the handwritten) tells you more about accuracy than any benchmark, and it shows which features you actually need before you pay for them at scale.

Amazon Textract tutorial: text, tables, forms and queries in Python

You need boto3 (pip install boto3), credentials with textract:DetectDocumentText and textract:AnalyzeDocument, and s3:GetObject on the bucket. The simplest call reads every line of a one-page document:

import boto3

textract = boto3.client("textract", region_name="us-east-1")
doc = {"S3Object": {"Bucket": "store-paperwork", "Name": "delivery-notes/dn-5521.jpg"}}

resp = textract.detect_document_text(Document=doc)
for block in resp["Blocks"]:
    if block["BlockType"] == "LINE":
        print(f'{block["Confidence"]:5.1f}  {block["Text"]}')

Tables, forms and queries in one call. Parsing the raw Blocks by hand means following Relationships from tables to cells to words. AWS's open-source Textractor library (pip install amazon-textract-textractor) does it for you:

from textractor import Textractor
from textractor.data.constants import TextractFeatures
from textractor.data.text_linearization_config import TextLinearizationConfig

extractor = Textractor(region_name="us-east-1")
document = extractor.analyze_document(
    file_source="s3://store-paperwork/invoices/acme-10442.pdf",
    features=[TextractFeatures.TABLES, TextractFeatures.FORMS, TextractFeatures.QUERIES],
    queries=["What is the invoice number?", "What is the invoice total?", "What is the due date?"],
)

for kv in document.key_values:                    # form fields
    print(kv.key, "->", kv.value)
for table in document.tables:                     # every table as a DataFrame or CSV
    table.to_pandas().to_csv("acme-10442-lines.csv", index=False)
for query in document.queries:                    # plain-English answers
    print(query.query, "->", query.result.answer if query.result else None)

print(document.get_text(TextLinearizationConfig()))  # clean reading-order text

Older tutorials use the amazon-textract-response-parser library (imported as trp) for the same job; it still works, but Textractor is its successor, calls Textract for you and adds exports to pandas, CSV, Markdown and linearized text.

That one call is billed as Forms + Tables + Queries ($0.07 per page). If the invoice fields are all you need, the queries alone ($0.015) or analyze_expense ($0.01) is cheaper. The same features from plain boto3 are analyze_document(Document=doc, FeatureTypes=["TABLES", "FORMS", "QUERIES"], QueriesConfig={"Queries": [{"Text": "What is the invoice total?", "Alias": "TOTAL"}]}); up to 15 queries per page synchronously and 30 asynchronously.

From the command line:

aws textract detect-document-text --region us-east-1 \
  --document '{"S3Object":{"Bucket":"store-paperwork","Name":"delivery-notes/dn-5521.jpg"}}'

aws textract analyze-document --region us-east-1 --feature-types TABLES \
  --document '{"S3Object":{"Bucket":"store-paperwork","Name":"price-lists/acme.png"}}'

Multi-page PDFs: asynchronous jobs

Synchronous calls accept one page: an image, or a PDF or TIFF of exactly one page, up to 10 MB. Anything longer goes through the asynchronous APIs, which read PDFs and TIFFs of up to 3,000 pages and 500 MB from S3:

job = textract.start_document_analysis(
    DocumentLocation={"S3Object": {"Bucket": "store-paperwork", "Name": "contracts/lease-2026.pdf"}},
    FeatureTypes=["TABLES", "LAYOUT"],
    NotificationChannel={"SNSTopicArn": "arn:aws:sns:us-east-1:111122223333:AmazonTextract-done",
                         "RoleArn": "arn:aws:iam::111122223333:role/TextractSNSPublish"},
    OutputConfig={"S3Bucket": "store-paperwork", "S3Prefix": "textract-output"},
)

# when the SNS message says SUCCEEDED, page through the results
pages, token = [], None
while True:
    kwargs = {"JobId": job["JobId"], "MaxResults": 1000}
    if token:
        kwargs["NextToken"] = token
    part = textract.get_document_analysis(**kwargs)
    pages.extend(part["Blocks"])
    token = part.get("NextToken")
    if not token:
        break
print(len(pages), "blocks")

• Collect results promptly: the Get operations return a job's results for a limited time after it finishes (about a week), so save them to S3, which OutputConfig does for you.
• Page through every result: big documents return many pages of Blocks; stop only when NextToken is gone.
• Use the notification, not polling: an SNS topic that triggers a Lambda function is cheaper and faster than a loop calling Get every few seconds.
• Bursts: to process thousands of PDFs at once, queue the file names in SQS and start jobs at a steady rate under your Textract quota, rather than starting all at once and fighting throttling.

Queries and adapters: ask the document a question

Queries are often the cheapest way to get a few fields out of varied documents. Instead of extracting every key-value pair (Forms, $0.05) and then searching for the one you want, you ask "What is the policy number?" or "Who is the tenant?" ($0.015 for up to 15 or 30 questions per page). Textract understands the wording, finds the answer even when the label differs ("Policy #", "Policy No.", "Contract number"), and returns it with a confidence and position. Queries work on English documents.

Adapters (Custom Queries) fine-tune the queries feature on your own document types when the built-in model misses fields on unusual layouts, such as a niche industry form. You upload 5 or more sample documents (up to 2,500 for training), annotate the answers in the console (Textract pre-labels them for you), train, and get an adapter ID you pass in AdaptersConfig. Pages processed with an adapter cost $0.025 for the first million a month. Start without one; train an adapter only when your accuracy testing shows the default misses too often.

Invoices, receipts, IDs and lending documents

• Analyze Expense reads invoices and receipts from any vendor and returns normalized fields such as VENDOR_NAME, INVOICE_RECEIPT_ID, INVOICE_RECEIPT_DATE, DUE_DATE, SUBTOTAL, TAX and TOTAL, plus every line item with description, quantity, unit price and amount, whatever each vendor calls them. At $0.01 per page, it is the right API for accounts payable and expense apps; the store's 600 invoices from dozens of suppliers needed no per-supplier setup.
• Analyze ID extracts fields from US passports and US driver's licenses (name, date of birth, document number, expiry, address, and more) with normalized names. Other countries' IDs are not supported by this API; for those, use queries on Analyze Document or another service.
• Analyze Lending takes a whole mortgage package (often hundreds of mixed pages), classifies each page (pay stubs, bank statements, tax forms, IDs, checks), extracts the fields that page type needs, and flags signatures, at $0.07 per page.

resp = textract.analyze_expense(Document={"S3Object": {"Bucket": "store-paperwork", "Name": "invoices/acme-10442.png"}})
for doc in resp["ExpenseDocuments"]:
    fields = {f["Type"]["Text"]: f["ValueDetection"]["Text"] for f in doc["SummaryFields"] if "ValueDetection" in f}
    print(fields.get("VENDOR_NAME"), fields.get("INVOICE_RECEIPT_ID"), fields.get("TOTAL"))
    for group in doc["LineItemGroups"]:
        for item in group["LineItems"]:
            row = {f["Type"]["Text"]: f["ValueDetection"]["Text"] for f in item["LineItemExpenseFields"]}
            print("  ", row.get("ITEM"), row.get("QUANTITY"), row.get("PRICE"))

How accurate is Textract? Handwriting, scans and photos

On clean, printed documents, Textract's text extraction is very accurate, and structure (tables, forms) is good enough to automate most of the work. Accuracy falls with the usual suspects:

• Image quality: text must be at least 15 pixels high (about 8-point text at 150 DPI). Scan at 200 to 300 DPI; for phone photos, fill the frame, avoid shadows and keep the page flat.
• Handwriting: supported in English only, and much better for block capitals in boxes than for joined-up notes. Neat handwriting on forms usually works; doctors' notes usually do not.
• Languages: printed text in English, French, German, Italian, Portuguese and Spanish. Vertical text, as in some Japanese and Chinese documents, is not supported, and Textract does not tell you which language it found.
• Rotation: any in-plane rotation is handled, so sideways and slightly skewed scans are fine.
• Complex tables: merged cells, tables spanning pages and tables without borders work, but check them; Textractor can stitch tables that continue across pages.

Keep a person in the loop. Route fields below your confidence threshold to a review screen, and track the correction rate per document type. Amazon Augmented AI (A2I), which offered a ready-made review workflow for Textract, closed to new customers in 2026 (see our list of AWS services retired in 2026), so new projects build a simple review page or use a document-processing product that includes one.

The store's crumpled delivery note came back with every printed word right, the order number read correctly from a query, and the customer's handwritten "left at back door" at 74 percent confidence, which went to the review screen, exactly as it should.

Is Amazon Textract good? Uses and limits

For businesses already on AWS, Textract is one of the easiest ways to stop retyping paper. Its strengths: no templates per supplier or form, structure as well as text, confidence scores on everything, specialized invoice and ID models, and pay-per-page pricing that stays small for small volumes. Its limits: six languages for printed text and English only for handwriting and queries, US-only identity documents, Forms pricing that adds up quickly at scale, and raw JSON that needs a library like Textractor to be pleasant. It is also HIPAA eligible, so healthcare forms and records can go through it under a Business Associate Addendum.

What people use it for: accounts payable (invoices and receipts), claims and application forms in insurance and banking, mortgage and loan packages, patient intake forms, contracts and leases (key dates and parties via queries), digitizing archives for search, and reading checks: queries such as "What is the check amount?" and "Who is the payee?" pull the fields from check images, and Analyze Lending classifies checks inside loan packages.

Does Textract use AI? Yes. It is built on deep learning models trained by AWS on millions of documents, which is why it needs no templates. It is not open source, though the Textractor helper library and many sample pipelines are.

An automatic invoice pipeline on AWS

1. Collect documents in S3: an email rule saves attachments to a bucket (Amazon SES can receive mail and store it in S3), and scanners and phone uploads write to the same place, perhaps through presigned upload URLs.
2. Trigger processing: an S3 event starts a Lambda function, or a Step Functions workflow for multi-page jobs.
3. Classify, then extract: decide the document type (invoice, delivery note, other) cheaply first, with a text call or the file name and sender, then call only the API that type needs.
4. Validate: check that line items add up to the subtotal, that the tax is plausible, that the supplier exists and the invoice number is new.
5. Review exceptions: anything low-confidence or failing validation goes to a person.
6. Post to the accounts system and archive the original with its extracted JSON.

The validation step catches more errors than any threshold: a total that does not equal the sum of its lines is either a misread or a supplier mistake, and either way a person should see it.

The Lambda function at the heart of that pipeline can be short. This one handles single-page invoice images arriving in S3; multi-page PDFs would start an asynchronous job instead:

import json, urllib.parse
import boto3

textract = boto3.client("textract")
s3 = boto3.client("s3")
REVIEW_BELOW = 95.0

def lambda_handler(event, context):
    for rec in event["Records"]:
        bucket = rec["s3"]["bucket"]["name"]
        key = urllib.parse.unquote_plus(rec["s3"]["object"]["key"])
        resp = textract.analyze_expense(Document={"S3Object": {"Bucket": bucket, "Name": key}})
        doc = resp["ExpenseDocuments"][0]
        fields, review = {}, False
        for f in doc["SummaryFields"]:
            if "ValueDetection" in f:
                fields[f["Type"]["Text"]] = f["ValueDetection"]["Text"]
                review = review or f["ValueDetection"]["Confidence"] < REVIEW_BELOW
        target = ("review/" if review else "ready/") + key.rsplit("/", 1)[-1] + ".json"
        s3.put_object(Bucket=bucket, Key=target, Body=json.JSONEncoder().encode(fields).encode())

Give the function textract:AnalyzeExpense, s3:GetObject on the upload prefix and s3:PutObject on the review and ready prefixes, and trigger it only on the upload prefix so its own output files do not trigger it again.

Finding and redacting personal data: Textract with Comprehend

Documents full of names, addresses, account numbers and medical details often need redacting before they are shared, stored long-term or sent to another system. Textract and Amazon Comprehend do this together:

1. Extract the text and positions with Textract (Detect Document Text is enough).
2. Find personal data by sending the text to Comprehend's DetectPiiEntities, which returns each item (name, address, phone, email, bank account, Social Security number and more) with its character offsets.
3. Map each item back to the page using the bounding boxes of the Textract words at those offsets.
4. Draw black boxes over those areas in a copy of the image or PDF (with Pillow or a PDF library), and keep the original locked away or delete it.

For text that will only be stored as text, Comprehend can also return a redacted version directly. Either way, test on real documents: names in unusual formats and numbers split across lines are the usual misses, so a human check on a sample is still worth doing.

Using Textract output with a language model

A common 2026 pattern pairs Textract with a language model on Bedrock. Textract does the reading, with exact text and positions, and the model does the thinking: summarizing a contract, answering questions over a stack of documents, or comparing an invoice with a purchase order. The Layout feature matters here: it returns text in reading order with titles, headers, lists and tables marked, so columns, sidebars and page headers do not end up mixed into the middle of sentences. Textractor's get_text() and Markdown export turn that into clean input for a prompt or for chunks in a knowledge base. Sending page images straight to a multimodal model can work for small volumes, but extracting first gives you confidence scores, positions you can show to reviewers, and a much smaller prompt.

Security, privacy and compliance

• Encryption: documents stay in your S3 bucket, encrypted with SSE-S3 or your KMS key; results written with OutputConfig can be encrypted with a KMS key too, and traffic to Textract uses TLS.
• Private networking: Textract supports VPC interface endpoints, so Lambda functions and servers in private subnets can call it without internet access.
• Data use: Textract may store and use document content it processes to improve the service unless you opt out with an AWS Organizations AI services opt-out policy; set that policy before processing sensitive documents.
• Compliance: Textract is HIPAA eligible and covered by AWS's usual compliance programs; check the AWS compliance pages for the specific program you need.
• Least privilege and retention: narrow IAM permissions to the APIs and prefixes each component uses, and set S3 lifecycle rules so originals with personal data do not live forever.

Textract vs Rekognition, Comprehend, Bedrock Data Automation and free OCR

• Textract vs Rekognition: Rekognition analyzes photos and video and reads up to 100 words of text in a picture (signs, labels, plates). Textract reads documents, with structure. Paper goes to Textract; pictures go to Rekognition.
• Textract vs Comprehend: they work in sequence. Textract turns the page into text; Amazon Comprehend analyzes that text (entities, key phrases, sentiment, PII detection). For example, Textract reads a contract and Comprehend finds the names and dates in it.
• Textract vs Bedrock Data Automation: Bedrock Data Automation (BDA) uses generative AI to turn documents, images, audio and video into structured output defined by blueprints, including summaries and fields inferred from context. Textract is cheaper per page for plain extraction and returns exact positions and confidences; BDA is easier when you want "the fields I care about, in my JSON shape" across varied documents.
• Textract vs a multimodal model on Bedrock: you can send a page image to a model such as Amazon Nova and ask for JSON. It is flexible and handles odd layouts, but it can invent values, gives no per-word confidence, and costs more per page at volume. A common pattern: Textract for extraction, a language model to interpret or summarize the text.
• Textract vs free and open-source OCR: Tesseract and newer models such as LightOnOCR-3 run on your own computer at no cost per page and keep documents private, with good results on clean pages. You give up the managed scaling, the forms and query features, and the expense and ID models.
• Textract vs Docling and other open-source converters: tools such as Docling turn PDFs and Office files into Markdown or JSON on your own machine, using born-digital text where it exists and OCR where it does not. They are excellent for feeding clean text to a language model, free per page and private; Textract wins on scanned and photographed paper, handwriting, forms, invoices and IDs, at scale.
• Textract vs Amazon Kendra: different jobs. Kendra was an enterprise search service that indexed documents for question answering, and it closed to new customers in 2026 (its successor is Bedrock Managed Knowledge Base). Textract extracts the text and fields that a search index or knowledge base then uses.
• Textract vs Azure Document Intelligence and Google Document AI: similar per-page pricing with prebuilt invoice, receipt and ID models and custom extraction. Choose the one in the cloud where your documents and apps already live, after testing your own documents in each.

Limits, formats and languages

• Formats: JPEG, PNG, PDF and TIFF (PDFs may contain JPEG 2000 images); XFA-based and password-protected PDFs are not supported.
• Synchronous: up to 10 MB, one page per PDF or TIFF.
• Asynchronous: images up to 10 MB; PDFs and TIFFs up to 500 MB and 3,000 pages, from S3.
• Page size: PDF pages up to 40 inches (9,000 points) on each side; images up to 10,000 pixels on each side.
• Text: at least 15 pixels high; horizontal text only.
• Queries: up to 15 per page synchronously, 30 asynchronously; answers up to 128 characters with adapters.
• Analyze ID: US passports and US driver's licenses only.
• Requests per second: default quotas per API and Region, adjustable in Service Quotas.

Common Amazon Textract errors and fixes

• UnsupportedDocumentException: the file is not a real JPEG, PNG, PDF or TIFF (HEIC photos, WebP, Word files), or the PDF is password protected or XFA-based. Convert or re-save the file as a normal PDF or image.
• "Request has unsupported document format" on a multi-page PDF: you used a synchronous API; multi-page documents need StartDocumentTextDetection or StartDocumentAnalysis.
• DocumentTooLargeException: over 10 MB synchronously, or over 500 MB or 3,000 pages asynchronously. Compress images, or split the PDF.
• InvalidS3ObjectException: wrong bucket or key, the bucket is in another Region from the Textract client, or the caller lacks s3:GetObject (and kms:Decrypt for KMS-encrypted objects).
• BadDocumentException: the file is damaged or truncated; open it locally to check, and re-export it.
• ProvisionedThroughputExceededException or ThrottlingException: too many requests at once. Spread the load with a queue, retry with backoff, and request a quota increase if needed.
• LimitExceededException on Start calls: too many asynchronous jobs running at once; wait for some to finish or raise the concurrent jobs quota.
• The SNS notification never arrives: the role in NotificationChannel cannot publish to the topic, or the topic policy does not allow it; the job still runs, and Get returns results.
• Tables come back empty: you called detect_document_text, which returns text only; tables need analyze_document with TABLES.
• Fields missing from forms: the label and value are far apart or unusual; try a query for that field, or an adapter.

Best practices and ways to cut the bill

• Request only the features you use; queries and tables are a fraction of the price of forms.
• Use the specialized APIs for invoices, receipts and IDs; they are cheaper and return normalized fields.
• Process only the pages you need, splitting long PDFs when the data sits on known pages.
• Save every response next to the document, so changes in your parsing never require paying again.
• Validate extracted numbers with business rules, not just confidence scores.
• Improve the input: scan at 200 to 300 DPI, keep photos flat and well lit.
• Protect the documents: encrypt the bucket, restrict access, and set lifecycle rules for originals that contain personal data.
• Test on your worst documents before committing, and track the review rate over time.

Frequently asked questions

By the end of the next month, the bookkeeper's invoice routine was a review screen: 600 invoices read by Analyze Expense, 540 posted automatically because every field was confident and the lines added up, and 60 waiting for a quick check, most of them photos of crumpled paper. The delivery notes were checked for a signature and an order number as they arrived. The Textract bill for the month was $19.40. Jake asked whether it could also read the notes customers wrote on the back. "In English, if they write neatly," Ethan said. "Which they don't."

Revision note. Written October 21, 2026. Prices are US East (N. Virginia) list prices on that date. We will update this page when Textract prices or features change.