
Fast document parsing in Rust. Turn PDFs, Office files, spreadsheets and more into Markdown and structured JSON also with built-in OCR. MIT licensed.
Repo bulkgrid/bulkparse, read from GitHub 16 min ago. bulkgrid has not joined Take My Repo.
bulkgrid/bulkparse is a public repo on GitHub by bulkgrid. Fast document parsing in Rust. Turn PDFs, Office files, spreadsheets and more into Markdown and structured JSON also with built-in OCR. MIT licensed. It declares the MIT license on GitHub. It is written mainly in Rust, has 47 stars and last changed on 2026-11-22. Nobody has reviewed it on Take My Repo yet, which says nothing about its quality. Read from GitHub on 2026-11-22.
In the maintainer's words. Shown from GitHub; Take My Repo does not keep a copy.
Documents in. AI-ready content out.
Turn PDFs, spreadsheets, slides and documents into Markdown and structured JSON.
Native Rust speed. Your infrastructure. Your rules.
Installation · Quick start · Agent skill · Formats · Benchmarks · APIs · Documentation

Build the next step. BulkParse handles the document conversion. Give your search engine, RAG pipeline or AI agent readable Markdown and structured records from the files your users already have. Convert PDFs, Word documents, spreadsheets, presentations and ebooks through one API, with headings, tables and source references your application can work with.
Built in Rust by Bulkgrid. Use it from Node.js, Python, Rust or the browser. Run the native conversion core on your own infrastructure without an API key, model download or external parsing service. Open source. MIT licensed. Yours to build on.
200 PDFs in 0.440 seconds. BulkParse used 40% less conversion time than the next-fastest tested configuration in our same-machine PDF development benchmark, with OCR off and startup excluded. Compare eight engines across speed, extraction scores and memory. See the full results and trade-offs ↓
Early release: see current scope for extraction and platform coverage.
Choose the package for your workflow:
| Use | Install | Examples |
|---|---|---|
| CLI (Node.js 20+) | npm install -g @bulkgrid/bulkparse |
Quick start |
| Node.js / TypeScript (Node.js 20+) | npm install @bulkgrid/bulkparse |
Node.js API |
| Python (3.10+) | python -m pip install bulkparse |
Python API |
| Rust | cargo add bulkparse |
Rust API |
| Browser / WebAssembly | npm install @bulkgrid/bulkparse-wasm |
Browser API |
| Coding agent skill | npx skills add bulkgrid/bulkparse --skill parse-documents-to-markdown |
Agent setup |
You can also install the CLI with cargo install bulkparse-cli --features ocr.
OCR requires additional model and runtime setup.
With Node.js 20 or newer, run the prebuilt CLI without a global installation:
# Convert a document to Markdown
npx @bulkgrid/bulkparse parse document.docx
# Export structured JSON
npx @bulkgrid/bulkparse parse table.csv --to json
# Inspect a PDF and its OCR-routing recommendations
npx @bulkgrid/bulkparse inspect document.pdf
After a global CLI installation, run bulkparse directly in place of
npx @bulkgrid/bulkparse.
To build from this checkout, use cargo build --release -p bulkparse-cli --locked.
Convert a directory with npx @bulkgrid/bulkparse batch ./documents --output ./parsed. Batch processing is sequential, writes per-file results, and continues after individual errors. Choose an output directory outside the input directory; existing output files are not overwritten.
CLI exit codes: 0 complete · 2 partial · 1 failure. Partial results can contain useful extracted content; inspect their diagnostics. Native PDF conversion currently reports partial coverage by design.
Run npx @bulkgrid/bulkparse capabilities for build-specific format support and npx @bulkgrid/bulkparse schema for the structured output schema.
Keep supported Office and EPUB images as assets in structured output, or save them alongside Markdown for applications and image-capable agents:
bulkparse parse document.docx -o document.md --export-images
Image retention is bounded and can be disabled with --no-images or
extract_images: false. Embedded images render as alt text in Markdown; exporting
assets does not add image links or an asset section. Structured output retains
resolved image references and the export summary lists saved files. PDF image
export is not supported. Images are not interpreted automatically. See
image support and limits.
Use the Parse documents to Markdown skill to let a coding agent parse documents or entire folders into Markdown with BulkParse. It covers CLI setup, partial-result diagnostics, PDF inspection, local OCR for scanned PDFs and images, and output verification.
Install it directly from GitHub with the Skills CLI, without cloning this repository:
npx skills add bulkgrid/bulkparse --skill parse-documents-to-markdown
Choose your coding agent when prompted. The skill runs the BulkParse CLI through
npx, which fetches the prebuilt package on first use; no source checkout is
needed. OCR models and native libraries require an additional
setup step.
Previously installed bulkparse-markdown? Install parse-documents-to-markdown
in the same scope, then remove the old skill. For a global installation:
npx skills add bulkgrid/bulkparse --skill parse-documents-to-markdown -g
npx skills remove bulkparse-markdown -g
To try local changes from this source checkout:
npx skills add ./skills/parse-documents-to-markdown
Example request:
Use parse-documents-to-markdown to parse ./documents into Markdown in ./converted and report any files with incomplete extraction.
From file uploads to searchable knowledge. Use BulkParse to prepare documents for retrieval, give agents readable source material, normalize an Office archive, or embed document conversion in your application. Build your first conversion
The default build enables the native PDF, DOCX and Office readers.
| Family | Extensions |
|---|---|
.pdf |
|
| Word | .doc, .docx, .docm |
| Excel | .xls, .xlsx, .xlsm, .xlsb |
| PowerPoint | .ppt, .pps, .pot, .pptx, .pptm, .ppsx, .ppsm |
| OpenDocument | .odt, .ods, .odp |
| Rich text and ebooks | .rtf, .epub |
| Delimited data | .csv, .tsv |
| Text and Markdown | .txt, .md |
| Jupyter notebooks | .ipynb |
Support means extraction is implemented, not that every feature of a format is reproduced. See the Office format contracts and implementation notes for capabilities and limitations. The Office readers are implemented in BulkParse; no external document converter is required at runtime.
Compare the whole workload, then inspect the details. Four views cover overall document conversion, results by format, PDF inspection and OCR. Each published result links to its corpus, settings and raw measurements; results from different runs are not combined into a new ranking.
Tested on 200 real-world documents across 19 formats and eight engines. One full-corpus pass displayed per engine on an Apple M3 Max with 36 GiB RAM. BulkParse was measured November 15, 2026; the other engines November 13. OCR was disabled.
BulkParse’s row and per-format results use its latest 200-document run. The other engines use the eight-engine comparison run. Each displayed row uses one sequential pass in a fresh worker without a full-corpus warm-up, measured on AC power. BulkParse shows the best of three checks—the same run had the lowest peak memory and fastest corpus time; all three are in the linked report. Other engines use one measured pass. These are separate runs on the identical corpus.
| Engine | Nonempty outputs | Formats with output | Median ms¹ | Attempt time s¹ | CPU s² | Peak RSS MiB³ |
|---|---|---|---|---|---|---|
| BulkParse | 200/200 | 19/19 | 3.26 | 13.84 | 13.74 | 1,693.5 |
| AnyDoc | 185/200 | 15/19 | 5.27 | 13.72 | 13.67 | 2,615.8 |
| Docling | 191/200 | 15/19 | 722.35 | 800.28 | ≥ 724.97 | ≥ 3,278.8 |
| MarkItDown | 128/200 | 13/19 | 73.69 | 140.33 | 147.93 | 3,075.5 |
| Pandoc | 102/200 | 8/19 | 101.74 | 59.75 | 58.02 | 2,130.9 |
| Mammoth | 20/200 | 2/19 | 36.46 | 1.79 | 1.79 | 665.8 |
| LibreOffice | 154/200 | 15/19 | 877.57 | 582.57 | ≥ 310.34 | ≥ 4,701.0 |
| Unstructured | 158/200 | 15/19 | 252.40 | 332.84 | ≥ 241.03 | ≥ 976.2 |
Nonempty output counts use all 200 documents as the denominator. Formats with output counts extensions with at least one nonempty result.
¹ Unsupported means outside the configured adapter’s format profile, not the engine’s complete capability list. Failed attempts include unsupported variants within an attempted extension. Median is across nonempty outputs from one conversion per document. Attempt time includes failed attempts and excludes unsupported inputs. Each engine has a different successful subset: these totals and medians are not an equal-workload ranking. Each displayed result uses one measured pass without a full-corpus warm-up. Worker startup is excluded, first-use work remains included, and required CLI launches are included. Engine order and OS cache effects are not averaged out in one pass.
² CPU includes the worker and completed child processes. “≥” means a killed worker prevented complete CPU accounting.
³ macOS /usr/bin/time -l reports high-water RSS, including initialization, output transport and waited-for child-process peaks. It is not the simultaneous sum of the process tree. “≥” means killed workers may lack memory samples. Different workloads and model imports affect these values; no whole-system memory winner is claimed.
Quality review is pending. Nonempty output measures coverage, not extraction accuracy. The planned assessment compares completeness, structure, formatting and cleanliness against source references on the same 40-document sample across engines. Overall scores will use equal format weights, with failed and unsupported inputs counted as zero; supported-only quality will be reported separately. This will be labelled assistant-reviewed, not independent blind judging. Quality review protocol.
The corpus includes 112 development documents and 88 selected before conversion, so it is not an entirely unseen test set. Full methodology, configurations and raw results.
The same 200 documents and engine runs shown above underpin this breakdown. Cells show nonempty outputs (%) on the first line and median successful conversion time (ms) on the second; — means unsupported or no successful timing. Percentages measure output coverage, not extraction accuracy. Tiny samples and different successful subsets limit speed comparisons.
| Format | BulkParse | AnyDoc | Docling | MarkItDown | Pandoc | Mammoth | LibreOffice | Unstructured |
|---|---|---|---|---|---|---|---|---|
| csv | 100% 0.49 ms |
100% 0.81 ms |
94.7% 11.49 ms |
89.5% 5.15 ms |
100% 54.74 ms |
— | 94.7% 647.37 ms |
36.8% 58.08 ms |
| doc | 100% 1.43 ms |
100% 1.00 ms |
100% 2,984.76 ms |
— | — | — | 100% 792.97 ms |
100% 727.35 ms |
| docm | 100% 2.55 ms |
100% 3.20 ms |
0% — |
100% 73.62 ms |
— | 100% 36.04 ms |
100% 707.77 ms |
0% — |
| docx | 100% 2.91 ms |
100% 2.67 ms |
100% 151.28 ms |
100% 117.17 ms |
100% 89.49 ms |
100% 36.89 ms |
100% 783.20 ms |
100% 46.38 ms |
| epub | 100% 9.53 ms |
100% 16.12 ms |
100% 723.73 ms |
100% 131.81 ms |
100% 1,328.67 ms |
— | — | 100% 7,143.06 ms |
| ipynb | 100% 0.46 ms |
— | — | 100% 3.60 ms |
100% 77.10 ms |
— | — | — |
| md | 100% 0.39 ms |
— | 100% 11.41 ms |
100% 3.95 ms |
100% 68.74 ms |
— | — | 100% 23.85 ms |
| odp | 100% 8.44 ms |
100% 12.63 ms |
100% 174.90 ms |
— | — | — | 100% 1,511.46 ms |
— |
| ods | 100% 39.18 ms |
84.2% 15.30 ms |
94.7% 2,322.19 ms |
— | — | — | 100% 2,047.78 ms |
— |
| odt | 100% 1.44 ms |
100% 1.83 ms |
100% 66.49 ms |
— | 100% 69.59 ms |
— | 100% 704.17 ms |
100% 242.39 ms |
| 100% 8.70 ms |
100% 14.55 ms |
100% 1,421.60 ms |
100% 199.58 ms |
— | — | — | 100% 231.64 ms |
|
| ppt | 100% 0.87 ms |
100% 0.57 ms |
100% 901.47 ms |
— | — | — | 100% 1,352.87 ms |
100% 816.31 ms |
| pptx | 100% 8.73 ms |
100% 9.16 ms |
100% 2,517.39 ms |
100% 46.74 ms |
— | — | 100% 5,809.23 ms |
100% 127.74 ms |
| rtf | 100% 5.91 ms |
100% 12.14 ms |
100% 1,642.36 ms |
— | 100% 252.28 ms |
— | 100% 939.77 ms |
100% 429.80 ms |
| tsv | 100% 1.93 ms |
— | — | 100% 5.08 ms |
100% 188.32 ms |
— | 100% 1,106.93 ms |
100% 333.08 ms |
| txt | 100% 2.33 ms |
— | — | 100% 10.89 ms |
— | — | 100% 929.16 ms |
100% 3,793.67 ms |
| xls | 100% 1.05 ms |
100% 1.73 ms |
100% 784.82 ms |
100% 39.43 ms |
— | — | 100% 843.45 ms |
94.4% 74.63 ms |
| xlsm | 100% 67.69 ms |
83.3% 39.02 ms |
100% 1,872.60 ms |
100% 3,006.90 ms |
— | — | 83.3% 6,245.45 ms |
83.3% 1,924.59 ms |
| xlsx | 100% 3.97 ms |
100% 7.39 ms |
100% 80.82 ms |
100% 139.09 ms |
— | — | 94.4% 1,146.64 ms |
100% 216.88 ms |
Latest spreadsheet checks and identical-input timings · November 13 identical-input comparisons · Detailed conversion outcomes
200 PDFs from opendataloader-bench · OCR off · eight engines, nine configurations. Measured November 12, 2026 on an Apple M3 Max with 36 GiB RAM, using one excluded warm-up and five rotating sequential passes.
Quality scores range from 0 to 1; higher is better. Time includes PDF-to-Markdown conversion and BulkParse’s inspection. Lower time and memory are better. Measurements apply to the builds and configurations recorded in the linked report.
| Engine / profile | Overall quality ↑ | Time / 200 PDFs ↓ | Peak memory MiB ↓ |
|---|---|---|---|
| BulkParse | 0.901 | 0.440 s | 169.0 |
| LiteParse | 0.886 | 0.733 s | 64.2 |
| pdf-inspector | 0.870 | 0.870 s | 169.4 |
| AnyDoc | 0.867 | 1.217 s | 174.1 |
| OpenDataLoader | 0.843 | 1.588 s | 724.7 |
| MarkItDown | 0.589 | 15.403 s | 297.8 |
| PyMuPDF4LLM — native | 0.735 | 15.668 s | 476.4 |
| PyMuPDF4LLM — learned layout | 0.866 | 17.319 s | 739.8 |
| Docling | 0.887 | 64.490 s | 1589.3 |
Lead on speed. Keep the structure. BulkParse recorded the shortest median conversion time and the highest overall, reading-order, table and heading scores across the tested configurations. Its 0.440-second median uses 40% less conversion time than the next-fastest configuration. Bold values mark the best result in each metric; BulkParse did not have the lowest memory use. These results apply to this corpus and these configurations, not every document or deployment.
| Engine / profile | Reading order (NID) ↑ | Tables (TEDS) ↑ | Headings (MHS) ↑ |
|---|---|---|---|
| BulkParse | 0.919 | 0.887 | 0.860 |
| LiteParse | 0.916 | 0.818 | 0.824 |
| pdf-inspector | 0.911 | 0.800 | 0.777 |
| AnyDoc | 0.906 | 0.814 | 0.772 |
| OpenDataLoader | 0.913 | 0.483 | 0.757 |
| MarkItDown | 0.844 | 0.273 | 0.000 |
| PyMuPDF4LLM — native | 0.885 | 0.403 | 0.423 |
| PyMuPDF4LLM — learned layout | 0.906 | 0.773 | 0.782 |
| Docling | 0.902 | 0.879 | 0.836 |
NID measures reading order, TEDS tables and MHS headings. All 200 inputs remain in scoring. BulkParse returned partial-coverage results for all 200. TEDS covers 42 documents, MHS 107 and NID all 200; overall averages each document’s available metrics.
Native and learned-layout profiles are reported separately. Model choices, thread counts and fallback converters vary by configuration; see the complete settings. OCR is disabled throughout. Startup/model loading is excluded; reads, conversion, Markdown export, writes and bookkeeping are included. Peak memory is resident memory (RSS), including initialization and warm-up. All attempted inputs and failures remain visible in the results.
This corpus has informed development. Treat these as development/regression results, not an unseen generalization estimate.
Full results, timing ranges and configurations · Reproduce the comparison
24 authored cases, 26 pages, nine languages · November 12, 2026 · Linux ARM64 containers on an Apple M3 Max. Each profile gets one CPU, 4 GiB RAM, one warm-up and five sequential passes. Lower error rates, time and memory are better.
| OCR profile | Character error rate | Word error rate | Warm time / 24 cases | CPU time | Peak RSS |
|---|---|---|---|---|---|
| Tesseract · fast | 5.27% | 17.77% | 5.49 s | 5.48 s | 259.3 MiB |
| RapidOCRLite · tiny | 3.73% | 8.29% | 30.41 s | 30.37 s | 345.9 MiB |
| PaddleOCR · tiny | 4.02% | 9.72% | 33.06 s | 33.02 s | 1367.0 MiB |
| RapidOCR · small | 3.19% | 4.74% | 35.64 s | 35.55 s | 805.1 MiB |
The trade-off is visible: Tesseract fast had the shortest time and lowest memory; RapidOCR small had the lowest text error rates. RapidOCRLite tiny used substantially less memory than the tested RapidOCR small and PaddleOCR tiny profiles. All four returned output without conversion errors.
These profiles use different model sizes and settings. This is a synthetic OCR-stage comparison, excluding PDF rendering and BulkParse’s layout reconstruction; it does not measure the current integrated adaptive detector or establish production multilingual accuracy. RapidOCRLite is a prerelease. ARM64 container results are not x86 server measurements.
Full OCR results, versions, models and startup measurements · OCR protocol
All bindings use the same Rust conversion path. Native packages include prebuilt binaries for supported platforms; source-build instructions are linked below.
npm install @bulkgrid/bulkparse
Save the example as an .mjs file, or use a .js file in a package with "type": "module". See the Node binding guide for source builds and supported platforms:
import { parse } from '@bulkgrid/bulkparse';
async function main() {
const result = await parse(Buffer.from('# Hello from BulkParse'), {
filename: 'hello.md',
});
console.log(result.markdown);
console.log(result.document.blocks);
console.log(result.diagnostics);
}
main().catch(console.error);
Conversion is asynchronous. TypeScript declarations ship with the binding.
| API | Input | Result |
|---|---|---|
parse(bytes, options) |
Buffer or Uint8Array | Document model, Markdown and diagnostics |
parseFile(path, options) |
Input file path | Document model, Markdown and diagnostics |
parseFileToMarkdown(input, output, options) |
Input and output file paths | Writes Markdown; returns status and metadata |
Use the Markdown file API when you do not need the complete model in JavaScript. It stages output and refuses to overwrite an existing file.
python -m pip install bulkparse
See the Python binding guide for source builds:
from bulkparse import parse
result = parse(b"# Hello from BulkParse", filename="hello.md")
print(result["markdown"])
print(result["document"]["blocks"])
print(result["diagnostics"])
Native conversion releases the GIL. File-based conversion is also available.
cargo add bulkparse
use bulkparse::{parse, Options};
fn main() -> Result<(), Box<dyn std::error::Error>> {
let result = parse(
b"# Hello from BulkParse",
Some("hello.md"),
Options::default(),
)?;
println!("{}", result.markdown);
Ok(())
}
npm install @bulkgrid/bulkparse-wasm
Import the package in your browser application. Serve the generated WASM asset with the application; see the WASM guide for bundling and source builds:
import { init, parse } from '@bulkgrid/bulkparse-wasm';
await init();
const result = parse(new TextEncoder().encode('# Hello from BulkParse'), {
filename: 'hello.md',
});
console.log(result.markdown);
The included browser example runs conversion in a Web Worker. Files are processed inside the browser without uploading them to a server. Broader browser compatibility remains under validation.
JSON is the canonical document model; Markdown is its readable projection. Results include document blocks, status, diagnostics and coverage, with source page, row, cell or package-part information where available. Conversion bindings also return Markdown and rendering diagnostics. The current schema is 0.8.
Each diagnostic identifies missing content, a formatting limitation, or an informational notice, with evidence marked detected or unverified. Use these fields to distinguish confirmed omissions from broad capability warnings. The legacy content_loss flag, partial status and strict-mode behavior remain conservative: they also cover formatting and uncertainty. complete does not prove perfect extraction. See diagnostic categories and interpretation.
Configurable limits cover input size, extracted text, nodes, depth, table cells, pages and archive expansion. For untrusted uploads, combine these with isolated workers and OS resource limits; parser limits are not a hard memory/CPU sandbox. The optional worker pool adds bounded queues, persistent processes, deadlines, cancellation and crash recovery.
Schema, provenance and operational details
Turn scanned pages into text your application can use, wherever you deploy it. BulkParse integrates OCR into its PDF conversion pipeline, combining native extraction with OCR for pages the inspector identifies as candidates. Run the OCR-enabled Rust or CLI pipeline in your server environment or desktop workflow. Once configured, conversion invokes the backend for eligible pages and retains source-page information in the result.
Enable OCR: provision the native libraries and models. Rust, Node and Python reuse native model sessions without a Python worker. The OCR-enabled CLI and native bindings accept scanned PDFs, PNG, JPEG, GIF, WebP and TIFF, including multiple frames. Layout and table models support headings, columns and scanned tables alongside conservative merged-cell rules. Recognition and complex cell assignments remain imperfect. WASM accepts OCR evidence from a browser or host engine; it does not bundle inference. CLI batch OCR is not implemented. See binding APIs, setup and limits.
Historical experimental adapter (not part of the native pipeline): an optional GLM-OCR layout-service adapter demonstrates semantic regions, scanned tables with merged cells and LaTeX formulas through the historical process-provider crate. The native CLI does not accept its process configuration. It requires a separately provisioned full GLM-OCR SDK server. Protocol, rendering and model-assembly tests are available; live GLM recognition quality remains unverified. Reference evaluation.
Inspection API · OCR provider interface · OCR engine benchmarks
BulkParse is ready to evaluate and build against, with these boundaries:
--liftoff-only because of a known optimizing-compiler memory issue.| Start here | Details |
|---|---|
| Architecture | Core, document model and language bindings |
| Agent skill | Document-to-Markdown workflow for coding agents |
| Format contracts | Office/EPUB capabilities and remaining gaps |
| Implementation notes | Detailed scope, options and limits |
| PDF inspection | Page classification and OCR routing |
| Worker pool | Bounded native processing and lifecycle management |
| Validation | Validation commands and platform coverage |
| Roadmap | Planned development |
| Contributing | Development workflow |
Maintainers: release pipelines and registry setup cover npm, PyPI, crates.io, WebAssembly and CLI downloads.
cargo fmt --all --check
cargo test --workspace --all-features
cargo test -p bulkparse --no-default-features
cargo clippy --workspace --all-targets --all-features -- -D warnings
Authored fixtures are reproducible and included under the project license. Upstream benchmark inputs are tracked by source URLs and hashes and are not bundled. The benchmark evidence includes settings, per-document measurements and scores; generated binaries, model weights and extracted third-party document text are excluded.
Make your documents part of what your application knows. Build with BulkParse for document conversion in your stack, or explore Bulkgrid for web content collection and searchable knowledge workflows.
If this is useful to your work, ⭐ star Bulkgrid on GitHub and help more developers find the project.
bulkgrid/bulkparse is a public repo on GitHub by bulkgrid. Fast document parsing in Rust. Turn PDFs, Office files, spreadsheets and more into Markdown and structured JSON also with built-in OCR. MIT licensed.
It declares the MIT license on GitHub.
Its maker has not tagged a system, so it is unknown here. Its README says what it needs.
Open "Take it" on its page: Take My Repo writes an install plan for your machine and hands it to your AI agent (Claude Code, Codex or Cursor), which asks you before each step. Take My Repo has not tested it on any machine.
Its last change on GitHub was on 2026-11-22. Take My Repo does not judge from that whether it is maintained.
Nobody has reviewed it on Take My Repo yet, which says nothing about its quality.
Take My Repo has not tested this on your machine. Requirements come from the project's own documentation.