AE3-TL

Page-level table extraction that gets more tables exactly right. AE3-TL finds every table on a PDF page and rebuilds it cell for cell: rows, columns, merged cells, headers and text, with each caption and footer attached to the right table.

It is the new state of the art on the PubTables-v2 page-level benchmark, first on all six metrics. At 32M parameters it runs on a single GPU or a CPU through ONNX, and it is free and open under Apache 2.0, including for commercial use.

Paper · Code

---

What it does

Input: a rendered PDF page, plus the page's words with their positions (from the PDF's text layer).

Output: every table on the page, each with:

• its grid of cells, including cells that span several rows or columns
• column headers and row structure
• the text of every cell
• its caption and footer, linked to the right table even when a page has several

AE3-TL reads structure from the image and text from the PDF's own words, so the text in each cell is exactly what the document contains, with no OCR errors. It is built for digital PDFs: reports, filings, papers and statements that have a text layer.

---

Results

Full method and analysis are in the paper. All scores are on the PubTables-v2 Single Pages test set (7,680 pages, 9,047 tables), with the dataset's own words, scored by Kensho's unchanged POTATR scorer v0.2.0. The other rows come from the POTATR paper (Smock et al., DAS 2026).

To make the comparison like for like, we re-ran POTATR from its released weights through the same pipeline. Our re-run matches the paper's POTATR + DT row to within 0.0022 on every metric.

At a glance

Gemini reads the page image only, as in the paper; AE3-TL and POTATR also use the page's words. The cost figures use the paper's pricing: $2.45 per GPU-hour, and list API prices for the MLLMs.

The denser the page, the bigger the lead

On simple pages AE3-TL and POTATR are close. As tables grow, POTATR's exact-match rate falls away faster: on pages with more than 250 cells, AE3-TL gets 59% of tables exactly right against 40%, a 1.48× lead.

Gain in percentage points of exact match (content). The per-bin figures come from an earlier scoring run of the same weights, before a final fix to word handling; the overall figures elsewhere on this page are from the final run.

Density bins: GriTS-Con and TEDS

AE3-TL leads in every bin on every metric.

Statistical significance

AE3-TL minus our POTATR re-run, on the same pages. The 95% intervals come from a paired page bootstrap (2,000 resamples, seed 20261028). Every interval is above zero.

Full benchmark table: all models (paper Table 2)

‡ Our runs. DT = the dataset's own words. Image-only models read the page image without the document's words, as in the paper.

Caption and footer text (paper Table 3, plus a footer column)

Character-level LCS F1, with precision (P) and recall (R).

‡ Our runs, using the scorer's @con table key. The paper does not publish footer scores.

Speed and cost (paper Table 4)

‡ One NVIDIA A10, batch size 1, timed at Kensho's boundary: model forward pass plus post-processing, file reading excluded. Priced at the paper's $2.45 per GPU-hour. The paper measured POTATR on an A10G, so we compare against our own A10 re-run.

---

Model details

Files

---

How to use

AE3-TL runs in three steps:

1. Page model. Detects tables, rows, columns, spanning cells and headers.
2. Relation head. Decides which caption and footer belong to which table.
3. Post-processing (included in the kit). Turns the detections and the page's words into finished tables with cells, spans, text, captions and footers.

USAGE.md walks through the full pipeline, including the "For best results" settings.

Model inputs and outputs

Running the page model

import numpy as np
import onnxruntime as ort

session = ort.InferenceSession(
    "ae3-tl-page.onnx",
    providers=["CUDAExecutionProvider", "CPUExecutionProvider"],
)

# One page rendered to RGB, prepared as described in USAGE.md:
# float32, shape [1, 3, 768, 768], values in 0..1
image = np.zeros((1, 3, 768, 768), dtype=np.float32)

names = [o.name for o in session.get_outputs()]
outputs = dict(zip(names, session.run(None, {"images": image})))

print(outputs["logits"].shape)  # (1, 300, 16)
print(outputs["boxes"].shape)   # (1, 300, 4)

Verify your download

sha256sum ae3-tl-page.onnx ae3-tl-relation.onnx

The hashes should match the table above.

---

Intended use and limitations

Good for: extracting tables at scale from digital PDFs (financial reports, filings, research papers, statements) where the text layer is available, including privately on your own hardware.

Know before you use it:

• Digital PDFs only, as evaluated. All results use the document's own words. Scanned pages need OCR first. The POTATR + OCR rows above show how much OCR errors can cost on this benchmark; we have not yet measured AE3-TL with OCR.
• Trained and tested on scientific articles. PubTables-v2 is built from PubMed Central papers. We expect the gains to carry over to financial and business documents, but have not yet benchmarked them.
• Captions are on a par, not ahead. Caption text F1 is 0.977 against POTATR's 0.981. Footer text F1 is higher (0.985 against 0.979).
• One training run. The confidence intervals cover variation across test pages, not across training seeds.
• Check before relying on outputs. Like any extraction model it makes mistakes, more often on very dense tables. Review the output before relying on it for decisions.

---

Licence and credits

AE3-TL's weights and code are released under the Apache License 2.0. You can use, modify and redistribute them, including commercially, provided you keep the licence and the notices below.

AE3-TL builds on the following open work. Thank you to their authors.

---

Citation

If you use AE3-TL, please cite the paper:

@misc{khan2026ae3tl,
  title        = {AE3-TL: Faster and More Exact Page-Level Table Extraction with a Real-Time Detection Transformer},
  author       = {Khan, Usman},
  year         = {2026},
  publisher    = {APEXE3},
  howpublished = {\url{https://github.com/apexe3/ae3-table-extract/blob/main/AE3-TL_2026.pdf}}
}

AE3-TL is evaluated against, and builds on:

• Peng et al. D-FINE: Redefine Regression Task in DETRs as Fine-grained Distribution Refinement. ICLR 2025.
• Smock et al. PubTables-1M: Towards Comprehensive Table Extraction From Unstructured Documents. CVPR 2022.
• Smock et al. PubTables-v2. 2025.
• Smock et al. POTATR. DAS 2026.

---

Contact

Built by APEXE3. For questions, help deploying AE3-TL privately at scale, or a hosted API, contact labs@apexe3.com.

Model v3, epoch 1, EMA weights. Card updated November 2026.