Use code for 1,000 extra pages on your first month of Starter.+1,000 pages on Starter
See Starter →See →Docling tested on a laptop CPU: install, Markdown and JSON output, 5.9 s a page, where it stops, and the same pages through HyperAPI's parse API.
Docling is a free, open-source Python library that turns PDFs, Office files and images into Markdown, HTML or JSON on your own machine. We installed it, ran it on 21 public pages on a laptop CPU, and put its output next to a hosted parser on the same two pages.
Last updated: 18 November 2026
Short answer. Docling, started at IBM Research Zurich and MIT-licensed, is the right pick when you want free Markdown and your documents cannot leave your network. If you need word boxes, heading levels and sections without installing over a gigabyte of packages and running models locally, HyperAPI by Hyperbots returns them as JSON from its fast parse for $1 per 1,000 pages. For Markdown from the API itself, HyperAPI's advanced parse returns it at $0.05 a page on the Plus plan.
Try it on your own file. Fast parse returns each heading at its level and flags page headers and footers, from one call. A free account gives 30 pages a month, no card.
Docling reads a file, works out what is on each page (paragraphs, headings, lists, tables, pictures, headers and footers) and stores the result as a DoclingDocument. You export that as Markdown for a language model, HTML for display, or lossless JSON for your own code. Besides PDF it reads DOCX, PPTX, XLSX, HTML, images, EPUB and email, according to its README.
| Fact | Value (read 17 November 2026) |
|---|---|
| Latest release | 2.150.1, published 14 November 2026 |
| Licence | MIT for the code; the models it downloads carry their own licences |
| Origin and home | Started at IBM Research Zurich; hosted by the LF AI & Data Foundation |
| Python | 3.10 or newer |
| GitHub stars | 70,680 |
| Integrations | LangChain, LlamaIndex, Crew AI, Haystack |
Docling's architecture page shows a document converter that picks a backend for the file format and a pipeline that processes it, ending in one DoclingDocument, which you export. For PDFs, its README lists page layout, reading order and table structure, and OCR for scanned PDFs and images. Table structure and OCR are both on by default, so Docling runs OCR on scanned pages and images unless you turn it off.
Docling does OCR, and you can choose the engine and the languages or force OCR on every page. The supported engines change between releases, so use its OCR documentation as the reference.
pip install doclingfrom docling.document_converter import DocumentConverter
converter = DocumentConverter()
result = converter.convert("report.pdf") # a path or a URL
doc = result.document
print(doc.export_to_markdown()) # Markdown
data = doc.export_to_dict() # lossless JSON
for table in doc.tables: # each table as a pandas DataFrame
print(table.export_to_dataframe(doc=doc))Expect a large install. pip install docling brought in 102 packages, PyTorch among them, and our virtualenv came to 1.26 GB (about 17 MB of that was unrelated packages). The first conversion downloaded 563 MB of model files, so our first one-page document took 141.6 seconds end to end. Later documents reuse the downloaded models.
We used two pages that we also parsed with HyperAPI further down: page 35 of the National Archives (NARA) 2024 records management report and page 5 of the Census Bureau's New Residential Construction release for September 2026. Both are US government works in the public domain.
Markdown. Here is Docling's Markdown for the NARA page, trimmed. Paragraphs and the bulleted list come through cleanly, and the “Page 27” footer is left out:
## CONCLUSION
NARA requires agencies to complete the annual reports to determine
threats and risks to records, ...
## RECOMMENDATIONS
NARA continues to conduct oversight of federal records management ...
## Senior Agency Officials for Records Management
NARA makes the following five recommendations for SAORMs. SAORMS must
- continue to advocate for and support their records management programs ...
- continue to support the agency's efforts to become fully electronic, ...
## CONCLUSION AND RECOMMENDATIONSJSON. In the lossless JSON, each item has its text, its page, one box and a content layer. Here is the “RECOMMENDATIONS” heading, trimmed (page 5 is the report's page 35 in the six pages we cut out). Coordinates are PDF points measured from the bottom-left corner of the page, and running headers and footers sit in a separate furniture layer:
{
"text": "RECOMMENDATIONS",
"level": 1,
"content_layer": "body",
"prov": [{"page_no": 5,
"bbox": {"l": 72.0, "t": 504.6, "r": 179.4, "b": 493.1,
"coord_origin": "BOTTOMLEFT"}}]
}Tables. On the Census page Docling found both tables and returned them as cell grids of 23 by 13 and 26 by 13, with two-row column headers joined into one name for Markdown. The values match the printed page:
| Period | United States - Total | United States - 1 unit | Northeast - Total |
|-----------------|-----------------------|------------------------|-------------------|
| 2025 | | | |
| September . . . | 1,319 | 837 | 165 |
| October . . . . | 1,273 | 893 | 145 |
(4 of 13 columns shown, dot leaders shortened)Machine: Apple M1 laptop, 16 GB RAM, Python 3.12.4, Docling 2.150.1 with default options, on the CPU with its default 4 threads, run on 17 November 2026. Seconds are wall-clock time for convert() after the models were loaded. The paper is arXiv 2611.17612 by Omidi, Mishra and Almassalkhi (CC BY 4.0); the other documents are US government works.
| Document | Pages | Seconds per page | Tables on the pages / found |
|---|---|---|---|
| NARA records management report, 2024 | 6 | 1.46 | 0 / 0 |
| Census new residential construction, Sep 2026 | 7 | 10.13 | 10 / 10 |
| arXiv 2611.17612, two-column paper | 4 | 2.56 | 3 / 3 |
| Statutes at Large 1946, image-only scan | 4 | 8.72 | 0 / 0 |
| All | 21 | 5.94 | 13 / 13 |
Docling found every table we counted by eye and reported none where there were none. Speed depends on the page: about a second and a half for plain text, about ten seconds for dense tables, nearly nine for OCR on a scan. Docling can also run on a GPU (its GPU guide covers setup); we did not time that.
CPU time. At our measured 5.94 seconds a page, 1,000 pages is about 99 minutes of laptop time; at the 10.13 seconds we saw on dense tables, about 2.8 hours. You can buy a GPU or more servers, but then you are running a parsing service.
Install size. 102 packages, a virtualenv of over 1.2 GB and a 563 MB model download, on every machine and container that parses.
No word boxes in the document JSON. Each item in the document JSON carries one box: a whole paragraph, heading or table cell. There is no per-word position, font or size, which is what you need to highlight a value in a viewer or to check where a number sits on the page. Docling can keep word and line cells from its PDF parser (generate_parsed_pages=True, off by default, documented for debugging or advanced post-processing), but they sit outside the DoclingDocument and its exports.
Heading levels flattened. All 53 headings across our four documents came back at level 1, from a paper title down to “4.1.1. State Space”. That is the documented default: Docling's heading levels option, off by default, rebuilds a hierarchy from bookmarks, numbering and font style. With default settings the headings are also flat siblings of the text, not sections that contain it.
Smaller things we saw. On the NARA page, the page title “CONCLUSION AND RECOMMENDATIONS” sits at the top but was emitted after everything else, so in the Markdown above it heads the next page. On the Census pages, 76 of 2,124 value cells began with a stray dot from the leader lines, such as . 1,482, and the table titles became headings.
Published by HyperAPI. We rank ourselves first on the criteria below; check them against your own documents.
The criteria are what comes back and what it costs, not accuracy. Prices are list prices; Docling's cost is your own hardware.
| Option | HyperAPI fast parse | HyperAPI advanced parse | Docling |
|---|---|---|---|
| Per 1,000 pages | $1 | $50 (Plus plan or higher) | Free; your CPU time |
| Setup | An API key; upload, then one call | Same call with mode=advanced | 102 packages, over 1.2 GB, plus 563 MB of models |
| Word and line boxes | Yes, with font, size and colour per word | No | Not in the document JSON by default; one box per item |
| Heading levels and sections | Level on each heading; sections as nested groups | Typed regions | Level 1 unless the option is on; no sections |
| Tables | Table blocks with positions, plus HTML by default (best-effort; a table it cannot parse is marked) | In the HTML and Markdown | Cell grids with spans; DataFrame export |
| Markdown | No (JSON); build it from the blocks | Yes, plus structured HTML | Yes |
And here is what each returned on the two pages. Docling's numbers are from our run; HyperAPI's are from a fast-parse run of the same pages, saved as returned.
| Field | HyperAPI fast parse (NARA / Census) | Docling, defaults (NARA / Census) |
|---|---|---|
| Word boxes | 257 / 826 | None |
| Line boxes | 29 / 581 | None |
| Typed blocks or items | 10 / 12 | 14 / 12, plus 2 tables |
| Heading levels used | 1 and 2 / 1 and 2 | 1 / 1 |
| Sections | 4, nested / 2, nested, with 2 table groups | None |
| Page title | First block, type: "title" / first block, type: "heading" | Emitted last / emitted first |
| Census tables | 2 table blocks with positions; HTML by default | 2 cell grids (23 × 13, 26 × 13) |
Neither output is perfect. On NARA, fast parse put the bold sub-heading “Senior Agency Officials for Records Management” at level 1, beside the page title rather than under “RECOMMENDATIONS”. On Census it made the key “p Preliminary” a level-2 heading, where Docling made the two table titles into headings. Check levels on your own documents before you split on them.
Every call is the same three steps: ask for an upload URL, PUT the file to it, then call /v1/parse with the document_key. Fast is the default mode. Python with requests:
import os
import requests
API = "https://apis.hyperbots.com/v1"
HEADERS = {"X-API-Key": os.environ["HYPERAPI_KEY"]}
path = "report-page.pdf"
# 1. Ask for an upload URL
up = requests.post(f"{API}/documents/upload", headers=HEADERS, json={
"filename": path,
"content_type": "application/pdf",
"content_length": os.path.getsize(path),
}).json()
# 2. PUT the file bytes to it
with open(path, "rb") as f:
requests.put(up["upload_url"], data=f, headers={
"Content-Type": "application/pdf",
"x-amz-server-side-encryption": "AES256",
}).raise_for_status()
# 3. Parse
result = requests.post(f"{API}/parse", headers=HEADERS,
files={"document_key": (None, up["document_key"])}).json()
for block in result["result"]["blocks"]:
print(block["order"], block["type"], block.get("heading"), block["bbox"])The same with cURL:
SIZE=$(wc -c < report-page.pdf | tr -d ' ')
RESP=$(curl -s -X POST https://apis.hyperbots.com/v1/documents/upload \
-H "X-API-Key: $HYPERAPI_KEY" -H "Content-Type: application/json" \
-d '{"filename":"report-page.pdf","content_type":"application/pdf","content_length":'"$SIZE"'}')
DOC_KEY=$(echo "$RESP" | python3 -c "import sys,json; print(json.load(sys.stdin)['document_key'])")
UPLOAD_URL=$(echo "$RESP" | python3 -c "import sys,json; print(json.load(sys.stdin)['upload_url'])")
curl -s -X PUT "$UPLOAD_URL" -H "Content-Type: application/pdf" \
-H "x-amz-server-side-encryption: AES256" --data-binary @report-page.pdf
curl -s -X POST https://apis.hyperbots.com/v1/parse \
-H "X-API-Key: $HYPERAPI_KEY" -F "document_key=$DOC_KEY" > report-page.jsonThe output for the NARA page, trimmed (HTML and styles left out). Boxes are pixels in the page's dimensions, measured from the top-left:
{
"pages": [{
"page_number": 1,
"dimensions": {"width": 1696, "height": 2176},
"word_boxes": [
{"text": "CONCLUSION", "bbox": [566, 203, 754, 237], "confidence": 0.9525,
"font": "TimesNewRomanPS", "size": 9.8, "color": "#231f20", "bold": true},
...256 more
]
}],
"blocks": [
{"id": "b1-0", "order": 0, "type": "title", "bbox": [558, 203, 1136, 242], "heading": 1, "group": "g0"},
{"id": "b1-1", "order": 1, "type": "heading", "bbox": [194, 285, 396, 323], "heading": 2, "group": "g1"},
{"id": "b1-2", "order": 2, "type": "text", "bbox": [190, 365, 1495, 595], "group": "g1"},
...
{"id": "b1-9", "order": 9, "type": "page_number", "bbox": [799, 2006, 893, 2037], "furniture": true}
],
"groups": [
{"id": "g0", "kind": "section", "level": 1, "heading": "b1-0", "children": ["b1-0", "g1", "g2"]},
{"id": "g1", "kind": "section", "level": 2, "heading": "b1-1", "children": ["b1-1", "b1-2", "b1-3"]},
...
]
}Each section group holds its heading and everything under it, so you can split a document on groups instead of on character counts; PDF chunking for RAG walks through it. On the Census page, each table is a type: "table" block with its box (Table 3a is [95, 229, 1512, 956]), returned as HTML by default, and a table that runs onto the next page is linked to its continuation. The parse reference lists every field.
Fast parse returns JSON, not Markdown. If you want Markdown from the API itself, call advanced parse (mode=advanced, $0.05 a page, Plus plan or higher, up to 60 pages a request). Or build it from the fast blocks, skipping page furniture and using heading as the number of # marks:
import html, re
def text(block):
return " ".join(html.unescape(re.sub(r"<[^>]+>", " ", block["html"])).split())
lines = []
for block in result["result"]["blocks"]:
if block.get("furniture"):
continue
level = block.get("heading")
lines.append("#" * level + " " + text(block) if level else text(block))
print("\n\n".join(lines))On the NARA page that prints, trimmed:
# CONCLUSION AND RECOMMENDATIONS
## CONCLUSION
NARA requires agencies to complete the annual reports to determine ...
## RECOMMENDATIONS
NARA continues to conduct oversight of federal records management ...
# Senior Agency Officials for Records Management
NARA makes the following five recommendations for SAORMs. SAORMS mustA free account parses your own files into JSON: 30 pages a month, no card.
Stay with Docling when documents must not leave your network, when you parse very large volumes on hardware you already run, or when Markdown and table cells are all you need. HyperAPI keeps each request's input and result for 30 days, retrievable by request_id, then deletes them, and does not train on them; if that does not fit your rules, run Docling. For a wider field of hosted options, see the best document parsing APIs, and for what each layer of a parse result means, see PDF parsing in Python.
Converting PDFs, Office files, HTML and images into Markdown, HTML or JSON, usually to feed search or a language model. It runs on your own machine.
Yes. The code is MIT-licensed and can be used commercially. The models it downloads carry their own licences, so check those for your use.
IBM Research Zurich started it. It is now hosted by the LF AI & Data Foundation and developed in the open on GitHub.
On an Apple M1 with 4 threads it averaged 5.94 seconds a page over 21 mixed pages: 1.46 on a text report and 10.13 on dense tables. The first run adds a 563 MB model download.
One box per item (a paragraph, heading or table cell), in PDF points from the bottom-left corner. Its document JSON has no per-word boxes. HyperAPI fast parse returns word and line boxes for every page.
If you would rather call an API than run models, HyperAPI fast parse returns word boxes, typed blocks, heading levels, sections and tables as HTML with positions for $1 per 1,000 pages, and advanced parse returns Markdown. If documents must stay on your own hardware, keep Docling.
Want parsed pages without the install? Start free with 30 pages a month and no card.