diff --git a/LICENSE-3rdparty.csv b/LICENSE-3rdparty.csv
index bc99a4da800..0748c22d08c 100644
--- a/LICENSE-3rdparty.csv
+++ b/LICENSE-3rdparty.csv
@@ -24,6 +24,16 @@ anyhow,https://github.com/dtolnay/anyhow,MIT OR Apache-2.0,David Tolnay <dtolnay
 arbitrary,https://github.com/rust-fuzz/arbitrary,MIT OR Apache-2.0,"The Rust-Fuzz Project Developers, Nick Fitzgerald <fitzgen@gmail.com>, Manish Goregaokar <manishsmail@gmail.com>, Simonas Kazlauskas <arbitrary@kazlauskas.me>, Brian L. Troutwine <brian@troutwine.us>, Corey Farwell <coreyf@rwell.org>"
 arc-swap,https://github.com/vorner/arc-swap,MIT OR Apache-2.0,Michal 'vorner' Vaner <vorner@vorner.cz>
 arrayvec,https://github.com/bluss/arrayvec,MIT OR Apache-2.0,bluss
+arrow-array,https://github.com/apache/arrow-rs,Apache-2.0 AND MIT,Apache Arrow <dev@arrow.apache.org>
+arrow-buffer,https://github.com/apache/arrow-rs,Apache-2.0,Apache Arrow <dev@arrow.apache.org>
+arrow-cast,https://github.com/apache/arrow-rs,Apache-2.0,Apache Arrow <dev@arrow.apache.org>
+arrow-cmp,https://github.com/apache/arrow-rs,Apache-2.0,Apache Arrow <dev@arrow.apache.org>
+arrow-data,https://github.com/apache/arrow-rs,Apache-2.0,Apache Arrow <dev@arrow.apache.org>
+arrow-ipc,https://github.com/apache/arrow-rs,Apache-2.0,Apache Arrow <dev@arrow.apache.org>
+arrow-json,https://github.com/apache/arrow-rs,Apache-2.0,Apache Arrow <dev@arrow.apache.org>
+arrow-ord,https://github.com/apache/arrow-rs,Apache-2.0,Apache Arrow <dev@arrow.apache.org>
+arrow-schema,https://github.com/apache/arrow-rs,Apache-2.0,Apache Arrow <dev@arrow.apache.org>
+arrow-select,https://github.com/apache/arrow-rs,Apache-2.0,Apache Arrow <dev@arrow.apache.org>
 ascii-canvas,https://github.com/lalrpop/ascii-canvas,Apache-2.0 OR MIT,Niko Matsakis <niko@alum.mit.edu>
 assert-json-diff,https://github.com/davidpdrsn/assert-json-diff,MIT,David Pedersen <david.pdrsn@gmail.com>
 async-channel,https://github.com/smol-rs/async-channel,Apache-2.0 OR MIT,Stjepan Glavina <stjepang@gmail.com>
@@ -261,6 +271,7 @@ fiat-crypto,https://github.com/mit-plv/fiat-crypto,MIT OR Apache-2.0 OR BSD-1-Cl
 find-msvc-tools,https://github.com/rust-lang/cc-rs,MIT OR Apache-2.0,The find-msvc-tools Authors
 findshlibs,https://github.com/gimli-rs/findshlibs,MIT OR Apache-2.0,The findshlibs Authors
 fixedbitset,https://github.com/petgraph/fixedbitset,MIT OR Apache-2.0,bluss
+flatbuffers,https://github.com/google/flatbuffers,Apache-2.0,"Robert Winslow <hello@rwinslow.com>, FlatBuffers Maintainers"
 flate2,https://github.com/rust-lang/flate2-rs,MIT OR Apache-2.0,"Alex Crichton <alex@alexcrichton.com>, Josh Triplett <josh@joshtriplett.org>"
 float-cmp,https://github.com/mikedilger/float-cmp,MIT,Mike Dilger <mike@mikedilger.com>
 fluent-uri,https://github.com/yescallop/fluent-uri-rs,MIT,Scallop Ye <yescallop@gmail.com>
@@ -386,6 +397,12 @@ lambda_runtime_api_client,https://github.com/aws/aws-lambda-rust-runtime,Apache-
 lazy_static,https://github.com/rust-lang-nursery/lazy-static.rs,MIT OR Apache-2.0,Marvin Löbel <loebel.marvin@gmail.com>
 left-right,https://github.com/jonhoo/left-right,MIT OR Apache-2.0,Jon Gjengset <jon@thesquareplanet.com>
 levenshtein_automata,https://github.com/tantivy-search/levenshtein-automata,MIT,Paul Masurel <paul.masurel@gmail.com>
+lexical-core,https://github.com/Alexhuszagh/rust-lexical,MIT OR Apache-2.0,Alex Huszagh <ahuszagh@gmail.com>
+lexical-parse-float,https://github.com/Alexhuszagh/rust-lexical,MIT OR Apache-2.0,Alex Huszagh <ahuszagh@gmail.com>
+lexical-parse-integer,https://github.com/Alexhuszagh/rust-lexical,MIT OR Apache-2.0,Alex Huszagh <ahuszagh@gmail.com>
+lexical-util,https://github.com/Alexhuszagh/rust-lexical,MIT OR Apache-2.0,Alex Huszagh <ahuszagh@gmail.com>
+lexical-write-float,https://github.com/Alexhuszagh/rust-lexical,MIT OR Apache-2.0,Alex Huszagh <ahuszagh@gmail.com>
+lexical-write-integer,https://github.com/Alexhuszagh/rust-lexical,MIT OR Apache-2.0,Alex Huszagh <ahuszagh@gmail.com>
 libc,https://github.com/rust-lang/libc,MIT OR Apache-2.0,The Rust Project Developers
 libm,https://github.com/rust-lang/compiler-builtins,MIT,"Alex Crichton <alex@alexcrichton.com>, Amanieu d'Antras <amanieu@gmail.com>, Jorge Aparicio <japaricious@gmail.com>, Trevor Gross <tg@trevorgross.com>"
 libredox,https://gitlab.redox-os.org/redox-os/libredox,MIT,4lDO2 <4lDO2@protonmail.com>
@@ -442,6 +459,7 @@ normalize-line-endings,https://github.com/derekdreery/normalize-line-endings,Apa
 nu-ansi-term,https://github.com/nushell/nu-ansi-term,MIT,"ogham@bsago.me, Ryan Scheel (Havvy) <ryan.havvy@gmail.com>, Josh Triplett <josh@joshtriplett.org>, The Nushell Project Developers"
 num,https://github.com/rust-num/num,MIT OR Apache-2.0,The Rust Project Developers
 num-bigint,https://github.com/rust-num/num-bigint,MIT OR Apache-2.0,The Rust Project Developers
+num-bigint,https://github.com/rust-num/num-bigint,MIT OR Apache-2.0,The num-bigint Authors
 num-bigint-dig,https://github.com/dignifiedquire/num-bigint,MIT OR Apache-2.0,"dignifiedquire <dignifiedquire@gmail.com>, The Rust Project Developers"
 num-cmp,https://github.com/lifthrasiir/num-cmp,MIT OR Apache-2.0,Kang Seonghoon <public+git@mearie.org>
 num-complex,https://github.com/rust-num/num-complex,MIT OR Apache-2.0,The Rust Project Developers
@@ -500,6 +518,7 @@ papergrid,https://github.com/zhiburt/tabled,MIT,Maxim Zhiburt <zhiburt@gmail.com
 parking,https://github.com/smol-rs/parking,Apache-2.0 OR MIT,"Stjepan Glavina <stjepang@gmail.com>, The Rust Project Developers"
 parking_lot,https://github.com/Amanieu/parking_lot,MIT OR Apache-2.0,Amanieu d'Antras <amanieu@gmail.com>
 parking_lot_core,https://github.com/Amanieu/parking_lot,MIT OR Apache-2.0,Amanieu d'Antras <amanieu@gmail.com>
+parquet,https://github.com/apache/arrow-rs,Apache-2.0,Apache Arrow <dev@arrow.apache.org>
 parse-size,https://github.com/kennytm/parse-size,MIT,kennytm <kennytm@gmail.com>
 paste,https://github.com/dtolnay/paste,MIT OR Apache-2.0,David Tolnay <dtolnay@gmail.com>
 pbkdf2,https://github.com/RustCrypto/password-hashes/tree/master/pbkdf2,MIT OR Apache-2.0,RustCrypto Developers
@@ -667,6 +686,7 @@ security-framework-sys,https://github.com/kornelski/rust-security-framework,MIT
 seize,https://github.com/ibraheemdev/seize,MIT,Ibraheem Ahmed <ibraheem@ibraheem.ca>
 semver,https://github.com/dtolnay/semver,MIT OR Apache-2.0,David Tolnay <dtolnay@gmail.com>
 separator,https://github.com/saghm/rust-separator,MIT,Saghm Rossi <saghmrossi@gmail.com>
+seq-macro,https://github.com/dtolnay/seq-macro,MIT OR Apache-2.0,David Tolnay <dtolnay@gmail.com>
 serde,https://github.com/serde-rs/serde,MIT OR Apache-2.0,"Erick Tryzelaar <erick.tryzelaar@gmail.com>, David Tolnay <dtolnay@gmail.com>"
 serde-tuple-vec-map,https://github.com/daboross/serde-tuple-vec-map,MIT,David Ross <daboross@daboross.net>
 serde-value,https://github.com/arcnmx/serde-value,MIT,arcnmx
diff --git a/docs/internals/parquet-bulk-load.md b/docs/internals/parquet-bulk-load.md
new file mode 100644
index 00000000000..27f3a63d430
--- /dev/null
+++ b/docs/internals/parquet-bulk-load.md
@@ -0,0 +1,38 @@
+# Parquet bulk load (cli only)
+
+Index a parquet file without merges.
+
+ 
+
+```
+quickwit tool local-ingest --index idx --input-path file:///data/x.parquet --num-pipelines N
+```
+
+## How it works
+
+```
+CLI
+ ├─ plan = ParquetLoadPlan::try_new(file) // parses the footer once
+ ├─ source_loader: File → ParquetSourceFactory { plan }
+ ├─ IndexingService::new(...).with_source_loader(source_loader)
+ └─ SpawnPipeline + DetachIndexingPipeline × N → ParquetSource { plan }
+```
+
+- Sources pull row groups from the plan, decode them on the
+blocking runtime, and emit JSON documents (`arrow_json`).
+- Only the CLI replaces the source loader, so servers can't run a Parquet
+source.
+
+## Failure handling
+
+No checkpoint. On failure, the CLI stops actors, attempts to clear the
+index, and reports cleanup errors alongside the load error.
+Rollback is best effort: detached uploads can outlive actor shutdown after an
+early pipeline failure. Process termination is not covered.
+
+## Benchmark settings
+
+Size splits with `split_num_docs_target`; use `no_merge` to keep them
+unchanged when running a server afterwards.
+`--num-pipelines` defaults to half the CPUs: 16 pipelines was the fastest on an
+m8gd.8xlarge (32 vCPUs) with 5M-document splits.
\ No newline at end of file
diff --git a/docs/reference/cli.md b/docs/reference/cli.md
index e4cbaa5e1e3..22ad95cf013 100644
--- a/docs/reference/cli.md
+++ b/docs/reference/cli.md
@@ -761,7 +761,7 @@ Performs utility operations. Requires a node config.
 
 ### tool local-ingest
 
-Indexes NDJSON documents locally.  
+Indexes NDJSON or Parquet documents locally.  
 `quickwit tool local-ingest [args]`
 
 *Synopsis*
@@ -771,6 +771,8 @@ quickwit tool local-ingest
     --index <index>
     [--input-path <input-path>]
     [--input-format <input-format>]
+    [--num-pipelines <num-pipelines>]
+    [--batch-num-rows <batch-num-rows>]
     [--overwrite]
     [--transform-script <transform-script>]
     [--keep-cache]
@@ -782,10 +784,14 @@ quickwit tool local-ingest
 |-----------------|-------------|--------:|
 | `--index` | ID of the target index |  |
 | `--input-path` | Location of the input file. |  |
-| `--input-format` | Format of the input data. | `json` |
+| `--input-format` | Format of the input documents: `json` or `plain`. Parquet rows are indexed as `json` documents. | `json` |
+| `--num-pipelines` | Number of indexing pipelines running in parallel. Values greater than 1 require a `.parquet` input file. Defaults to half the number of CPUs for a `.parquet` input file, 1 otherwise. |  |
+| `--batch-num-rows` | Number of Parquet rows decoded at once. Only valid with a `.parquet` input file. |  |
 | `--overwrite` | Overwrites pre-existing index. |  |
 | `--transform-script` | VRL program to transform docs before ingesting. |  |
 | `--keep-cache` | Does not clear local cache directory upon completion. |  |
+
+An `--input-path` ending with `.parquet` is bulk loaded by several pipelines without merging (benchmark only, requires the `parquet` Cargo feature). The index must be empty (`--overwrite` clears it); cleanup on failure is best effort. See `docs/internals/parquet-bulk-load.md`.
 ### tool extract-split
 
 Downloads and extracts a split to a directory.  
diff --git a/quickwit/Cargo.lock b/quickwit/Cargo.lock
index 05da65b9ec2..0b17b3d0613 100644
--- a/quickwit/Cargo.lock
+++ b/quickwit/Cargo.lock
@@ -67,6 +67,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75"
 dependencies = [
  "cfg-if",
+ "const-random",
  "getrandom 0.3.4",
  "once_cell",
  "serde",
@@ -183,7 +184,7 @@ version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
 dependencies = [
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -194,7 +195,7 @@ checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
 dependencies = [
  "anstyle",
  "once_cell_polyfill",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -224,6 +225,156 @@ version = "0.7.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d3fb67a6e08acf24fdeccbac2cb6ac4305825bd1f117462e0e6f2f193345ad56"
 
+[[package]]
+name = "arrow-array"
+version = "60.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51dff6e4b9f158864a0aeb6a131ad53858ecbae7a2fc8989307b9b3c6b2f122e"
+dependencies = [
+ "ahash",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "chrono",
+ "chrono-tz",
+ "half",
+ "hashbrown 0.17.1",
+ "num-complex",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "arrow-buffer"
+version = "60.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7235b863533e9db3ab86905b4521251de11226275b436ff3cb2d0010558d1c5"
+dependencies = [
+ "bytes",
+ "half",
+ "num-bigint 0.5.1",
+ "num-traits",
+]
+
+[[package]]
+name = "arrow-cast"
+version = "60.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d52cf840f0c34aeeb7e8b05aba72d66878e6c001827f423331f0b260209e7b7e"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-ord",
+ "arrow-schema",
+ "arrow-select",
+ "atoi 3.1.0",
+ "base64 0.23.0",
+ "chrono",
+ "half",
+ "lexical-core",
+ "num-traits",
+ "ryu",
+]
+
+[[package]]
+name = "arrow-cmp"
+version = "60.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73a0e9adb28d95739fabcdae637261a2c14e618caf58ba1b88857120f9ee2687"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-schema",
+]
+
+[[package]]
+name = "arrow-data"
+version = "60.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5aa06d5e22786c4966ffc4d2f171d0cb65d95f6bdea108a14e8c335e9faa437f"
+dependencies = [
+ "arrow-buffer",
+ "arrow-schema",
+ "half",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "arrow-ipc"
+version = "60.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86c523472d22e31f984df7a44fc36e6323d3c9b05ffe53d267ee4c3aa7c128d2"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "arrow-select",
+ "flatbuffers",
+]
+
+[[package]]
+name = "arrow-json"
+version = "60.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "342fc6600a93a48038d853431803c941436b7b51f756763e76cad9784b7e3718"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-cast",
+ "arrow-ord",
+ "arrow-schema",
+ "arrow-select",
+ "chrono",
+ "half",
+ "indexmap 2.14.0",
+ "itoa",
+ "lexical-core",
+ "memchr",
+ "num-traits",
+ "ryu",
+ "serde_core",
+ "serde_json",
+ "simdutf8",
+]
+
+[[package]]
+name = "arrow-ord"
+version = "60.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a7ac2c6a9cdc782fa9548d3763461eaec8c93347e297fddbaa44807e70a3698"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-cmp",
+ "arrow-data",
+ "arrow-schema",
+ "arrow-select",
+]
+
+[[package]]
+name = "arrow-schema"
+version = "60.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f85a9a58cd03560526b0066487574aacb9008e413504fa0ee23d61141e96c338"
+
+[[package]]
+name = "arrow-select"
+version = "60.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba3482b7d03bf4a3bf0b195f08a7f2b071595ccd54897e35b975ac63d3104977"
+dependencies = [
+ "ahash",
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-cmp",
+ "arrow-data",
+ "arrow-schema",
+ "num-traits",
+]
+
 [[package]]
 name = "ascii-canvas"
 version = "4.0.0"
@@ -409,6 +560,15 @@ dependencies = [
  "num-traits",
 ]
 
+[[package]]
+name = "atoi"
+version = "3.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7a8bbe9949e43a1edaa043038c68703b04774156afdfb62ba2cef5bf93d67be"
+dependencies = [
+ "num-traits",
+]
+
 [[package]]
 name = "atomic-waker"
 version = "1.1.2"
@@ -1528,7 +1688,7 @@ dependencies = [
  "data-encoding",
  "half",
  "nom 7.1.3",
- "num-bigint",
+ "num-bigint 0.4.8",
  "num-rational",
  "num-traits",
  "separator",
@@ -1803,7 +1963,7 @@ version = "3.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "faf9468729b8cbcea668e36183cb69d317348c2e08e994829fb56ebfdfbaac34"
 dependencies = [
- "windows-sys 0.48.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -3029,7 +3189,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -3176,6 +3336,16 @@ version = "0.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99"
 
+[[package]]
+name = "flatbuffers"
+version = "25.12.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "35f6839d7b3b98adde531effaf34f0c2badc6f4735d26fe74709d8e513a96ef3"
+dependencies = [
+ "bitflags 2.13.0",
+ "rustc_version",
+]
+
 [[package]]
 name = "flate2"
 version = "1.1.9"
@@ -3742,6 +3912,7 @@ checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b"
 dependencies = [
  "cfg-if",
  "crunchy",
+ "num-traits",
  "zerocopy",
 ]
 
@@ -4139,7 +4310,7 @@ dependencies = [
  "libc",
  "percent-encoding",
  "pin-project-lite",
- "socket2 0.5.10",
+ "socket2 0.6.4",
  "tokio",
  "tower-service",
  "tracing",
@@ -4431,7 +4602,7 @@ checksum = "3640c1c38b8e4e43584d8df18be5fc6b0aa314ce6ebf51b53313d4306cca8e46"
 dependencies = [
  "hermit-abi",
  "libc",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -4792,6 +4963,63 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0c2cdeb66e45e9f36bfad5bbdb4d2384e70936afbee843c6f6543f0c551ebb25"
 
+[[package]]
+name = "lexical-core"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d8d125a277f807e55a77304455eb7b1cb52f2b18c143b60e766c120bd64a594"
+dependencies = [
+ "lexical-parse-float",
+ "lexical-parse-integer",
+ "lexical-util",
+ "lexical-write-float",
+ "lexical-write-integer",
+]
+
+[[package]]
+name = "lexical-parse-float"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52a9f232fbd6f550bc0137dcb5f99ab674071ac2d690ac69704593cb4abbea56"
+dependencies = [
+ "lexical-parse-integer",
+ "lexical-util",
+]
+
+[[package]]
+name = "lexical-parse-integer"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a7a039f8fb9c19c996cd7b2fcce303c1b2874fe1aca544edc85c4a5f8489b34"
+dependencies = [
+ "lexical-util",
+]
+
+[[package]]
+name = "lexical-util"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2604dd126bb14f13fb5d1bd6a66155079cb9fa655b37f875b3a742c705dbed17"
+
+[[package]]
+name = "lexical-write-float"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50c438c87c013188d415fbabbb1dceb44249ab81664efbd31b14ae55dabb6361"
+dependencies = [
+ "lexical-util",
+ "lexical-write-integer",
+]
+
+[[package]]
+name = "lexical-write-integer"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "409851a618475d2d5796377cad353802345cba92c867d9fbcde9cf4eac4e14df"
+dependencies = [
+ "lexical-util",
+]
+
 [[package]]
 name = "libc"
 version = "0.2.186"
@@ -4947,6 +5175,9 @@ name = "lz4_flex"
 version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ecbdfe44b1bd960b68170b417450a628c43f7cf56bb3c5317e61cb230ee7f226"
+dependencies = [
+ "twox-hash",
+]
 
 [[package]]
 name = "mach2"
@@ -5325,7 +5556,7 @@ version = "0.50.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
 dependencies = [
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -5334,7 +5565,7 @@ version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "35bd024e8b2ff75562e5f34e7f4905839deb4b22955ef5e73d2fea1b9813cb23"
 dependencies = [
- "num-bigint",
+ "num-bigint 0.4.8",
  "num-complex",
  "num-integer",
  "num-iter",
@@ -5352,6 +5583,16 @@ dependencies = [
  "num-traits",
 ]
 
+[[package]]
+name = "num-bigint"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93e7820bc0a80a0238e650327316f929ba18d5be054b647490a3a6a339f3e7c0"
+dependencies = [
+ "num-integer",
+ "num-traits",
+]
+
 [[package]]
 name = "num-bigint-dig"
 version = "0.8.6"
@@ -5424,7 +5665,7 @@ version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824"
 dependencies = [
- "num-bigint",
+ "num-bigint 0.4.8",
  "num-integer",
  "num-traits",
 ]
@@ -5506,7 +5747,7 @@ version = "5.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "51e219e79014df21a225b1860a479e2dcd7cbd9130f4defd4bd0e191ea31d67d"
 dependencies = [
- "base64 0.21.7",
+ "base64 0.22.1",
  "chrono",
  "getrandom 0.2.17",
  "http 1.4.2",
@@ -5956,7 +6197,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7d8fae84b431384b68627d0f9b3b1245fcf9f46f6c0e3dc902e9dce64edd1967"
 dependencies = [
  "libc",
- "windows-sys 0.48.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -6083,6 +6324,34 @@ dependencies = [
  "windows-link",
 ]
 
+[[package]]
+name = "parquet"
+version = "60.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8af83d2940bc0510f9aef86d865f56fdc6095f87ab115ac885a80b7c5226d3ba"
+dependencies = [
+ "ahash",
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-ipc",
+ "arrow-schema",
+ "arrow-select",
+ "base64 0.23.0",
+ "bytes",
+ "chrono",
+ "half",
+ "hashbrown 0.17.1",
+ "lz4_flex 0.14.0",
+ "num-bigint 0.5.1",
+ "num-integer",
+ "num-traits",
+ "seq-macro",
+ "snap",
+ "twox-hash",
+ "zstd 0.14.0",
+]
+
 [[package]]
 name = "parse-size"
 version = "1.1.0"
@@ -7143,6 +7412,7 @@ name = "quickwit-cli"
 version = "0.9.1"
 dependencies = [
  "anyhow",
+ "async-trait",
  "backtrace",
  "bytesize",
  "chrono",
@@ -7486,10 +7756,14 @@ version = "0.9.1"
 dependencies = [
  "anyhow",
  "arc-swap",
+ "arrow-array",
+ "arrow-json",
+ "arrow-schema",
  "async-compression",
  "async-trait",
  "aws-sdk-kinesis",
  "aws-sdk-sqs",
+ "base64 0.23.0",
  "bytes",
  "bytesize",
  "criterion",
@@ -7506,6 +7780,7 @@ dependencies = [
  "mockall",
  "oneshot 0.2.1",
  "openssl",
+ "parquet",
  "percent-encoding",
  "proptest",
  "prost 0.14.4",
@@ -8177,7 +8452,7 @@ dependencies = [
  "quinn-udp",
  "rustc-hash",
  "rustls 0.23.41",
- "socket2 0.5.10",
+ "socket2 0.6.4",
  "thiserror 2.0.18",
  "tokio",
  "tracing",
@@ -8216,9 +8491,9 @@ dependencies = [
  "cfg_aliases",
  "libc",
  "once_cell",
- "socket2 0.5.10",
+ "socket2 0.6.4",
  "tracing",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -8990,7 +9265,7 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys 0.4.15",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -9003,7 +9278,7 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys 0.12.1",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -9083,7 +9358,7 @@ dependencies = [
  "security-framework",
  "security-framework-sys",
  "webpki-root-certs",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -9324,7 +9599,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5b55fb86dfd3a2f5f76ea78310a88f96c4ea21a3031f8d212443d56123fd0521"
 dependencies = [
  "libc",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -9343,6 +9618,12 @@ version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f97841a747eef040fcd2e7b3b9a220a7205926e60488e673d9e4926d27772ce5"
 
+[[package]]
+name = "seq-macro"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bc711410fbe7399f390ca1c3b60ad0f53f80e95c5eb935e52268a0e2cd49acc"
+
 [[package]]
 name = "serde"
 version = "1.0.228"
@@ -9731,7 +10012,7 @@ version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0d585997b0ac10be3c5ee635f1bab02d512760d14b7c468801ac8a01d9ae5f1d"
 dependencies = [
- "num-bigint",
+ "num-bigint 0.4.8",
  "num-traits",
  "thiserror 2.0.18",
  "time",
@@ -9854,7 +10135,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "52d1cfed4120b4d927bf7c0f86d2087a4a7d6027c906d9f9d525a80573b9be51"
 dependencies = [
  "libc",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -9988,7 +10269,7 @@ version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "aa003f0038df784eb8fecbbac13affe3da23b45194bd57dba231c8f48199c526"
 dependencies = [
- "atoi",
+ "atoi 2.0.0",
  "base64 0.22.1",
  "bitflags 2.13.0",
  "byteorder",
@@ -10031,7 +10312,7 @@ version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "db58fcd5a53cf07c184b154801ff91347e4c30d17a3562a635ff028ad5deda46"
 dependencies = [
- "atoi",
+ "atoi 2.0.0",
  "base64 0.22.1",
  "bitflags 2.13.0",
  "byteorder",
@@ -10069,7 +10350,7 @@ version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2d12fe70b2c1b4401038055f90f151b78208de1f9f89a7dbfd41587a10c3eea"
 dependencies = [
- "atoi",
+ "atoi 2.0.0",
  "flume 0.11.1",
  "futures-channel",
  "futures-core",
@@ -10471,10 +10752,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
 dependencies = [
  "fastrand 2.4.1",
- "getrandom 0.3.4",
+ "getrandom 0.4.3",
  "once_cell",
  "rustix 1.1.4",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -10483,7 +10764,7 @@ version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d8c27177b12a6399ffc08b98f76f7c9a1f4fe9fc967c784c5a071fa8d93cf7e1"
 dependencies = [
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -11891,7 +12172,7 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.48.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
diff --git a/quickwit/Cargo.toml b/quickwit/Cargo.toml
index 99dc769561e..58f454e6f6b 100644
--- a/quickwit/Cargo.toml
+++ b/quickwit/Cargo.toml
@@ -54,6 +54,9 @@ license = "Apache-2.0"
 ahash = "0.8"
 anyhow = "1"
 arc-swap = "1.9"
+arrow-array = { version = "60", default-features = false }
+arrow-json = { version = "60", default-features = false }
+arrow-schema = { version = "60", default-features = false }
 assert-json-diff = "2"
 async-compression = { version = "0.4", features = ["tokio", "gzip"] }
 async-speed-limit = "0.4"
@@ -156,6 +159,7 @@ opentelemetry-otlp = { version = "0.32", default-features = false, features = [
     "trace",
 ] }
 ouroboros = "0.18"
+parquet = { version = "60", default-features = false }
 percent-encoding = "2.3"
 pin-project = "1.1"
 pnet = { version = "0.35", features = ["std"] }
diff --git a/quickwit/quickwit-cli/Cargo.toml b/quickwit/quickwit-cli/Cargo.toml
index 5257d6f5c85..546040f053d 100644
--- a/quickwit/quickwit-cli/Cargo.toml
+++ b/quickwit/quickwit-cli/Cargo.toml
@@ -71,12 +71,14 @@ quickwit-transport = { workspace = true }
 procfs = { workspace = true }
 
 [dev-dependencies]
+async-trait = { workspace = true }
 predicates = { workspace = true }
 reqwest = { workspace = true }
 
 quickwit-actors = { workspace = true, features = ["testsuite"] }
 quickwit-common = { workspace = true, features = ["testsuite"] }
 quickwit-config = { workspace = true, features = ["testsuite"] }
+quickwit-indexing = { workspace = true, features = ["testsuite"] }
 quickwit-metastore = { workspace = true, features = ["testsuite"] }
 quickwit-proto = { workspace = true, features = ["testsuite"] }
 quickwit-storage = { workspace = true, features = ["testsuite"] }
@@ -93,6 +95,8 @@ jemalloc-profiled = [
 ci-test = []
 pprof = ["quickwit-serve/pprof"]
 openssl-support = ["openssl-probe"]
+# Enables `quickwit tool local-ingest` on `.parquet` files (benchmark-only bulk load).
+parquet = ["quickwit-indexing/parquet"]
 # Requires to enable tokio unstable via RUSTFLAGS="--cfg tokio_unstable"
 tokio-console = [
   "dep:console-subscriber",
diff --git a/quickwit/quickwit-cli/src/main.rs b/quickwit/quickwit-cli/src/main.rs
index 0af72990277..37e105e7789 100644
--- a/quickwit/quickwit-cli/src/main.rs
+++ b/quickwit/quickwit-cli/src/main.rs
@@ -448,7 +448,10 @@ mod tests {
                     overwrite,
                     vrl_script: Some(vrl_script),
                     clear_cache,
+                    num_pipelines,
+                    batch_num_rows_opt: None,
                 })) if &index_id == "wikipedia"
+                       && num_pipelines.get() == 1
                        && config_uri == Uri::from_str("file:///config.yaml").unwrap()
                        && vrl_script == ".message = downcase(string!(.message))"
                        && overwrite
@@ -457,6 +460,82 @@ mod tests {
         ));
     }
 
+    #[test]
+    fn test_parse_local_ingest_parquet_args() {
+        let app = build_cli().no_binary_name(true);
+        let matches = app
+            .try_get_matches_from([
+                "tool",
+                "local-ingest",
+                "--index",
+                "wikipedia",
+                "--config",
+                "/config.yaml",
+                "--input-path",
+                "/data/wikipedia.parquet",
+                "--num-pipelines",
+                "8",
+                "--batch-num-rows",
+                "4096",
+            ])
+            .unwrap();
+        let command = CliCommand::parse_cli_args(matches).unwrap();
+        let CliCommand::Tool(ToolCliCommand::LocalIngest(args)) = command else {
+            panic!("expected local ingest command");
+        };
+        assert_eq!(args.input_format, SourceInputFormat::Json);
+        assert_eq!(args.num_pipelines.get(), 8);
+        assert_eq!(args.batch_num_rows_opt.unwrap().get(), 4096);
+    }
+
+    #[test]
+    fn test_parse_local_ingest_args_rejects_multiple_json_pipelines() {
+        for extra_args in [["--num-pipelines", "2"], ["--batch-num-rows", "1000"]] {
+            let app = build_cli().no_binary_name(true);
+            let matches = app
+                .try_get_matches_from(
+                    [
+                        "tool",
+                        "local-ingest",
+                        "--index",
+                        "wikipedia",
+                        "--config",
+                        "/config.yaml",
+                    ]
+                    .into_iter()
+                    .chain(extra_args),
+                )
+                .unwrap();
+            let error = CliCommand::parse_cli_args(matches).unwrap_err();
+            assert!(
+                error
+                    .to_string()
+                    .contains("requires a `.parquet` input file")
+            );
+        }
+    }
+
+    #[test]
+    fn test_parse_local_ingest_args_rejects_plain_parquet() {
+        let app = build_cli().no_binary_name(true);
+        let matches = app
+            .try_get_matches_from([
+                "tool",
+                "local-ingest",
+                "--index",
+                "wikipedia",
+                "--config",
+                "/config.yaml",
+                "--input-path",
+                "/data/wikipedia.parquet",
+                "--input-format",
+                "plain",
+            ])
+            .unwrap();
+        let error = CliCommand::parse_cli_args(matches).unwrap_err();
+        assert!(error.to_string().contains("indexed as `json` documents"));
+    }
+
     #[test]
     fn test_parse_search_args() -> anyhow::Result<()> {
         let app = build_cli().no_binary_name(true);
diff --git a/quickwit/quickwit-cli/src/tool.rs b/quickwit/quickwit-cli/src/tool.rs
index dfff0b937c2..696b02f8316 100644
--- a/quickwit/quickwit-cli/src/tool.rs
+++ b/quickwit/quickwit-cli/src/tool.rs
@@ -41,6 +41,7 @@ use quickwit_indexing::docs_clustering::Fingerprinter;
 use quickwit_indexing::models::{
     DetachIndexingPipeline, DetachMergePipeline, IndexingStatistics, SpawnPipeline,
 };
+use quickwit_indexing::source::{SourceLoader, quickwit_supported_sources};
 use quickwit_indexing::{IndexingPipeline, IndexingSplitCache};
 use quickwit_ingest::IngesterPool;
 use quickwit_metastore::IndexMetadataResponseExt;
@@ -53,7 +54,7 @@ use quickwit_search::{SearchResponseRest, single_node_search};
 use quickwit_serve::{
     BodyFormat, SearchRequestQueryString, SortBy, search_request_from_api_request,
 };
-use quickwit_storage::{BundleStorage, Storage};
+use quickwit_storage::{BundleStorage, Storage, StorageResolver};
 use quickwit_transport::ChannelFactory;
 use thousands::Separable;
 use tracing::debug;
@@ -64,6 +65,11 @@ use crate::{
     run_index_checklist, start_actor_runtimes,
 };
 
+#[cfg(feature = "parquet")]
+mod parquet_ingest;
+#[cfg(feature = "parquet")]
+mod parquet_report;
+
 pub fn build_tool_command() -> Command {
     Command::new("tool")
         .about("Performs utility operations. Requires a node config.")
@@ -71,17 +77,21 @@ pub fn build_tool_command() -> Command {
         .subcommand(
             Command::new("local-ingest")
                 .display_order(10)
-                .about("Indexes NDJSON documents locally.")
-                .long_about("Local ingest indexes locally NDJSON documents from a file or from stdin and uploads splits on the configured storage.")
+                .about("Indexes NDJSON or Parquet documents locally.")
+                .long_about("Local ingest indexes locally NDJSON documents from a file or from stdin, or rows of a local `.parquet` file (requires the `parquet` feature), and uploads splits on the configured storage.")
                 .args(&[
                     arg!(--index <INDEX> "ID of the target index")
                         .display_order(1)
                         .required(true),
                     arg!(--"input-path" <INPUT_PATH> "Location of the input file.")
                         .required(false),
-                    arg!(--"input-format" <INPUT_FORMAT> "Format of the input data.")
+                    arg!(--"input-format" <INPUT_FORMAT> "Format of the input documents: `json` or `plain`. Parquet rows are indexed as `json` documents.")
                         .default_value("json")
                         .required(false),
+                    arg!(--"num-pipelines" <NUM_PIPELINES> "Number of indexing pipelines running in parallel. Values greater than 1 require a `.parquet` input file. Defaults to half the number of CPUs for a `.parquet` input file, 1 otherwise.")
+                        .required(false),
+                    arg!(--"batch-num-rows" <BATCH_NUM_ROWS> "Number of Parquet rows decoded at once. Only valid with a `.parquet` input file.")
+                        .required(false),
                     arg!(--overwrite "Overwrites pre-existing index.")
                         .required(false),
                     arg!(--"transform-script" <SCRIPT> "VRL program to transform docs before ingesting.")
@@ -177,6 +187,10 @@ pub struct LocalIngestDocsArgs {
     pub overwrite: bool,
     pub vrl_script: Option<String>,
     pub clear_cache: bool,
+    /// Number of indexing pipelines. Values greater than 1 require a `.parquet` input file.
+    pub num_pipelines: NonZeroUsize,
+    /// Number of Parquet rows decoded at once. Only valid with a `.parquet` input file.
+    pub batch_num_rows_opt: Option<NonZeroUsize>,
 }
 
 #[derive(Debug, Eq, PartialEq)]
@@ -263,7 +277,39 @@ impl ToolCliCommand {
         let overwrite = matches.get_flag("overwrite");
         let vrl_script = matches.remove_one::<String>("transform-script");
         let clear_cache = !matches.get_flag("keep-cache");
-
+        let num_pipelines_opt: Option<NonZeroUsize> = matches
+            .remove_one::<String>("num-pipelines")
+            .map(|num_pipelines| num_pipelines.parse())
+            .transpose()
+            .context("`num-pipelines` must be a strictly positive integer")?;
+        let batch_num_rows_opt: Option<NonZeroUsize> = matches
+            .remove_one::<String>("batch-num-rows")
+            .map(|batch_num_rows| batch_num_rows.parse())
+            .transpose()
+            .context("`batch-num-rows` must be a strictly positive integer")?;
+
+        let is_parquet = matches!(&input_path_opt, Some(input_path) if is_parquet_uri(input_path));
+        if is_parquet && input_format != SourceInputFormat::Json {
+            bail!("Parquet rows are indexed as `json` documents: remove `--input-format`");
+        }
+        if !is_parquet {
+            if let Some(num_pipelines) = num_pipelines_opt
+                && num_pipelines.get() > 1
+            {
+                bail!("`--num-pipelines` greater than 1 requires a `.parquet` input file");
+            }
+            if batch_num_rows_opt.is_some() {
+                bail!("`--batch-num-rows` requires a `.parquet` input file");
+            }
+        }
+        // Measured optimum: 16 pipelines on m8gd.8xlarge (32 vCPUs), with 5M-doc splits.
+        let num_pipelines = num_pipelines_opt.unwrap_or_else(|| {
+            if is_parquet {
+                NonZeroUsize::new(quickwit_common::num_cpus() / 2).unwrap_or(NonZeroUsize::MIN)
+            } else {
+                NonZeroUsize::MIN
+            }
+        });
         Ok(Self::LocalIngest(LocalIngestDocsArgs {
             config_uri,
             index_id,
@@ -272,6 +318,8 @@ impl ToolCliCommand {
             overwrite,
             vrl_script,
             clear_cache,
+            num_pipelines,
+            batch_num_rows_opt,
         }))
     }
 
@@ -399,8 +447,20 @@ impl ToolCliCommand {
     }
 }
 
+fn is_parquet_uri(uri: &Uri) -> bool {
+    uri.extension() == Some("parquet")
+}
+
 pub async fn local_ingest_docs_cli(args: LocalIngestDocsArgs) -> anyhow::Result<()> {
     debug!(args=?args, "local-ingest-docs");
+
+    if matches!(&args.input_path_opt, Some(input_path) if is_parquet_uri(input_path)) {
+        #[cfg(not(feature = "parquet"))]
+        bail!("Quickwit was compiled without the `parquet` feature");
+
+        #[cfg(feature = "parquet")]
+        return parquet_ingest::local_ingest_parquet_cli(args).await;
+    }
     println!("❯ Ingesting documents locally...");
 
     let config = load_node_config(&args.config_uri, None).await?;
@@ -436,44 +496,16 @@ pub async fn local_ingest_docs_cli(args: LocalIngestDocsArgs) -> anyhow::Result<
         let mut index_service = IndexService::new(metastore.clone(), storage_resolver.clone());
         index_service.clear_index(&args.index_id).await?;
     }
-    // The indexing service needs to update its cluster chitchat state so that the control plane is
-    // aware of the running tasks. We thus create a fake cluster to instantiate the indexing service
-    // and avoid impacting potential control plane running on the cluster.
-    let cluster = create_empty_cluster(&config).await?;
-    let indexer_config = IndexerConfig {
-        ..Default::default()
-    };
-    let runtimes_config = RuntimesConfig::default();
-    start_actor_runtimes(
-        runtimes_config,
-        &HashSet::from_iter([QuickwitService::Indexer]),
-    )?;
     let universe = Universe::new();
-    let merge_scheduler_service_mailbox = universe.get_or_spawn_one();
-    let split_cache =
-        Arc::new(IndexingSplitCache::from_config(&indexer_config, &config.data_dir_path).await?);
-    let fingerprinter_opt = config
-        .docs_clustering_config
-        .as_ref()
-        .map(Fingerprinter::new);
-    let indexing_server = IndexingService::new(
-        config.node_id.clone(),
-        config.data_dir_path.clone(),
-        indexer_config,
-        runtimes_config.num_threads_blocking,
-        cluster,
+    let (indexing_server_mailbox, indexing_server_handle) = spawn_indexing_service(
+        &universe,
+        &config,
         metastore,
-        None,
-        Some(merge_scheduler_service_mailbox),
-        IngesterPool::default(),
         storage_resolver,
-        EventBroker::default(),
-        split_cache,
-        fingerprinter_opt,
+        quickwit_supported_sources().clone(),
+        true,
     )
     .await?;
-    let (indexing_server_mailbox, indexing_server_handle) =
-        universe.spawn_builder().spawn(indexing_server);
     let pipeline_id = indexing_server_mailbox
         .ask_for_res(SpawnPipeline {
             index_id: args.index_id.clone(),
@@ -539,6 +571,54 @@ pub async fn local_ingest_docs_cli(args: LocalIngestDocsArgs) -> anyhow::Result<
     }
 }
 
+/// Starts the actor runtimes and spawns an indexing service in `universe`.
+pub(crate) async fn spawn_indexing_service(
+    universe: &Universe,
+    config: &NodeConfig,
+    metastore: MetastoreServiceClient,
+    storage_resolver: StorageResolver,
+    source_loader: Arc<SourceLoader>,
+    enable_merges: bool,
+) -> anyhow::Result<(Mailbox<IndexingService>, ActorHandle<IndexingService>)> {
+    // Use an isolated cluster so local tasks don't affect a running control plane.
+    let cluster = create_empty_cluster(config).await?;
+    let indexer_config = IndexerConfig::default();
+    let runtimes_config = RuntimesConfig::default();
+    start_actor_runtimes(
+        runtimes_config,
+        &HashSet::from_iter([QuickwitService::Indexer]),
+    )?;
+    let merge_scheduler_service_opt = if enable_merges {
+        Some(universe.get_or_spawn_one())
+    } else {
+        None
+    };
+    let split_cache =
+        Arc::new(IndexingSplitCache::from_config(&indexer_config, &config.data_dir_path).await?);
+    let fingerprinter_opt = config
+        .docs_clustering_config
+        .as_ref()
+        .map(Fingerprinter::new);
+    let indexing_server = IndexingService::new(
+        config.node_id.clone(),
+        config.data_dir_path.clone(),
+        indexer_config,
+        runtimes_config.num_threads_blocking,
+        cluster,
+        metastore,
+        None,
+        merge_scheduler_service_opt,
+        IngesterPool::default(),
+        storage_resolver,
+        EventBroker::default(),
+        split_cache,
+        fingerprinter_opt,
+    )
+    .await?
+    .with_source_loader(source_loader);
+    Ok(universe.spawn_builder().spawn(indexing_server))
+}
+
 pub async fn local_search_cli(args: LocalSearchArgs) -> anyhow::Result<()> {
     debug!(args=?args, "local-search");
     println!("❯ Searching directly on the index storage (without calling REST API)...");
@@ -950,7 +1030,7 @@ impl ThroughputCalculator {
     }
 }
 
-async fn create_empty_cluster(config: &NodeConfig) -> anyhow::Result<Cluster> {
+pub(crate) async fn create_empty_cluster(config: &NodeConfig) -> anyhow::Result<Cluster> {
     let self_node = ClusterMember {
         node_id: config.node_id.clone(),
         generation_id: quickwit_cluster::GenerationId::now(),
diff --git a/quickwit/quickwit-cli/src/tool/parquet_ingest.rs b/quickwit/quickwit-cli/src/tool/parquet_ingest.rs
new file mode 100644
index 00000000000..f1aa6d85a9d
--- /dev/null
+++ b/quickwit/quickwit-cli/src/tool/parquet_ingest.rs
@@ -0,0 +1,276 @@
+// Copyright 2021-Present Datadog, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Local Parquet bulk load. See `docs/internals/parquet-bulk-load.md`.
+//! Requires no published splits; failures trigger best-effort index cleanup.
+
+use std::io::stdout;
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+
+use anyhow::bail;
+use bytesize::ByteSize;
+use colored::Colorize;
+use quickwit_actors::{ActorHandle, Mailbox, Universe};
+use quickwit_config::{CLI_SOURCE_ID, NodeConfig, SourceConfig, SourceParams, TransformConfig};
+use quickwit_index_management::IndexService;
+use quickwit_indexing::IndexingPipeline;
+use quickwit_indexing::actors::IndexingService;
+use quickwit_indexing::models::{DetachIndexingPipeline, IndexingStatistics, SpawnPipeline};
+use quickwit_indexing::source::SourceLoader;
+use quickwit_indexing::source::parquet_file::{
+    DEFAULT_PARQUET_BATCH_NUM_ROWS, ParquetLoadPlan, ParquetSourceFactory,
+};
+use quickwit_metastore::{
+    IndexMetadata, IndexMetadataResponseExt, ListSplitsQuery, ListSplitsRequestExt,
+    MetastoreServiceStreamSplitsExt, SplitMetadata, SplitState,
+};
+use quickwit_proto::metastore::{
+    IndexMetadataRequest, ListSplitsRequest, MetastoreService, MetastoreServiceClient, SourceType,
+};
+use quickwit_proto::types::PipelineUid;
+use thousands::Separable;
+
+use super::parquet_report::LoadReport;
+use super::{
+    LocalIngestDocsArgs, ThroughputCalculator, display_statistics, spawn_indexing_service,
+};
+use crate::{get_resolvers, load_node_config, run_index_checklist};
+
+mod lifecycle;
+#[cfg(test)]
+mod tests;
+
+const REPORT_INTERVAL: Duration = Duration::from_secs(1);
+
+pub(super) async fn local_ingest_parquet_cli(args: LocalIngestDocsArgs) -> anyhow::Result<()> {
+    let input_uri = args
+        .input_path_opt
+        .clone()
+        .expect("the Parquet input is detected from `--input-path`");
+    let batch_num_rows = args
+        .batch_num_rows_opt
+        .map(|batch_num_rows| batch_num_rows.get())
+        .unwrap_or(DEFAULT_PARQUET_BATCH_NUM_ROWS);
+    println!(
+        "❯ Ingesting Parquet file locally with {} pipeline(s)...",
+        args.num_pipelines
+    );
+    let config = load_node_config(&args.config_uri, None).await?;
+    let (storage_resolver, metastore_resolver) =
+        get_resolvers(&config.storage_configs, &config.metastore_configs);
+    let mut metastore = metastore_resolver.resolve(&config.metastore_uri).await?;
+
+    let source_config = SourceConfig {
+        source_id: CLI_SOURCE_ID.to_string(),
+        num_pipelines: args.num_pipelines,
+        enabled: true,
+        source_params: SourceParams::file_from_uri(input_uri.clone()),
+        transform_config: args
+            .vrl_script
+            .clone()
+            .map(|vrl_script| TransformConfig::new(vrl_script, None)),
+        input_format: args.input_format,
+    };
+    run_index_checklist(
+        &mut metastore,
+        &storage_resolver,
+        &args.index_id,
+        Some(&source_config),
+    )
+    .await?;
+
+    let mut index_service = IndexService::new(metastore.clone(), storage_resolver.clone());
+    let index_metadata = metastore
+        .index_metadata(IndexMetadataRequest::for_index_id(args.index_id.clone()))
+        .await?
+        .deserialize_index_metadata()?;
+    if args.overwrite {
+        lifecycle::clear_index_checked(&mut index_service, &index_metadata.index_uid).await?;
+    }
+    if !list_published_splits(&metastore, &index_metadata)
+        .await?
+        .is_empty()
+    {
+        bail!(
+            "index `{}` already has published splits: a Parquet load requires an empty index, use \
+             `--overwrite` to clear it",
+            args.index_id
+        );
+    }
+    let plan =
+        tokio::task::spawn_blocking(move || ParquetLoadPlan::try_new(input_uri, batch_num_rows))
+            .await??;
+    println!(
+        "Parquet file: {} rows, {} row groups, {} uncompressed.",
+        plan.num_rows().separate_with_commas(),
+        plan.num_row_groups().separate_with_commas(),
+        ByteSize(plan.num_uncompressed_bytes()),
+    );
+    let plan = Arc::new(plan);
+    let mut source_loader = SourceLoader::default();
+    source_loader.add_source(SourceType::File, ParquetSourceFactory::new(plan.clone()));
+    let universe = Universe::new();
+    let (indexing_server_mailbox, indexing_server_handle) = spawn_indexing_service(
+        &universe,
+        &config,
+        metastore.clone(),
+        storage_resolver,
+        Arc::new(source_loader),
+        false,
+    )
+    .await?;
+    let load_res = run_load(
+        &indexing_server_mailbox,
+        &plan,
+        &args,
+        &config,
+        &metastore,
+        source_config,
+        &index_metadata,
+    )
+    .await;
+    universe.kill();
+    indexing_server_handle.kill().await;
+    lifecycle::quiesce(&universe).await;
+    lifecycle::finish_load(
+        load_res,
+        &mut index_service,
+        &args,
+        &config,
+        &index_metadata.index_uid,
+    )
+    .await
+}
+
+async fn run_load(
+    indexing_server_mailbox: &Mailbox<IndexingService>,
+    plan: &ParquetLoadPlan,
+    args: &LocalIngestDocsArgs,
+    config: &NodeConfig,
+    metastore: &MetastoreServiceClient,
+    source_config: SourceConfig,
+    index_metadata: &IndexMetadata,
+) -> anyhow::Result<()> {
+    let start_time = Instant::now();
+    let pipeline_handles = spawn_pipelines(indexing_server_mailbox, args, source_config).await?;
+    let indexing_statistics = wait_for_indexing_pipelines(pipeline_handles).await?;
+    let report = LoadReport {
+        num_pipelines: args.num_pipelines.get(),
+        plan,
+        indexing_statistics,
+        elapsed: start_time.elapsed(),
+        splits: list_published_splits(metastore, index_metadata).await?,
+        index_config: &index_metadata.index_config,
+        metastore_uri: &config.metastore_uri,
+    };
+    report.print();
+    report.check()
+}
+
+async fn spawn_pipelines(
+    indexing_server_mailbox: &Mailbox<IndexingService>,
+    args: &LocalIngestDocsArgs,
+    source_config: SourceConfig,
+) -> anyhow::Result<Vec<ActorHandle<IndexingPipeline>>> {
+    let mut handles = Vec::with_capacity(args.num_pipelines.get());
+    for _ in 0..args.num_pipelines.get() {
+        let pipeline_id = indexing_server_mailbox
+            .ask_for_res(SpawnPipeline {
+                index_id: args.index_id.clone(),
+                source_config: source_config.clone(),
+                pipeline_uid: PipelineUid::random(),
+            })
+            .await?;
+        let handle = indexing_server_mailbox
+            .ask_for_res(DetachIndexingPipeline { pipeline_id })
+            .await?;
+        handles.push(handle);
+    }
+    Ok(handles)
+}
+
+async fn wait_for_indexing_pipelines(
+    pipeline_handles: Vec<ActorHandle<IndexingPipeline>>,
+) -> anyhow::Result<IndexingStatistics> {
+    let mut stdout_handle = stdout();
+    let mut throughput_calculator = ThroughputCalculator::new(Instant::now());
+    let mut report_interval = tokio::time::interval(REPORT_INTERVAL);
+
+    loop {
+        report_interval.tick().await;
+        let mut statistics = IndexingStatistics::default();
+        let mut num_running_pipelines = 0;
+
+        for pipeline_handle in &pipeline_handles {
+            pipeline_handle.refresh_observe();
+            let pipeline_statistics = pipeline_handle.last_observation();
+            check_no_restart(&pipeline_statistics)?;
+            add_indexing_statistics(&mut statistics, &pipeline_statistics);
+            if !pipeline_handle.state().is_exit() {
+                num_running_pipelines += 1;
+            }
+        }
+        if num_running_pipelines == 0 {
+            break;
+        }
+        print!(" {} {num_running_pipelines}", "Pipelines".bright_blue());
+        display_statistics(&mut stdout_handle, &mut throughput_calculator, &statistics)?;
+    }
+    let mut statistics = IndexingStatistics::default();
+
+    for pipeline_handle in pipeline_handles {
+        let (exit_status, pipeline_statistics) = pipeline_handle.join().await;
+        if !exit_status.is_success() {
+            bail!("indexing pipeline failed: {exit_status:?}");
+        }
+        check_no_restart(&pipeline_statistics)?;
+        add_indexing_statistics(&mut statistics, &pipeline_statistics);
+    }
+    Ok(statistics)
+}
+
+/// Claimed row groups cannot be replayed, so a restart or spawn retry must abort the load.
+fn check_no_restart(pipeline_statistics: &IndexingStatistics) -> anyhow::Result<()> {
+    if pipeline_statistics.generation > 1 || pipeline_statistics.num_spawn_attempts > 1 {
+        bail!("an indexing pipeline failed and restarted, see the logs for the cause");
+    }
+    Ok(())
+}
+
+fn add_indexing_statistics(total: &mut IndexingStatistics, statistics: &IndexingStatistics) {
+    total.num_docs += statistics.num_docs;
+    total.num_invalid_docs += statistics.num_invalid_docs;
+    total.num_local_splits += statistics.num_local_splits;
+    total.num_staged_splits += statistics.num_staged_splits;
+    total.num_uploaded_splits += statistics.num_uploaded_splits;
+    total.num_published_splits += statistics.num_published_splits;
+    total.num_empty_splits += statistics.num_empty_splits;
+    total.total_bytes_processed += statistics.total_bytes_processed;
+    total.total_size_splits += statistics.total_size_splits;
+}
+
+async fn list_published_splits(
+    metastore: &MetastoreServiceClient,
+    index_metadata: &IndexMetadata,
+) -> anyhow::Result<Vec<SplitMetadata>> {
+    let query = ListSplitsQuery::for_index(index_metadata.index_uid.clone())
+        .with_split_state(SplitState::Published);
+    let request = ListSplitsRequest::try_from_list_splits_query(&query)?;
+    Ok(metastore
+        .list_splits(request)
+        .await?
+        .collect_splits_metadata()
+        .await?)
+}
diff --git a/quickwit/quickwit-cli/src/tool/parquet_ingest/lifecycle.rs b/quickwit/quickwit-cli/src/tool/parquet_ingest/lifecycle.rs
new file mode 100644
index 00000000000..7b2cfc9cded
--- /dev/null
+++ b/quickwit/quickwit-cli/src/tool/parquet_ingest/lifecycle.rs
@@ -0,0 +1,106 @@
+// Copyright 2021-Present Datadog, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::collections::HashSet;
+
+use anyhow::{Context, ensure};
+use colored::Colorize;
+use quickwit_actors::Universe;
+use quickwit_config::NodeConfig;
+use quickwit_index_management::{IndexService, clear_cache_directory};
+use quickwit_metastore::{ListSplitsQuery, ListSplitsRequestExt, MetastoreServiceStreamSplitsExt};
+use quickwit_proto::metastore::{ListSplitsRequest, MetastoreService};
+use quickwit_proto::types::IndexUid;
+
+use super::LocalIngestDocsArgs;
+use crate::checklist::GREEN_COLOR;
+
+/// Stops actors; detached upload tasks are not tracked here.
+pub(super) async fn quiesce(universe: &Universe) {
+    universe.kill();
+    let mut joined = HashSet::new();
+    loop {
+        // Initializers can register children after a quit snapshot.
+        let snapshot: HashSet<String> = universe.quit().await.into_keys().collect();
+        if snapshot == joined {
+            return;
+        }
+        joined = snapshot;
+    }
+}
+
+/// Runs cache cleanup and rollback after actor shutdown.
+pub(super) async fn finish_load(
+    load_result: anyhow::Result<()>,
+    index_service: &mut IndexService,
+    args: &LocalIngestDocsArgs,
+    config: &NodeConfig,
+    index_uid: &IndexUid,
+) -> anyhow::Result<()> {
+    let cache_result = clear_cache_directory_if_requested(args, config).await;
+    let load_error = match (load_result, cache_result) {
+        (Ok(()), Ok(())) => return Ok(()),
+        (Err(error), Ok(())) | (Ok(()), Err(error)) => error,
+        (Err(error), Err(cache_error)) => {
+            error.context(format!("cache cleanup also failed: {cache_error:#}"))
+        }
+    };
+    println!("Load failed, clearing index `{}`...", args.index_id);
+    if let Err(rollback_error) = clear_index_checked(index_service, index_uid).await {
+        return Err(load_error.context(format!(
+            "failed to clear the index after the load failed: {rollback_error:#}"
+        )));
+    }
+    Err(load_error)
+}
+
+pub(super) async fn clear_index_checked(
+    index_service: &mut IndexService,
+    index_uid: &IndexUid,
+) -> anyhow::Result<()> {
+    index_service.clear_index(&index_uid.index_id).await?;
+    // clear_index currently logs some deletion failures rather than returning them.
+    let query = ListSplitsQuery::for_index(index_uid.clone()).with_limit(1);
+    let remaining = index_service
+        .metastore()
+        .list_splits(ListSplitsRequest::try_from_list_splits_query(&query)?)
+        .await
+        .context("failed to verify index cleanup")?
+        .collect_splits_metadata()
+        .await
+        .context("failed to verify index cleanup")?;
+    ensure!(
+        remaining.is_empty(),
+        "index cleanup left split metadata behind"
+    );
+    Ok(())
+}
+
+async fn clear_cache_directory_if_requested(
+    args: &LocalIngestDocsArgs,
+    config: &NodeConfig,
+) -> anyhow::Result<()> {
+    if !args.clear_cache {
+        return Ok(());
+    }
+    println!("Clearing local cache directory...");
+    clear_cache_directory(&config.data_dir_path)
+        .await
+        .context("failed to clear local cache directory")?;
+    println!("{} Local cache directory cleared.", "✔".color(GREEN_COLOR));
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/quickwit/quickwit-cli/src/tool/parquet_ingest/lifecycle/tests.rs b/quickwit/quickwit-cli/src/tool/parquet_ingest/lifecycle/tests.rs
new file mode 100644
index 00000000000..6e9edd2b8a9
--- /dev/null
+++ b/quickwit/quickwit-cli/src/tool/parquet_ingest/lifecycle/tests.rs
@@ -0,0 +1,221 @@
+// Copyright 2021-Present Datadog, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::num::NonZeroUsize;
+use std::path::Path;
+use std::sync::Arc;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::time::Duration;
+
+use async_trait::async_trait;
+use quickwit_actors::{Actor, ActorContext, ActorExitStatus};
+use quickwit_common::fs::get_cache_directory_path;
+use quickwit_common::uri::Uri;
+use quickwit_config::{IndexConfig, SourceInputFormat, StorageBackend};
+use quickwit_metastore::{SplitMetadata, StageSplitsRequestExt, metastore_for_test};
+use quickwit_proto::metastore::{PublishSplitsRequest, StageSplitsRequest};
+use quickwit_storage::{BulkDeleteError, MockStorage, MockStorageFactory, StorageResolver};
+use tokio::sync::oneshot;
+
+use super::*;
+
+struct LateInitializer {
+    gates: Vec<oneshot::Receiver<()>>,
+    finalized: Arc<AtomicUsize>,
+}
+
+#[async_trait]
+impl Actor for LateInitializer {
+    type ObservableState = ();
+
+    fn observable_state(&self) {}
+
+    async fn initialize(&mut self, ctx: &ActorContext<Self>) -> Result<(), ActorExitStatus> {
+        self.gates.remove(0).await.unwrap();
+        if !self.gates.is_empty() {
+            ctx.spawn_actor().spawn(LateInitializer {
+                gates: std::mem::take(&mut self.gates),
+                finalized: self.finalized.clone(),
+            });
+        }
+        Ok(())
+    }
+
+    async fn finalize(
+        &mut self,
+        _: &ActorExitStatus,
+        _: &ActorContext<Self>,
+    ) -> anyhow::Result<()> {
+        self.finalized.fetch_add(1, Ordering::SeqCst);
+        Ok(())
+    }
+}
+
+#[tokio::test]
+async fn test_quiesce_joins_late_initialization_descendants() {
+    let universe = Universe::new();
+    let finalized = Arc::new(AtomicUsize::new(0));
+    let (senders, gates): (Vec<_>, Vec<_>) = (0..3).map(|_| oneshot::channel()).unzip();
+    universe.spawn_builder().spawn(LateInitializer {
+        gates,
+        finalized: finalized.clone(),
+    });
+    let shutdown = quiesce(&universe);
+    tokio::pin!(shutdown);
+    let mut returned_early = false;
+    for sender in senders {
+        if !returned_early {
+            returned_early = tokio::time::timeout(Duration::from_millis(100), &mut shutdown)
+                .await
+                .is_ok();
+        }
+        sender.send(()).unwrap();
+    }
+    if !returned_early {
+        tokio::time::timeout(Duration::from_secs(5), &mut shutdown)
+            .await
+            .unwrap();
+    }
+    // Also clean up descendants when testing a broken, single-snapshot implementation.
+    for _ in 0..4 {
+        universe.quit().await;
+    }
+    assert!(
+        !returned_early,
+        "rollback barrier missed an initializing descendant"
+    );
+    assert_eq!(finalized.load(Ordering::SeqCst), 3);
+}
+
+fn args() -> LocalIngestDocsArgs {
+    LocalIngestDocsArgs {
+        config_uri: Uri::for_test("file:///unused-config"),
+        index_id: "test-index".to_string(),
+        input_path_opt: None,
+        input_format: SourceInputFormat::Json,
+        overwrite: false,
+        vrl_script: None,
+        clear_cache: true,
+        num_pipelines: NonZeroUsize::MIN,
+        batch_num_rows_opt: None,
+    }
+}
+
+async fn populated_index() -> (IndexService, IndexUid, StorageResolver) {
+    let metastore = metastore_for_test();
+    let resolver = StorageResolver::for_test();
+    let mut service = IndexService::new(metastore.clone(), resolver.clone());
+    let metadata = service
+        .create_index(
+            IndexConfig::for_test("test-index", "ram:///test-index"),
+            false,
+        )
+        .await
+        .unwrap();
+    let split = SplitMetadata {
+        index_uid: metadata.index_uid.clone(),
+        split_id: "published".into(),
+        ..Default::default()
+    };
+    metastore
+        .stage_splits(
+            StageSplitsRequest::try_from_splits_metadata(metadata.index_uid.clone(), vec![split])
+                .unwrap(),
+        )
+        .await
+        .unwrap();
+    metastore
+        .publish_splits(PublishSplitsRequest {
+            index_uid: Some(metadata.index_uid.clone()),
+            staged_split_ids: vec!["published".into()],
+            ..Default::default()
+        })
+        .await
+        .unwrap();
+    let storage = resolver.resolve(metadata.index_uri()).await.unwrap();
+    storage
+        .put(Path::new("published.split"), Box::new(vec![1u8]))
+        .await
+        .unwrap();
+    (service, metadata.index_uid, resolver)
+}
+
+#[tokio::test]
+async fn test_cache_cleanup_failure_rolls_back_published_splits() {
+    let (mut service, index_uid, resolver) = populated_index().await;
+    let temp_dir = tempfile::tempdir().unwrap();
+    let mut config = NodeConfig::for_test();
+    config.data_dir_path = temp_dir.path().to_path_buf();
+    let cache_path = get_cache_directory_path(temp_dir.path());
+    std::fs::create_dir_all(cache_path.parent().unwrap()).unwrap();
+    // An uncleanable cache path fails deterministically, including when tests run as root.
+    std::fs::write(&cache_path, b"not a directory").unwrap();
+    let result = finish_load(Ok(()), &mut service, &args(), &config, &index_uid).await;
+    assert!(result.is_err());
+    let splits = service
+        .metastore()
+        .list_splits(ListSplitsRequest::try_from_index_uid(index_uid).unwrap())
+        .await
+        .unwrap()
+        .collect_splits_metadata()
+        .await
+        .unwrap();
+    assert!(splits.is_empty());
+    let storage = resolver
+        .resolve(&Uri::for_test("ram:///test-index"))
+        .await
+        .unwrap();
+    assert!(!storage.exists(Path::new("published.split")).await.unwrap());
+}
+
+#[tokio::test]
+#[allow(clippy::result_large_err)] // MockStorage's bulk_delete signature.
+async fn test_rollback_reports_suppressed_deletion_error_and_load_error() {
+    let (service, index_uid, _) = populated_index().await;
+    let mut storage = MockStorage::new();
+    storage.expect_bulk_delete().times(1).returning(|paths| {
+        Err(BulkDeleteError {
+            unattempted: paths.iter().map(|path| path.to_path_buf()).collect(),
+            ..Default::default()
+        })
+    });
+    let storage = Arc::new(storage);
+    let mut factory = MockStorageFactory::new();
+    factory.expect_backend().returning(|| StorageBackend::Ram);
+    factory
+        .expect_resolve()
+        .returning(move |_| Ok(storage.clone()));
+    let resolver = StorageResolver::builder()
+        .register(factory)
+        .build()
+        .unwrap();
+    let mut service = IndexService::new(service.metastore(), resolver);
+    let mut args = args();
+    args.clear_cache = false;
+    let error = finish_load(
+        Err(anyhow::anyhow!("injected load failure")),
+        &mut service,
+        &args,
+        &NodeConfig::for_test(),
+        &index_uid,
+    )
+    .await
+    .unwrap_err();
+    let details = format!("{error:#}");
+    assert!(details.contains("injected load failure"), "{details}");
+    assert!(
+        details.contains("index cleanup left split metadata behind"),
+        "{details}"
+    );
+}
diff --git a/quickwit/quickwit-cli/src/tool/parquet_ingest/tests.rs b/quickwit/quickwit-cli/src/tool/parquet_ingest/tests.rs
new file mode 100644
index 00000000000..480038cd4ce
--- /dev/null
+++ b/quickwit/quickwit-cli/src/tool/parquet_ingest/tests.rs
@@ -0,0 +1,84 @@
+// Copyright 2021-Present Datadog, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::num::NonZeroUsize;
+
+use quickwit_common::uri::Uri;
+use quickwit_config::{IndexConfig, SourceInputFormat};
+use quickwit_indexing::actors::{MergePipeline, MergeSchedulerService};
+use quickwit_indexing::source::quickwit_supported_sources;
+use quickwit_metastore::metastore_for_test;
+use quickwit_storage::StorageResolver;
+
+use super::*;
+
+#[tokio::test]
+async fn test_spawn_pipelines_without_merges() {
+    let temp_dir = tempfile::tempdir().unwrap();
+    let mut config = NodeConfig::for_test();
+    config.data_dir_path = temp_dir.path().to_path_buf();
+    let metastore = metastore_for_test();
+    let storage_resolver = StorageResolver::for_test();
+    let mut index_service = IndexService::new(metastore.clone(), storage_resolver.clone());
+    index_service
+        .create_index(
+            IndexConfig::for_test("test-index", "ram:///test-index"),
+            false,
+        )
+        .await
+        .unwrap();
+    let args = LocalIngestDocsArgs {
+        config_uri: Uri::for_test("file:///unused-config"),
+        index_id: "test-index".to_string(),
+        input_path_opt: None,
+        input_format: SourceInputFormat::Json,
+        overwrite: false,
+        vrl_script: None,
+        clear_cache: false,
+        num_pipelines: NonZeroUsize::new(2).unwrap(),
+        batch_num_rows_opt: None,
+    };
+    let source_config = SourceConfig {
+        source_id: CLI_SOURCE_ID.to_string(),
+        num_pipelines: args.num_pipelines,
+        enabled: true,
+        // Keep pipelines alive while checking that no merge actors were created.
+        source_params: SourceParams::void(),
+        transform_config: None,
+        input_format: SourceInputFormat::Json,
+    };
+    let universe = Universe::new();
+    let (mailbox, service_handle) = spawn_indexing_service(
+        &universe,
+        &config,
+        metastore,
+        storage_resolver,
+        quickwit_supported_sources().clone(),
+        false,
+    )
+    .await
+    .unwrap();
+    let spawn_result = spawn_pipelines(&mailbox, &args, source_config).await;
+    let num_indexing_pipelines = universe.get::<IndexingPipeline>().len();
+    let num_merge_pipelines = universe.get::<MergePipeline>().len();
+    let num_merge_schedulers = universe.get::<MergeSchedulerService>().len();
+    universe.kill();
+    service_handle.kill().await;
+    lifecycle::quiesce(&universe).await;
+
+    assert_eq!(spawn_result.unwrap().len(), 2);
+    assert_eq!(num_indexing_pipelines, 2);
+    assert_eq!(num_merge_pipelines, 0);
+    assert_eq!(num_merge_schedulers, 0);
+}
diff --git a/quickwit/quickwit-cli/src/tool/parquet_report.rs b/quickwit/quickwit-cli/src/tool/parquet_report.rs
new file mode 100644
index 00000000000..13a390c1911
--- /dev/null
+++ b/quickwit/quickwit-cli/src/tool/parquet_report.rs
@@ -0,0 +1,126 @@
+// Copyright 2021-Present Datadog, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Report of a Parquet bulk load.
+
+use std::time::Duration;
+
+use anyhow::bail;
+use bytesize::ByteSize;
+use colored::Colorize;
+use humantime::format_duration;
+use quickwit_common::uri::Uri;
+use quickwit_config::IndexConfig;
+use quickwit_indexing::models::IndexingStatistics;
+use quickwit_indexing::source::parquet_file::ParquetLoadPlan;
+use quickwit_metastore::SplitMetadata;
+use thousands::Separable;
+
+pub(super) struct LoadReport<'a> {
+    pub num_pipelines: usize,
+    pub plan: &'a ParquetLoadPlan,
+    pub indexing_statistics: IndexingStatistics,
+    pub elapsed: Duration,
+    pub splits: Vec<SplitMetadata>,
+    pub index_config: &'a IndexConfig,
+    pub metastore_uri: &'a Uri,
+}
+
+impl LoadReport<'_> {
+    pub fn print(&self) {
+        let statistics = &self.indexing_statistics;
+        let num_docs = statistics.num_docs;
+        let ndjson_num_bytes = statistics.total_bytes_processed;
+        let splits_num_bytes: u64 = self
+            .splits
+            .iter()
+            .map(|split| split.footer_offsets.end)
+            .sum();
+        let indexing_settings = &self.index_config.indexing_settings;
+        let metastore_type = if self.metastore_uri.protocol().is_database() {
+            "PostgreSQL"
+        } else {
+            "file-backed"
+        };
+        println!();
+        println!("{}", "Parquet bulk load report".bold());
+        println!(
+            "  Input:        {} rows, {} uncompressed Parquet, {} NDJSON",
+            self.plan.num_rows().separate_with_commas(),
+            ByteSize(self.plan.num_uncompressed_bytes()),
+            ByteSize(ndjson_num_bytes),
+        );
+        println!(
+            "  Docs:         {} processed, {} invalid",
+            num_docs.separate_with_commas(),
+            statistics.num_invalid_docs.separate_with_commas()
+        );
+        println!(
+            "  Elapsed:      {}, {}",
+            format_elapsed(self.elapsed),
+            format_throughput(num_docs, ndjson_num_bytes, self.elapsed)
+        );
+        println!(
+            "  Splits:       {} ({})",
+            self.splits.len(),
+            ByteSize(splits_num_bytes),
+        );
+        println!(
+            "  Settings:     num_pipelines={}, batch_num_rows={}, heap_size={}, \
+             split_num_docs_target={}, commit_timeout_secs={}, metastore={metastore_type}",
+            self.num_pipelines,
+            self.plan.batch_num_rows(),
+            indexing_settings.resources.heap_size,
+            indexing_settings.split_num_docs_target,
+            indexing_settings.commit_timeout_secs,
+        );
+        println!("  Merging:      disabled for Parquet bulk loads");
+    }
+
+    /// Rejects invalid documents or row counts that disagree with the Parquet footer.
+    pub fn check(&self) -> anyhow::Result<()> {
+        let statistics = &self.indexing_statistics;
+        if statistics.num_invalid_docs > 0 {
+            bail!(
+                "failed to index {} document(s)",
+                statistics.num_invalid_docs.separate_with_commas()
+            );
+        }
+        let num_split_docs: usize = self.splits.iter().map(|split| split.num_docs).sum();
+        if statistics.num_docs != self.plan.num_rows()
+            || num_split_docs as u64 != self.plan.num_rows()
+        {
+            bail!(
+                "indexed {} documents ({} in the splits) but the Parquet file has {} rows",
+                statistics.num_docs.separate_with_commas(),
+                num_split_docs.separate_with_commas(),
+                self.plan.num_rows().separate_with_commas()
+            );
+        }
+        Ok(())
+    }
+}
+
+fn format_elapsed(elapsed: Duration) -> String {
+    format_duration(Duration::from_millis(elapsed.as_millis() as u64)).to_string()
+}
+
+fn format_throughput(num_docs: u64, num_bytes: u64, elapsed: Duration) -> String {
+    let secs = elapsed.as_secs_f64().max(f64::EPSILON);
+    format!(
+        "{:.0} docs/s, {:.2} MB/s",
+        num_docs as f64 / secs,
+        num_bytes as f64 / 1_000_000.0 / secs
+    )
+}
diff --git a/quickwit/quickwit-cli/tests/cli.rs b/quickwit/quickwit-cli/tests/cli.rs
index aebdfa9a925..06743ac0e12 100644
--- a/quickwit/quickwit-cli/tests/cli.rs
+++ b/quickwit/quickwit-cli/tests/cli.rs
@@ -67,6 +67,8 @@ async fn local_ingest_docs(uri: Uri, test_env: &TestEnv) -> anyhow::Result<()> {
         overwrite: false,
         clear_cache: true,
         vrl_script: None,
+        num_pipelines: std::num::NonZeroUsize::MIN,
+        batch_num_rows_opt: None,
     };
     local_ingest_docs_cli(args).await
 }
@@ -177,6 +179,8 @@ async fn test_cmd_ingest_on_non_existing_index() {
         overwrite: false,
         clear_cache: true,
         vrl_script: None,
+        num_pipelines: std::num::NonZeroUsize::MIN,
+        batch_num_rows_opt: None,
     };
 
     let error = local_ingest_docs_cli(args).await.unwrap_err();
@@ -207,6 +211,8 @@ async fn test_ingest_docs_cli_keep_cache() {
         overwrite: false,
         clear_cache: false,
         vrl_script: None,
+        num_pipelines: std::num::NonZeroUsize::MIN,
+        batch_num_rows_opt: None,
     };
 
     local_ingest_docs_cli(args).await.unwrap();
@@ -234,6 +240,8 @@ async fn test_ingest_docs_cli() {
         overwrite: false,
         clear_cache: true,
         vrl_script: None,
+        num_pipelines: std::num::NonZeroUsize::MIN,
+        batch_num_rows_opt: None,
     };
 
     local_ingest_docs_cli(args).await.unwrap();
@@ -268,6 +276,8 @@ async fn test_ingest_docs_cli() {
         overwrite: false,
         clear_cache: true,
         vrl_script: None,
+        num_pipelines: std::num::NonZeroUsize::MIN,
+        batch_num_rows_opt: None,
     };
 
     let error = local_ingest_docs_cli(args).await.unwrap_err();
@@ -300,6 +310,8 @@ async fn test_reingest_same_file_cli() {
             overwrite: false,
             clear_cache: true,
             vrl_script: None,
+            num_pipelines: std::num::NonZeroUsize::MIN,
+            batch_num_rows_opt: None,
         };
 
         local_ingest_docs_cli(args).await.unwrap();
diff --git a/quickwit/quickwit-cli/tests/parquet.rs b/quickwit/quickwit-cli/tests/parquet.rs
new file mode 100644
index 00000000000..90ccf271893
--- /dev/null
+++ b/quickwit/quickwit-cli/tests/parquet.rs
@@ -0,0 +1,255 @@
+// Copyright 2021-Present Datadog, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#![cfg(feature = "parquet")]
+
+use std::num::NonZeroUsize;
+
+use quickwit_cli::tool::{LocalIngestDocsArgs, local_ingest_docs_cli};
+use quickwit_common::rand::append_random_suffix;
+use quickwit_common::uri::Uri;
+use quickwit_config::{ConfigFormat, SourceInputFormat, load_index_config_from_user_config};
+use quickwit_index_management::IndexService;
+use quickwit_indexing::source::parquet_file::{
+    ParquetLoadPlan, write_f64_values_as_parquet_file, write_json_docs_as_parquet_file,
+};
+use quickwit_metastore::{
+    ListSplitsQuery, ListSplitsRequestExt, MetastoreServiceStreamSplitsExt, SplitMetadata,
+    SplitState,
+};
+use quickwit_proto::metastore::{ListSplitsRequest, MetastoreService};
+use serde_json::json;
+
+use crate::helpers::{TestEnv, TestStorageType, create_test_env, uri_from_path};
+
+#[allow(dead_code)]
+mod helpers;
+
+const NUM_ROWS: usize = 1_000;
+const ROW_GROUP_NUM_ROWS: usize = 50;
+
+const INDEX_CONFIG: &str = r#"
+    version: 0.8
+    index_id: #index_id
+    index_uri: #index_uri
+    doc_mapping:
+      field_mappings:
+        - name: ts
+          type: datetime
+          input_formats: [unix_timestamp]
+          fast: true
+        - name: event
+          type: text
+        - name: city
+          type: text
+          tokenizer: raw
+      timestamp_field: ts
+    indexing_settings:
+      commit_timeout_secs: 3600
+      split_num_docs_target: 300
+      merge_policy:
+        type: no_merge
+      resources:
+        heap_size: 50MB
+"#;
+
+#[tokio::test]
+async fn test_local_ingest_parquet_with_multiple_pipelines() {
+    quickwit_common::setup_logging_for_tests();
+    let index_id = append_random_suffix("test-parquet-local-ingest");
+    let test_env = create_test_env(index_id.clone(), TestStorageType::LocalFileSystem)
+        .await
+        .unwrap();
+    let index_config_yaml = INDEX_CONFIG
+        .replace("#index_id", &index_id)
+        .replace("#index_uri", test_env.index_uri.as_str());
+    let index_config = load_index_config_from_user_config(
+        ConfigFormat::Yaml,
+        index_config_yaml.as_bytes(),
+        &test_env.index_uri,
+    )
+    .unwrap();
+    let metastore = test_env.metastore().await;
+    let mut index_service = IndexService::new(metastore.clone(), test_env.storage_resolver.clone());
+    index_service
+        .create_index(index_config.clone(), false)
+        .await
+        .unwrap();
+
+    let json_docs: Vec<serde_json::Value> = (0..NUM_ROWS)
+        .map(|row_idx| {
+            let city = ["paris", "tokyo", "london"][row_idx % 3];
+            json!({
+                "ts": 1_700_000_000 + row_idx as i64,
+                "event": format!("event-{row_idx}"),
+                "city": city,
+            })
+        })
+        .collect();
+    let parquet_path = test_env.data_dir_path.join("docs.parquet");
+    write_json_docs_as_parquet_file(&parquet_path, &json_docs, ROW_GROUP_NUM_ROWS).unwrap();
+    let parquet_uri: Uri = uri_from_path(&parquet_path);
+
+    let mut args = parquet_args(&test_env, &index_id, &parquet_uri, false);
+    args.num_pipelines = NonZeroUsize::new(4).unwrap();
+    args.batch_num_rows_opt = NonZeroUsize::new(16);
+    local_ingest_docs_cli(args).await.unwrap();
+
+    let splits = list_published_splits(&test_env).await;
+    let num_docs: usize = splits.iter().map(|split| split.num_docs).sum();
+    assert_eq!(num_docs, NUM_ROWS);
+    // No merges: split at 300 docs (plus at most one 16-row batch) or pipeline EOF.
+    assert!(splits.len() >= 4);
+    assert!(splits.iter().all(|split| split.num_docs <= 300 + 16));
+
+    // A load requires an empty index.
+    let error = local_ingest_docs_cli(parquet_args(&test_env, &index_id, &parquet_uri, false))
+        .await
+        .unwrap_err();
+    assert!(error.to_string().contains("--overwrite"));
+    assert_eq!(list_published_splits(&test_env).await.len(), splits.len());
+
+    // A missing timestamp must fail the load and clear the index.
+    let mut invalid_json_docs = json_docs;
+    invalid_json_docs[500] = json!({"event": "no-timestamp"});
+    let invalid_parquet_path = test_env.data_dir_path.join("invalid-docs.parquet");
+    write_json_docs_as_parquet_file(
+        &invalid_parquet_path,
+        &invalid_json_docs,
+        ROW_GROUP_NUM_ROWS,
+    )
+    .unwrap();
+    let invalid_parquet_uri: Uri = uri_from_path(&invalid_parquet_path);
+    let error = local_ingest_docs_cli(parquet_args(
+        &test_env,
+        &index_id,
+        &invalid_parquet_uri,
+        true,
+    ))
+    .await
+    .unwrap_err();
+    assert!(error.to_string().contains("failed to index 1 document"));
+    assert!(list_published_splits(&test_env).await.is_empty());
+}
+
+#[tokio::test]
+async fn test_local_ingest_parquet_rolls_back_nonfinite_later_batch() {
+    quickwit_common::setup_logging_for_tests();
+    for value in [f64::NAN, f64::INFINITY, f64::NEG_INFINITY] {
+        let index_id = append_random_suffix("test-parquet-nonfinite");
+        let test_env = create_test_env(index_id.clone(), TestStorageType::LocalFileSystem)
+            .await
+            .unwrap();
+        let config = json!({
+            "version": "0.8",
+            "index_id": index_id,
+            "index_uri": test_env.index_uri.as_str(),
+            "doc_mapping": {"field_mappings": [{"name": "value", "type": "f64"}]},
+            "indexing_settings": {
+                "split_num_docs_target": 100,
+                "merge_policy": {"type": "no_merge"},
+                "resources": {"heap_size": "50MB"}
+            }
+        });
+        let index_config = load_index_config_from_user_config(
+            ConfigFormat::Json,
+            &serde_json::to_vec(&config).unwrap(),
+            &test_env.index_uri,
+        )
+        .unwrap();
+        let mut index_service = IndexService::new(
+            test_env.metastore().await,
+            test_env.storage_resolver.clone(),
+        );
+        index_service
+            .create_index(index_config, false)
+            .await
+            .unwrap();
+        let path = test_env.data_dir_path.join("nonfinite.parquet");
+        let mut values = vec![1.0; NUM_ROWS];
+        values.push(value);
+        write_f64_values_as_parquet_file(&path, &values, values.len()).unwrap();
+        let uri = uri_from_path(&path);
+        // Preflight only checks the first row; the invalid value is in a later decoded batch.
+        ParquetLoadPlan::try_new(uri.clone(), 16).unwrap();
+        let mut args = parquet_args(&test_env, &index_id, &uri, false);
+        args.num_pipelines = NonZeroUsize::MIN;
+        args.batch_num_rows_opt = NonZeroUsize::new(16);
+        let error = tokio::time::timeout(
+            std::time::Duration::from_secs(30),
+            local_ingest_docs_cli(args),
+        )
+        .await
+        .expect("non-finite input must not hang shutdown")
+        .unwrap_err();
+        assert!(
+            error.to_string().contains("indexing pipeline failed"),
+            "{error:#}"
+        );
+        let index_uid = test_env.index_metadata().await.unwrap().index_uid;
+        let splits = test_env
+            .metastore()
+            .await
+            .list_splits(ListSplitsRequest::try_from_index_uid(index_uid).unwrap())
+            .await
+            .unwrap()
+            .collect_splits_metadata()
+            .await
+            .unwrap();
+        assert!(splits.is_empty(), "rollback must clear every split state");
+        for entry in std::fs::read_dir(test_env.index_uri.filepath().unwrap()).unwrap() {
+            assert_ne!(
+                entry
+                    .unwrap()
+                    .path()
+                    .extension()
+                    .and_then(|extension| extension.to_str()),
+                Some("split")
+            );
+        }
+    }
+}
+
+fn parquet_args(
+    test_env: &TestEnv,
+    index_id: &str,
+    parquet_uri: &Uri,
+    overwrite: bool,
+) -> LocalIngestDocsArgs {
+    LocalIngestDocsArgs {
+        config_uri: test_env.resource_files.config.clone(),
+        index_id: index_id.to_string(),
+        input_path_opt: Some(parquet_uri.clone()),
+        input_format: SourceInputFormat::Json,
+        overwrite,
+        vrl_script: None,
+        clear_cache: true,
+        num_pipelines: NonZeroUsize::new(2).unwrap(),
+        batch_num_rows_opt: None,
+    }
+}
+
+async fn list_published_splits(test_env: &TestEnv) -> Vec<SplitMetadata> {
+    let index_uid = test_env.index_metadata().await.unwrap().index_uid;
+    let query = ListSplitsQuery::for_index(index_uid).with_split_state(SplitState::Published);
+    test_env
+        .metastore()
+        .await
+        .list_splits(ListSplitsRequest::try_from_list_splits_query(&query).unwrap())
+        .await
+        .unwrap()
+        .collect_splits_metadata()
+        .await
+        .unwrap()
+}
diff --git a/quickwit/quickwit-indexing/Cargo.toml b/quickwit/quickwit-indexing/Cargo.toml
index a0dc08b0ee5..6461baf877f 100644
--- a/quickwit/quickwit-indexing/Cargo.toml
+++ b/quickwit/quickwit-indexing/Cargo.toml
@@ -13,10 +13,15 @@ license.workspace = true
 [dependencies]
 anyhow = { workspace = true }
 arc-swap = { workspace = true }
+# `chrono-tz` is required to format timestamps with a named time zone, e.g. `UTC`.
+arrow-array = { workspace = true, optional = true, features = ["chrono-tz"] }
+arrow-json = { workspace = true, optional = true }
+arrow-schema = { workspace = true, optional = true }
 async-compression = { workspace = true }
 async-trait = { workspace = true }
 aws-sdk-kinesis = { workspace = true, optional = true }
 aws-sdk-sqs = { workspace = true, optional = true }
+base64 = { workspace = true, optional = true }
 bytes = { workspace = true }
 bytesize = { workspace = true }
 fail = { workspace = true }
@@ -30,6 +35,7 @@ google-cloud-pubsub = { workspace = true, optional = true }
 itertools = { workspace = true }
 libz-sys = { workspace = true, optional = true }
 oneshot = { workspace = true }
+parquet = { workspace = true, optional = true, features = ["arrow", "snap", "zstd", "lz4"] }
 openssl = { workspace = true, optional = true }
 percent-encoding = { workspace = true }
 pulsar = { workspace = true, optional = true }
@@ -80,6 +86,13 @@ kinesis = [
   "quickwit-aws/kinesis",
 ]
 kinesis-localstack-tests = []
+parquet = [
+  "dep:arrow-array",
+  "dep:arrow-json",
+  "dep:arrow-schema",
+  "dep:base64",
+  "dep:parquet",
+]
 pulsar = ["dep:pulsar"]
 pulsar-broker-tests = []
 queue-sources = []
diff --git a/quickwit/quickwit-indexing/src/actors/indexing_pipeline.rs b/quickwit/quickwit-indexing/src/actors/indexing_pipeline.rs
index f3f044f5114..e0090cdcd8b 100644
--- a/quickwit/quickwit-indexing/src/actors/indexing_pipeline.rs
+++ b/quickwit/quickwit-indexing/src/actors/indexing_pipeline.rs
@@ -45,9 +45,7 @@ use crate::docs_clustering::Fingerprinter;
 use crate::merge_policy::MergePolicy;
 use crate::metrics::{ACTOR_NAME, BACKPRESSURE_MICROS, INDEXING_PIPELINES};
 use crate::models::{IndexingStatistics, SharedPublishToken};
-use crate::source::{
-    AssignShards, Assignment, SourceActor, SourceRuntime, quickwit_supported_sources,
-};
+use crate::source::{AssignShards, Assignment, SourceActor, SourceLoader, SourceRuntime};
 use crate::split_store::IndexingSplitStore;
 
 pub(crate) const SUPERVISE_INTERVAL: Duration = Duration::from_secs(1);
@@ -438,7 +436,7 @@ impl IndexingPipeline {
             publish_token: self.publish_token.clone(),
         };
         let source = ctx
-            .protect_future(quickwit_supported_sources().load_source(source_runtime))
+            .protect_future(self.params.source_loader.load_source(source_runtime))
             .await?;
         let actor_source = SourceActor::new(source, doc_processor_mailbox);
         let (source_mailbox, source_handle) = ctx
@@ -598,6 +596,9 @@ pub struct IndexingPipelineParams {
 
     // Source-related parameters
     pub source_config: SourceConfig,
+    /// Creates the source of the pipeline. Servers use
+    /// [`quickwit_supported_sources`](crate::source::quickwit_supported_sources).
+    pub source_loader: Arc<SourceLoader>,
     pub source_storage_resolver: StorageResolver,
     pub ingester_pool: IngesterPool,
     pub queues_dir_path: PathBuf,
@@ -630,6 +631,7 @@ mod tests {
     use super::{IndexingPipeline, *};
     use crate::actors::{MergePipeline, MergePipelineParams};
     use crate::merge_policy::default_merge_policy;
+    use crate::source::quickwit_supported_sources;
 
     #[test]
     fn test_wait_duration() {
@@ -720,6 +722,7 @@ mod tests {
             doc_mapper: Arc::new(default_doc_mapper_for_test()),
             source_config,
             source_storage_resolver: StorageResolver::for_test(),
+            source_loader: quickwit_supported_sources().clone(),
             indexing_directory: TempDirectory::for_test(),
             indexing_settings: IndexingSettings::for_test(),
             fingerprinter_opt: None,
@@ -828,6 +831,7 @@ mod tests {
             doc_mapper: Arc::new(default_doc_mapper_for_test()),
             source_config,
             source_storage_resolver: StorageResolver::for_test(),
+            source_loader: quickwit_supported_sources().clone(),
             indexing_directory: TempDirectory::for_test(),
             indexing_settings: IndexingSettings::for_test(),
             fingerprinter_opt: None,
@@ -959,6 +963,7 @@ mod tests {
             doc_mapper: Arc::new(default_doc_mapper_for_test()),
             source_config,
             source_storage_resolver: StorageResolver::for_test(),
+            source_loader: quickwit_supported_sources().clone(),
             indexing_directory: TempDirectory::for_test(),
             indexing_settings: IndexingSettings::for_test(),
             fingerprinter_opt: None,
@@ -1061,6 +1066,7 @@ mod tests {
             doc_mapper,
             source_config,
             source_storage_resolver: StorageResolver::for_test(),
+            source_loader: quickwit_supported_sources().clone(),
             indexing_directory: TempDirectory::for_test(),
             indexing_settings: IndexingSettings::for_test(),
             fingerprinter_opt: None,
@@ -1146,6 +1152,7 @@ mod tests {
             doc_mapper: Arc::new(default_doc_mapper_for_test()),
             source_config,
             source_storage_resolver: StorageResolver::for_test(),
+            source_loader: quickwit_supported_sources().clone(),
             indexing_directory: TempDirectory::for_test(),
             indexing_settings: IndexingSettings::for_test(),
             fingerprinter_opt: None,
@@ -1301,6 +1308,7 @@ mod tests {
             doc_mapper: Arc::new(broken_mapper),
             source_config,
             source_storage_resolver: StorageResolver::for_test(),
+            source_loader: quickwit_supported_sources().clone(),
             indexing_directory: TempDirectory::for_test(),
             indexing_settings: IndexingSettings::for_test(),
             fingerprinter_opt: None,
diff --git a/quickwit/quickwit-indexing/src/actors/indexing_service.rs b/quickwit/quickwit-indexing/src/actors/indexing_service.rs
index 97e0cf31b5c..ef0a7979b26 100644
--- a/quickwit/quickwit-indexing/src/actors/indexing_service.rs
+++ b/quickwit/quickwit-indexing/src/actors/indexing_service.rs
@@ -62,7 +62,7 @@ use super::merge_pipeline::{MergePipeline, MergePipelineParams};
 use super::{FinishPendingMergesAndShutdownPipeline, MergePlanner, MergeSchedulerService};
 use crate::docs_clustering::Fingerprinter;
 use crate::models::{DetachIndexingPipeline, DetachMergePipeline, ObservePipeline, SpawnPipeline};
-use crate::source::{AssignShards, Assignment};
+use crate::source::{AssignShards, Assignment, SourceLoader, quickwit_supported_sources};
 use crate::split_store::IndexingSplitCache;
 use crate::{IndexingPipeline, IndexingPipelineParams, IndexingSplitStore, IndexingStatistics};
 
@@ -123,6 +123,8 @@ pub struct IndexingService {
     indexing_io_throughput_limiter_opt: Option<io::Limiter>,
     merge_io_throughput_limiter_opt: Option<io::Limiter>,
     event_broker: EventBroker,
+    /// Creates the sources of the indexing pipelines.
+    source_loader: Arc<SourceLoader>,
 }
 
 impl Debug for IndexingService {
@@ -185,9 +187,16 @@ impl IndexingService {
             merge_io_throughput_limiter_opt,
             cooperative_indexing_permits,
             event_broker,
+            source_loader: quickwit_supported_sources().clone(),
         })
     }
 
+    /// Overrides [`quickwit_supported_sources`] for CLI-only sources.
+    pub fn with_source_loader(mut self, source_loader: Arc<SourceLoader>) -> Self {
+        self.source_loader = source_loader;
+        self
+    }
+
     async fn detach_indexing_pipeline(
         &mut self,
         pipeline_uid: &PipelineUid,
@@ -403,6 +412,7 @@ impl IndexingService {
             ingester_pool: self.ingester_pool.clone(),
             queues_dir_path: self.queue_dir_path.clone(),
             source_storage_resolver: self.storage_resolver.clone(),
+            source_loader: self.source_loader.clone(),
             params_fingerprint,
             event_broker: self.event_broker.clone(),
         };
diff --git a/quickwit/quickwit-indexing/src/source/mod.rs b/quickwit/quickwit-indexing/src/source/mod.rs
index 372c22c72c5..5b1fb799522 100644
--- a/quickwit/quickwit-indexing/src/source/mod.rs
+++ b/quickwit/quickwit-indexing/src/source/mod.rs
@@ -62,6 +62,8 @@ mod ingest_api_source;
 mod kafka_source;
 #[cfg(feature = "kinesis")]
 mod kinesis;
+#[cfg(feature = "parquet")]
+pub mod parquet_file;
 #[cfg(feature = "pulsar")]
 mod pulsar_source;
 #[cfg(feature = "queue-sources")]
@@ -73,7 +75,7 @@ mod void_source;
 
 use std::collections::BTreeSet;
 use std::path::PathBuf;
-use std::sync::LazyLock;
+use std::sync::{Arc, LazyLock};
 use std::time::Duration;
 
 use async_trait::async_trait;
@@ -418,8 +420,8 @@ impl Handler<AssignShards> for SourceActor {
 }
 
 // TODO: Use `SourceType` instead of `&str``.
-pub fn quickwit_supported_sources() -> &'static SourceLoader {
-    static SOURCE_LOADER: LazyLock<SourceLoader> = LazyLock::new(|| {
+pub fn quickwit_supported_sources() -> &'static Arc<SourceLoader> {
+    static SOURCE_LOADER: LazyLock<Arc<SourceLoader>> = LazyLock::new(|| {
         let mut source_factory = SourceLoader::default();
         source_factory.add_source(SourceType::File, FileSourceFactory);
         #[cfg(feature = "gcp-pubsub")]
@@ -435,7 +437,7 @@ pub fn quickwit_supported_sources() -> &'static SourceLoader {
         source_factory.add_source(SourceType::Stdin, StdinSourceFactory);
         source_factory.add_source(SourceType::Vec, VecSourceFactory);
         source_factory.add_source(SourceType::Void, VoidSourceFactory);
-        source_factory
+        Arc::new(source_factory)
     });
     &SOURCE_LOADER
 }
diff --git a/quickwit/quickwit-indexing/src/source/parquet_file/conversion_tests.rs b/quickwit/quickwit-indexing/src/source/parquet_file/conversion_tests.rs
new file mode 100644
index 00000000000..36bfd0ebf50
--- /dev/null
+++ b/quickwit/quickwit-indexing/src/source/parquet_file/conversion_tests.rs
@@ -0,0 +1,315 @@
+// Copyright 2021-Present Datadog, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::fs::File;
+use std::sync::Arc;
+
+use arrow_array::types::{Float16Type, Float64Type, Int32Type};
+use arrow_array::{
+    ArrayRef, ArrowPrimitiveType, BinaryArray, BinaryViewArray, DictionaryArray,
+    FixedSizeBinaryArray, FixedSizeListArray, Float16Array, Float32Array, Float64Array, Int32Array,
+    LargeBinaryArray, LargeListArray, ListArray, PrimitiveArray, RecordBatch, StructArray,
+};
+use arrow_schema::Field;
+use parquet::arrow::arrow_reader::ParquetRecordBatchReaderBuilder;
+use quickwit_doc_mapper::DocMapperBuilder;
+use serde_json::json;
+use tantivy::schema::Value;
+
+use super::source::record_batch_to_ndjson_docs;
+use super::testsuite::write_record_batch_as_parquet_file;
+
+fn batch(array: ArrayRef) -> RecordBatch {
+    RecordBatch::try_from_iter([("value", array)]).unwrap()
+}
+
+fn nested(array: ArrayRef) -> ArrayRef {
+    Arc::new(StructArray::from(vec![(
+        Arc::new(Field::new("inner", array.data_type().clone(), true)),
+        array,
+    )]))
+}
+
+#[test]
+fn test_parquet_native_binary_preserves_default_bytes_mapping() {
+    let values = vec![Some(&[1, 2][..]), None, Some(&[0, 255][..])];
+    let arrays: Vec<ArrayRef> = vec![
+        Arc::new(BinaryArray::from(values.clone())),
+        Arc::new(LargeBinaryArray::from(values.clone())),
+        Arc::new(BinaryViewArray::from(values.clone())),
+        Arc::new(
+            FixedSizeBinaryArray::try_from_sparse_iter_with_size(values.into_iter(), 2).unwrap(),
+        ),
+        Arc::new(
+            DictionaryArray::<Int32Type>::try_new(
+                Int32Array::from(vec![Some(0), None, Some(1)]),
+                Arc::new(BinaryArray::from(vec![&[1, 2][..], &[0, 255][..]])),
+            )
+            .unwrap(),
+        ),
+    ];
+    let mapper = serde_json::from_value::<DocMapperBuilder>(json!({
+        "field_mappings": [{"name": "value", "type": "bytes"}]
+    }))
+    .unwrap()
+    .try_build()
+    .unwrap();
+    let field = mapper.schema().get_field("value").unwrap();
+    let temp_dir = tempfile::tempdir().unwrap();
+    let path = temp_dir.path().join("binary.parquet");
+
+    for array in arrays {
+        let native_batch = batch(array);
+        write_record_batch_as_parquet_file(&path, &native_batch, 3).unwrap();
+        let decoded_batch = ParquetRecordBatchReaderBuilder::try_new(File::open(&path).unwrap())
+            .unwrap()
+            .build()
+            .unwrap()
+            .next()
+            .unwrap()
+            .unwrap();
+        for record_batch in [&native_batch, &decoded_batch] {
+            let docs = record_batch_to_ndjson_docs(record_batch).unwrap();
+            assert_eq!(
+                serde_json::from_slice::<serde_json::Value>(&docs[0]).unwrap(),
+                json!({"value": "AQI="})
+            );
+            assert_eq!(
+                serde_json::from_slice::<serde_json::Value>(&docs[1]).unwrap(),
+                json!({})
+            );
+            for (row, expected) in [(0, &[1, 2][..]), (2, &[0, 255][..])] {
+                let (_, doc) = mapper.doc_from_json_bytes(&docs[row]).unwrap();
+                assert_eq!(doc.get_first(field).unwrap().as_bytes().unwrap(), expected);
+            }
+        }
+    }
+}
+
+#[test]
+fn test_parquet_binary_nested_list_dictionary_and_empty_values() {
+    let array = Arc::new(BinaryArray::from(vec![&[1, 2][..], &[][..]])) as ArrayRef;
+    let field = Arc::new(Field::new("item", array.data_type().clone(), false));
+    let array = Arc::new(FixedSizeListArray::try_new(field, 2, array, None).unwrap());
+    let dictionary =
+        DictionaryArray::<Int32Type>::try_new(Int32Array::from(vec![0]), array).unwrap();
+    let docs = record_batch_to_ndjson_docs(&batch(nested(Arc::new(dictionary)))).unwrap();
+    assert_eq!(
+        serde_json::from_slice::<serde_json::Value>(&docs[0]).unwrap(),
+        json!({"value": {"inner": ["AQI=", ""]}})
+    );
+}
+
+#[test]
+fn test_parquet_rejects_nonfinite_float_widths_and_nested_values() {
+    for value in [f64::NAN, f64::INFINITY, f64::NEG_INFINITY] {
+        let arrays: Vec<ArrayRef> = vec![
+            Arc::new(Float16Array::from(vec![
+                Some(<Float16Type as ArrowPrimitiveType>::Native::from_f64(value)),
+                None,
+            ])),
+            Arc::new(Float32Array::from(vec![Some(value as f32), None])),
+            Arc::new(Float64Array::from(vec![Some(value), None])),
+        ];
+        for array in arrays {
+            let dictionary = Arc::new(
+                DictionaryArray::<Int32Type>::try_new(Int32Array::from(vec![0, 1]), array.clone())
+                    .unwrap(),
+            ) as ArrayRef;
+            let field = Arc::new(Field::new("item", dictionary.data_type().clone(), true));
+            let list =
+                Arc::new(FixedSizeListArray::try_new(field, 2, dictionary.clone(), None).unwrap());
+            for candidate in [array, dictionary, nested(list)] {
+                let error = record_batch_to_ndjson_docs(&batch(candidate.clone())).unwrap_err();
+                let details = format!("{error:#}");
+                assert!(
+                    details.contains("non-finite float"),
+                    "{}: {details}",
+                    candidate.data_type()
+                );
+                assert!(
+                    details.contains("value") || details.contains("inner"),
+                    "{details}"
+                );
+            }
+        }
+        for array in [
+            Arc::new(ListArray::from_iter_primitive::<Float64Type, _, _>([Some(
+                vec![Some(1.0), Some(value)],
+            )])) as ArrayRef,
+            Arc::new(LargeListArray::from_iter_primitive::<Float64Type, _, _>([
+                Some(vec![Some(1.0), Some(value)]),
+            ])),
+        ] {
+            let error = record_batch_to_ndjson_docs(&batch(nested(array))).unwrap_err();
+            assert!(format!("{error:#}").contains("non-finite float"));
+        }
+    }
+}
+
+#[test]
+fn test_parquet_masked_nonfinite_floats_remain_supported() {
+    for value in [f64::NAN, f64::INFINITY, f64::NEG_INFINITY] {
+        let arrays: Vec<ArrayRef> = vec![
+            Arc::new(Float16Array::from(vec![
+                <Float16Type as ArrowPrimitiveType>::Native::from_f64(value),
+                <Float16Type as ArrowPrimitiveType>::Native::from_f32(1.5),
+            ])),
+            Arc::new(Float32Array::from(vec![value as f32, 1.5])),
+            Arc::new(Float64Array::from(vec![value, 1.5])),
+        ];
+        for array in arrays {
+            let field = Arc::new(Field::new("inner", array.data_type().clone(), true));
+            let parent = StructArray::new(
+                vec![field.clone()].into(),
+                vec![array.clone()],
+                Some(vec![false, true].into()),
+            );
+            let docs = record_batch_to_ndjson_docs(&batch(Arc::new(parent))).unwrap();
+            assert_eq!(
+                serde_json::from_slice::<serde_json::Value>(&docs[0]).unwrap(),
+                json!({})
+            );
+            assert_eq!(
+                serde_json::from_slice::<serde_json::Value>(&docs[1]).unwrap(),
+                json!({"value": {"inner": 1.5}})
+            );
+
+            let offsets = ListArray::from_iter_primitive::<Float64Type, _, _>([
+                Some(vec![Some(value)]),
+                Some(vec![Some(1.5)]),
+            ])
+            .offsets()
+            .clone();
+            let list = ListArray::new(
+                field.clone(),
+                offsets,
+                array.clone(),
+                Some(vec![false, true].into()),
+            );
+            let fixed_list =
+                FixedSizeListArray::new(field, 1, array.clone(), Some(vec![false, true].into()));
+            for list in [Arc::new(list) as ArrayRef, Arc::new(fixed_list)] {
+                let docs = record_batch_to_ndjson_docs(&batch(list)).unwrap();
+                assert_eq!(
+                    serde_json::from_slice::<serde_json::Value>(&docs[0]).unwrap(),
+                    json!({})
+                );
+                assert_eq!(
+                    serde_json::from_slice::<serde_json::Value>(&docs[1]).unwrap(),
+                    json!({"value": [1.5]})
+                );
+            }
+
+            let dictionary =
+                DictionaryArray::<Int32Type>::try_new(Int32Array::from(vec![Some(1), None]), array)
+                    .unwrap();
+            let docs = record_batch_to_ndjson_docs(&batch(Arc::new(dictionary))).unwrap();
+            assert_eq!(
+                serde_json::from_slice::<serde_json::Value>(&docs[0]).unwrap(),
+                json!({"value": 1.5})
+            );
+            assert_eq!(
+                serde_json::from_slice::<serde_json::Value>(&docs[1]).unwrap(),
+                json!({})
+            );
+        }
+        let nullable = Arc::new(Float64Array::new(
+            vec![value, 1.5].into(),
+            Some(vec![false, true].into()),
+        ));
+        let docs = record_batch_to_ndjson_docs(&batch(nullable.clone())).unwrap();
+        assert_eq!(
+            serde_json::from_slice::<serde_json::Value>(&docs[0]).unwrap(),
+            json!({})
+        );
+        let dictionary =
+            DictionaryArray::<Int32Type>::try_new(Int32Array::from(vec![0, 1]), nullable).unwrap();
+        let docs = record_batch_to_ndjson_docs(&batch(Arc::new(dictionary))).unwrap();
+        assert_eq!(
+            serde_json::from_slice::<serde_json::Value>(&docs[0]).unwrap(),
+            json!({})
+        );
+        assert_eq!(
+            serde_json::from_slice::<serde_json::Value>(&docs[1]).unwrap(),
+            json!({"value": 1.5})
+        );
+    }
+}
+
+#[test]
+fn test_parquet_dictionary_referenced_value_nulls() {
+    for value in [f64::NAN, f64::INFINITY, f64::NEG_INFINITY] {
+        let floats = Arc::new(Float64Array::from(vec![value, 1.5])) as ArrayRef;
+        let field = Arc::new(Field::new("inner", floats.data_type().clone(), true));
+        let parent = Arc::new(StructArray::new(
+            vec![field.clone()].into(),
+            vec![floats.clone()],
+            Some(vec![false, true].into()),
+        )) as ArrayRef;
+        let list = Arc::new(FixedSizeListArray::new(
+            field,
+            1,
+            floats.clone(),
+            Some(vec![false, true].into()),
+        )) as ArrayRef;
+        macro_rules! check_dictionary_keys {
+            ($($key_type:ident),+) => {$(
+                for (values, expected) in [
+                    (parent.clone(), json!({"value": {"inner": 1.5}})),
+                    (list.clone(), json!({"value": [1.5]})),
+                ] {
+                    let dictionary = DictionaryArray::<arrow_array::types::$key_type>::try_new(
+                        PrimitiveArray::from_iter_values([0, 1]), values,
+                    ).unwrap();
+                    let docs = record_batch_to_ndjson_docs(&batch(Arc::new(dictionary))).unwrap();
+                    assert_eq!(serde_json::from_slice::<serde_json::Value>(&docs[0]).unwrap(), json!({}));
+                    assert_eq!(serde_json::from_slice::<serde_json::Value>(&docs[1]).unwrap(), expected);
+                }
+                let dictionary = DictionaryArray::<arrow_array::types::$key_type>::try_new(
+                    PrimitiveArray::from_iter_values([0, 1]), floats.clone(),
+                ).unwrap();
+                let error = record_batch_to_ndjson_docs(&batch(Arc::new(dictionary))).unwrap_err();
+                assert!(format!("{error:#}").contains("non-finite float"));
+            )+};
+        }
+        check_dictionary_keys!(
+            Int8Type, Int16Type, Int32Type, Int64Type, UInt8Type, UInt16Type, UInt32Type,
+            UInt64Type
+        );
+    }
+}
+
+#[test]
+fn test_parquet_finite_floats_and_nulls_remain_supported() {
+    let arrays: Vec<ArrayRef> = vec![
+        Arc::new(Float16Array::from(vec![
+            Some(<Float16Type as ArrowPrimitiveType>::Native::from_f32(1.5)),
+            None,
+        ])),
+        Arc::new(Float32Array::from(vec![Some(1.5), None])),
+        Arc::new(Float64Array::from(vec![Some(1.5), None])),
+    ];
+    for array in arrays {
+        let docs = record_batch_to_ndjson_docs(&batch(array)).unwrap();
+        assert_eq!(
+            serde_json::from_slice::<serde_json::Value>(&docs[0]).unwrap(),
+            json!({"value": 1.5})
+        );
+        assert_eq!(
+            serde_json::from_slice::<serde_json::Value>(&docs[1]).unwrap(),
+            json!({})
+        );
+    }
+}
diff --git a/quickwit/quickwit-indexing/src/source/parquet_file/mod.rs b/quickwit/quickwit-indexing/src/source/parquet_file/mod.rs
new file mode 100644
index 00000000000..73da6569267
--- /dev/null
+++ b/quickwit/quickwit-indexing/src/source/parquet_file/mod.rs
@@ -0,0 +1,31 @@
+// Copyright 2021-Present Datadog, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Parallel local Parquet source for `quickwit tool local-ingest`.
+//! See `docs/internals/parquet-bulk-load.md`.
+
+mod plan;
+mod source;
+#[cfg(any(test, feature = "testsuite"))]
+mod testsuite;
+
+pub use plan::{DEFAULT_PARQUET_BATCH_NUM_ROWS, ParquetLoadPlan};
+pub use source::{ParquetSource, ParquetSourceFactory};
+#[cfg(any(test, feature = "testsuite"))]
+pub use testsuite::{write_f64_values_as_parquet_file, write_json_docs_as_parquet_file};
+
+#[cfg(test)]
+mod conversion_tests;
+#[cfg(test)]
+mod tests;
diff --git a/quickwit/quickwit-indexing/src/source/parquet_file/plan.rs b/quickwit/quickwit-indexing/src/source/parquet_file/plan.rs
new file mode 100644
index 00000000000..3f4da6a25a3
--- /dev/null
+++ b/quickwit/quickwit-indexing/src/source/parquet_file/plan.rs
@@ -0,0 +1,163 @@
+// Copyright 2021-Present Datadog, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Shared row-group allocation for one local Parquet load.
+//! Groups are claimed once, never checkpointed or retried; pipeline failure aborts the load.
+
+use std::fs::File;
+use std::path::PathBuf;
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+use anyhow::{Context, bail};
+use parquet::arrow::arrow_reader::{
+    ArrowReaderMetadata, ParquetRecordBatchReader, ParquetRecordBatchReaderBuilder,
+};
+use quickwit_common::uri::{Protocol, Uri};
+
+use super::source::record_batch_to_ndjson_docs;
+
+/// Default number of rows decoded per Arrow record batch.
+pub const DEFAULT_PARQUET_BATCH_NUM_ROWS: usize = 8192;
+
+/// Shared file metadata and row-group cursor, injected via
+/// [`ParquetSourceFactory`](super::ParquetSourceFactory).
+pub struct ParquetLoadPlan {
+    file_uri: Uri,
+    filepath: PathBuf,
+    arrow_metadata: ArrowReaderMetadata,
+    batch_num_rows: usize,
+    next_row_group_idx: AtomicUsize,
+}
+
+impl std::fmt::Debug for ParquetLoadPlan {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        f.debug_struct("ParquetLoadPlan")
+            .field("file_uri", &self.file_uri)
+            .field("num_row_groups", &self.num_row_groups())
+            .field("batch_num_rows", &self.batch_num_rows)
+            .finish()
+    }
+}
+
+impl ParquetLoadPlan {
+    /// Reads metadata and checks one row's JSON conversion. Performs blocking I/O.
+    pub fn try_new(file_uri: Uri, batch_num_rows: usize) -> anyhow::Result<Self> {
+        if file_uri.protocol() != Protocol::File {
+            bail!("Parquet input only supports local files, got `{file_uri}`");
+        }
+        if batch_num_rows == 0 {
+            bail!("Parquet batch number of rows must be strictly positive");
+        }
+        let filepath = file_uri
+            .filepath()
+            .context("failed to extract file path from URI")?
+            .to_path_buf();
+        let file = File::open(&filepath)
+            .with_context(|| format!("failed to open file `{}`", filepath.display()))?;
+        let arrow_metadata = ArrowReaderMetadata::load(&file, Default::default())
+            .with_context(|| format!("failed to read Parquet footer of `{file_uri}`"))?;
+        let plan = Self {
+            file_uri,
+            filepath,
+            arrow_metadata,
+            batch_num_rows,
+            next_row_group_idx: AtomicUsize::new(0),
+        };
+        plan.check_json_conversion()?;
+        Ok(plan)
+    }
+
+    /// Checks JSON conversion before spawning pipelines.
+    fn check_json_conversion(&self) -> anyhow::Result<()> {
+        let row_groups = self.arrow_metadata.metadata().row_groups();
+        let Some(row_group_idx) = row_groups
+            .iter()
+            .position(|row_group| row_group.num_rows() > 0)
+        else {
+            return Ok(());
+        };
+        let mut reader = self
+            .row_group_reader_builder(row_group_idx)?
+            .with_limit(1)
+            .build()?;
+        if let Some(record_batch) = reader.next() {
+            record_batch_to_ndjson_docs(&record_batch?)
+                .with_context(|| format!("unsupported Parquet schema in `{}`", self.file_uri))?;
+        }
+        Ok(())
+    }
+
+    fn row_group_reader_builder(
+        &self,
+        row_group_idx: usize,
+    ) -> anyhow::Result<ParquetRecordBatchReaderBuilder<File>> {
+        let file = File::open(&self.filepath)
+            .with_context(|| format!("failed to open file `{}`", self.filepath.display()))?;
+        let builder =
+            ParquetRecordBatchReaderBuilder::new_with_metadata(file, self.arrow_metadata.clone())
+                .with_row_groups(vec![row_group_idx])
+                .with_batch_size(self.batch_num_rows);
+        Ok(builder)
+    }
+
+    /// Claims the next row group, or returns `None` when all groups have been claimed.
+    pub(super) fn next_row_group_reader(
+        &self,
+    ) -> anyhow::Result<Option<(usize, ParquetRecordBatchReader)>> {
+        let row_group_idx = self.next_row_group_idx.fetch_add(1, Ordering::Relaxed);
+        if row_group_idx >= self.num_row_groups() {
+            return Ok(None);
+        }
+        let reader = self
+            .row_group_reader_builder(row_group_idx)?
+            .build()
+            .with_context(|| {
+                format!(
+                    "failed to read row group {row_group_idx} of `{}`",
+                    self.file_uri
+                )
+            })?;
+        Ok(Some((row_group_idx, reader)))
+    }
+
+    pub fn file_uri(&self) -> &Uri {
+        &self.file_uri
+    }
+
+    pub fn num_rows(&self) -> u64 {
+        self.arrow_metadata
+            .metadata()
+            .file_metadata()
+            .num_rows()
+            .max(0) as u64
+    }
+
+    pub fn batch_num_rows(&self) -> usize {
+        self.batch_num_rows
+    }
+
+    pub fn num_row_groups(&self) -> usize {
+        self.arrow_metadata.metadata().num_row_groups()
+    }
+
+    /// Uncompressed size of the file, as reported by the footer.
+    pub fn num_uncompressed_bytes(&self) -> u64 {
+        self.arrow_metadata
+            .metadata()
+            .row_groups()
+            .iter()
+            .map(|row_group| row_group.total_byte_size().max(0) as u64)
+            .sum()
+    }
+}
diff --git a/quickwit/quickwit-indexing/src/source/parquet_file/source.rs b/quickwit/quickwit-indexing/src/source/parquet_file/source.rs
new file mode 100644
index 00000000000..4046a8e4b50
--- /dev/null
+++ b/quickwit/quickwit-indexing/src/source/parquet_file/source.rs
@@ -0,0 +1,336 @@
+// Copyright 2021-Present Datadog, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::fmt;
+use std::io::Write;
+use std::sync::{Arc, LazyLock, OnceLock};
+use std::time::Duration;
+
+use anyhow::{Context, bail};
+use arrow_array::cast::AsArray;
+use arrow_array::types::{ArrowDictionaryKeyType, Float16Type, Float32Type, Float64Type};
+use arrow_array::{Array, ArrayAccessor, DictionaryArray, RecordBatch, downcast_dictionary_array};
+use arrow_json::writer::{
+    Encoder, EncoderFactory, EncoderOptions, LineDelimited, NullableEncoder, WriterBuilder,
+    make_encoder,
+};
+use arrow_schema::{ArrowError, DataType, FieldRef};
+use async_trait::async_trait;
+use base64::display::Base64Display;
+use base64::prelude::BASE64_STANDARD;
+use bytes::Bytes;
+use parquet::arrow::arrow_reader::ParquetRecordBatchReader;
+use quickwit_actors::{ActorExitStatus, Mailbox};
+use quickwit_common::runtimes::RuntimeType;
+use quickwit_config::{FileSourceParams, SourceInputFormat, SourceParams};
+use quickwit_proto::metastore::SourceType;
+use serde_json::json;
+
+use super::plan::ParquetLoadPlan;
+use crate::actors::DocProcessor;
+use crate::source::{
+    BATCH_NUM_BYTES_LIMIT, BatchBuilder, Source, SourceContext, SourceFactory, SourceRuntime,
+};
+
+/// Creates sources sharing one load plan; registered as `file` only in the CLI's loader.
+pub struct ParquetSourceFactory {
+    plan: Arc<ParquetLoadPlan>,
+}
+
+impl ParquetSourceFactory {
+    pub fn new(plan: Arc<ParquetLoadPlan>) -> Self {
+        Self { plan }
+    }
+}
+
+#[async_trait]
+impl SourceFactory for ParquetSourceFactory {
+    async fn create_source(
+        &self,
+        source_runtime: SourceRuntime,
+    ) -> anyhow::Result<Box<dyn Source>> {
+        let file_uri = match &source_runtime.source_config.source_params {
+            SourceParams::File(FileSourceParams::Filepath(file_uri)) => file_uri,
+            SourceParams::File(_) => {
+                bail!("a Parquet load reads a file path, not file notifications");
+            }
+            _ => bail!("a Parquet load requires a file source"),
+        };
+        if file_uri != self.plan.file_uri() {
+            bail!(
+                "the Parquet load plan reads `{}`, not `{file_uri}`",
+                self.plan.file_uri()
+            );
+        }
+        let input_format = source_runtime.source_config.input_format;
+        if input_format != SourceInputFormat::Json {
+            bail!("Parquet files require the `json` input format, got `{input_format:?}`");
+        }
+        Ok(Box::new(ParquetSource {
+            plan: self.plan.clone(),
+            current_opt: None,
+            num_rows_emitted: 0,
+            num_bytes_emitted: 0,
+        }))
+    }
+}
+
+/// Emits row groups from a shared [`ParquetLoadPlan`] as JSON documents.
+/// Checkpoints are empty: restarts lose claimed groups, so the CLI must abort the load.
+pub struct ParquetSource {
+    plan: Arc<ParquetLoadPlan>,
+    /// Current row group, taken while the blocking task owns the reader.
+    current_opt: Option<(usize, ParquetRecordBatchReader)>,
+    num_rows_emitted: u64,
+    num_bytes_emitted: u64,
+}
+
+impl fmt::Debug for ParquetSource {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            formatter,
+            "ParquetSource {{ file_uri: {} }}",
+            self.plan.file_uri()
+        )
+    }
+}
+
+#[async_trait]
+impl Source for ParquetSource {
+    async fn emit_batches(
+        &mut self,
+        doc_processor_mailbox: &Mailbox<DocProcessor>,
+        ctx: &SourceContext,
+    ) -> Result<Duration, ActorExitStatus> {
+        let next_batch = ctx
+            .protect_future(decode_next_batch(
+                self.plan.clone(),
+                self.current_opt.take(),
+            ))
+            .await?;
+        let Some((row_group_idx, reader, docs)) = next_batch else {
+            ctx.send_exit_with_success(doc_processor_mailbox).await?;
+            return Err(ActorExitStatus::Success);
+        };
+        self.current_opt = Some((row_group_idx, reader));
+
+        // Split between documents; a single document may exceed the byte limit.
+        let mut batch_builder = BatchBuilder::new(SourceType::File);
+        let num_docs = docs.len();
+        for (doc_idx, doc) in docs.into_iter().enumerate() {
+            batch_builder.add_doc(doc);
+            let is_last_doc = doc_idx + 1 == num_docs;
+            if !is_last_doc && batch_builder.num_bytes < BATCH_NUM_BYTES_LIMIT {
+                continue;
+            }
+            self.num_rows_emitted += batch_builder.docs.len() as u64;
+            self.num_bytes_emitted += batch_builder.num_bytes;
+            let raw_doc_batch =
+                std::mem::replace(&mut batch_builder, BatchBuilder::new(SourceType::File)).build();
+            ctx.send_message(doc_processor_mailbox, raw_doc_batch)
+                .await?;
+        }
+        Ok(Duration::ZERO)
+    }
+
+    fn name(&self) -> String {
+        format!("{self:?}")
+    }
+
+    fn observable_state(&self) -> serde_json::Value {
+        json!({
+            "num_rows_emitted": self.num_rows_emitted,
+            "num_bytes_emitted": self.num_bytes_emitted,
+        })
+    }
+}
+
+/// Acquires readers, decodes and JSON-encodes on the blocking runtime.
+/// Advances past exhausted row groups; `None` marks EOF.
+pub(super) async fn decode_next_batch(
+    plan: Arc<ParquetLoadPlan>,
+    mut current_opt: Option<(usize, ParquetRecordBatchReader)>,
+) -> anyhow::Result<Option<(usize, ParquetRecordBatchReader, Vec<Bytes>)>> {
+    let join_handle = RuntimeType::Blocking
+        .get_runtime_handle()
+        .spawn(async move {
+            loop {
+                let current = match current_opt.take() {
+                    Some(current) => Some(current),
+                    None => plan.next_row_group_reader()?,
+                };
+                let Some((row_group_idx, mut reader)) = current else {
+                    return Ok(None);
+                };
+                let docs_res = match reader.next() {
+                    Some(Ok(record_batch)) => record_batch_to_ndjson_docs(&record_batch),
+                    Some(Err(error)) => Err(anyhow::Error::from(error)),
+                    None => continue,
+                };
+                let docs = docs_res.with_context(|| {
+                    format!(
+                        "failed to decode row group {row_group_idx} of `{}`",
+                        plan.file_uri()
+                    )
+                })?;
+                return Ok(Some((row_group_idx, reader, docs)));
+            }
+        });
+    join_handle
+        .await
+        .context("Parquet decoding task panicked or was cancelled")?
+}
+
+/// Treat naive timestamps as UTC for RFC 3339 parsing; zoned timestamps keep their offset.
+const NAIVE_TIMESTAMP_FORMAT: &str = "%Y-%m-%dT%H:%M:%S%.fZ";
+
+struct Base64Encoder<B>(B);
+
+impl<'a, B: ArrayAccessor<Item = &'a [u8]>> Encoder for Base64Encoder<B> {
+    fn encode(&mut self, idx: usize, out: &mut Vec<u8>) {
+        write!(
+            out,
+            "\"{}\"",
+            Base64Display::new(self.0.value(idx), &BASE64_STANDARD)
+        )
+        .expect("writing to a Vec cannot fail");
+    }
+}
+
+struct ParquetDictionaryEncoder<'a, K: ArrowDictionaryKeyType> {
+    array: &'a DictionaryArray<K>,
+    values: NullableEncoder<'a>,
+}
+
+impl<K: ArrowDictionaryKeyType> Encoder for ParquetDictionaryEncoder<'_, K> {
+    fn encode(&mut self, idx: usize, out: &mut Vec<u8>) {
+        let key = self.array.key(idx).expect("null keys are not encoded");
+        // A valid key can reference a null value, including a struct/list with masked children.
+        if self.values.is_null(key) {
+            out.extend_from_slice(b"null");
+        } else {
+            self.values.encode(key, out);
+        }
+    }
+}
+
+struct CheckedFloatEncoder<'a, F> {
+    inner: NullableEncoder<'a>,
+    is_finite: F,
+    field_name: &'a str,
+    invalid_field: Arc<OnceLock<String>>,
+}
+
+impl<F: Fn(usize) -> bool> Encoder for CheckedFloatEncoder<'_, F> {
+    fn encode(&mut self, idx: usize, out: &mut Vec<u8>) {
+        // Encoder cannot return errors; reject the batch without checking masked/unused values.
+        if !(self.is_finite)(idx) {
+            let _ = self.invalid_field.set(self.field_name.to_string());
+        }
+        self.inner.encode(idx, out);
+    }
+}
+
+#[derive(Debug, Default)]
+struct ParquetEncoderFactory {
+    invalid_field: Arc<OnceLock<String>>,
+}
+
+// Primitive float formatting does not use the writer's timestamp/null options or custom factory.
+static FLOAT_ENCODER_OPTIONS: LazyLock<EncoderOptions> = LazyLock::new(EncoderOptions::default);
+
+impl EncoderFactory for ParquetEncoderFactory {
+    fn make_default_encoder<'a>(
+        &self,
+        field: &'a FieldRef,
+        array: &'a dyn Array,
+        options: &'a EncoderOptions,
+    ) -> Result<Option<NullableEncoder<'a>>, ArrowError> {
+        // Arrow invokes this hook recursively, including for dictionary values and list children.
+        macro_rules! float_encoder {
+            ($float_type:ty) => {{
+                let array = array.as_primitive::<$float_type>();
+                Box::new(CheckedFloatEncoder {
+                    inner: make_encoder(field, array, &FLOAT_ENCODER_OPTIONS)?,
+                    is_finite: move |idx| array.value(idx).is_finite(),
+                    field_name: field.name(),
+                    invalid_field: self.invalid_field.clone(),
+                })
+            }};
+        }
+        let encoder: Box<dyn Encoder> = match array.data_type() {
+            DataType::Binary => Box::new(Base64Encoder(array.as_binary::<i32>())),
+            DataType::LargeBinary => Box::new(Base64Encoder(array.as_binary::<i64>())),
+            DataType::BinaryView => Box::new(Base64Encoder(array.as_binary_view())),
+            DataType::FixedSizeBinary(_) => Box::new(Base64Encoder(array.as_fixed_size_binary())),
+            DataType::Dictionary(_, _) => downcast_dictionary_array! {
+                array => Box::new(ParquetDictionaryEncoder {
+                    array,
+                    values: make_encoder(field, array.values().as_ref(), options)?,
+                }),
+                _ => unreachable!("Arrow dictionary keys must be integers"),
+            },
+            DataType::Float16 => float_encoder!(Float16Type),
+            DataType::Float32 => float_encoder!(Float32Type),
+            DataType::Float64 => float_encoder!(Float64Type),
+            _ => return Ok(None),
+        };
+        Ok(Some(NullableEncoder::new(encoder, array.logical_nulls())))
+    }
+}
+
+/// Encodes one JSON document per row; returned slices share a single buffer.
+pub(super) fn record_batch_to_ndjson_docs(
+    record_batch: &RecordBatch,
+) -> anyhow::Result<Vec<Bytes>> {
+    let num_rows = record_batch.num_rows();
+    let encoder_factory = Arc::new(ParquetEncoderFactory::default());
+    let mut writer = WriterBuilder::new()
+        .with_explicit_nulls(false)
+        .with_timestamp_format(NAIVE_TIMESTAMP_FORMAT.to_string())
+        .with_encoder_factory(encoder_factory.clone())
+        .build::<_, LineDelimited>(Vec::new());
+    writer
+        .write(record_batch)
+        .context("failed to encode Parquet rows as JSON")?;
+    if let Some(field_name) = encoder_factory.invalid_field.get() {
+        bail!("non-finite float in Parquet field `{field_name}` cannot be represented as JSON");
+    }
+    writer
+        .finish()
+        .context("failed to encode Parquet rows as JSON")?;
+    let buffer = Bytes::from(writer.into_inner());
+
+    // arrow-json escapes string newlines, so every raw newline separates documents.
+    let mut docs = Vec::with_capacity(num_rows);
+    let mut line_start = 0;
+    for (newline_pos, _) in buffer
+        .iter()
+        .enumerate()
+        .filter(|(_, byte)| **byte == b'\n')
+    {
+        docs.push(buffer.slice(line_start..newline_pos));
+        line_start = newline_pos + 1;
+    }
+    if line_start != buffer.len() {
+        anyhow::bail!("JSON encoding of Parquet rows is missing a trailing newline");
+    }
+    if docs.len() != num_rows {
+        anyhow::bail!(
+            "JSON encoding of {num_rows} Parquet rows produced {} lines",
+            docs.len()
+        );
+    }
+    Ok(docs)
+}
diff --git a/quickwit/quickwit-indexing/src/source/parquet_file/tests.rs b/quickwit/quickwit-indexing/src/source/parquet_file/tests.rs
new file mode 100644
index 00000000000..bd1c819e829
--- /dev/null
+++ b/quickwit/quickwit-indexing/src/source/parquet_file/tests.rs
@@ -0,0 +1,351 @@
+// Copyright 2021-Present Datadog, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::num::NonZeroUsize;
+use std::path::Path;
+use std::str::FromStr;
+use std::sync::Arc;
+
+use arrow_array::{
+    ArrayRef, BooleanArray, Int64Array, RecordBatch, StringArray, StructArray,
+    TimestampMillisecondArray,
+};
+use arrow_schema::{DataType, Field, Fields, Schema, TimeUnit};
+use quickwit_actors::{Command, Universe};
+use quickwit_common::uri::Uri;
+use quickwit_config::{FileSourceParams, SourceConfig, SourceInputFormat, SourceParams};
+use quickwit_proto::types::IndexUid;
+use serde_json::json;
+
+use super::source::record_batch_to_ndjson_docs;
+use super::*;
+use crate::actors::DocProcessor;
+use crate::models::RawDocBatch;
+use crate::source::tests::SourceRuntimeBuilder;
+use crate::source::{SourceActor, SourceFactory};
+
+const SOURCE_ID: &str = "test-parquet-source";
+
+/// Writes `num_rows` rows `{"id": i, "message": "message-{i}"}` in row groups of
+/// `row_group_num_rows` rows.
+fn write_parquet_file(path: &Path, num_rows: usize, row_group_num_rows: usize) -> Uri {
+    let json_docs: Vec<serde_json::Value> = (0..num_rows)
+        .map(|id| json!({"id": id, "message": format!("message-{id}")}))
+        .collect();
+    write_json_docs_as_parquet_file(path, &json_docs, row_group_num_rows).unwrap();
+    Uri::from_str(path.to_str().unwrap()).unwrap()
+}
+
+fn parquet_source_runtime(
+    index_uid: IndexUid,
+    file_uri: &Uri,
+    input_format: SourceInputFormat,
+) -> crate::source::SourceRuntime {
+    let source_config = SourceConfig {
+        source_id: SOURCE_ID.to_string(),
+        num_pipelines: NonZeroUsize::MIN,
+        enabled: true,
+        source_params: SourceParams::File(FileSourceParams::Filepath(file_uri.clone())),
+        transform_config: None,
+        input_format,
+    };
+    SourceRuntimeBuilder::new(index_uid, source_config)
+        .with_mock_metastore(None)
+        .build()
+}
+
+/// Creates a source reading `source_file_uri` from a plan reading `plan_file_uri`.
+async fn create_parquet_source(
+    plan_file_uri: &Uri,
+    source_file_uri: &Uri,
+    input_format: SourceInputFormat,
+) -> anyhow::Result<Box<dyn crate::source::Source>> {
+    let plan = Arc::new(ParquetLoadPlan::try_new(plan_file_uri.clone(), 3).unwrap());
+    let index_uid = IndexUid::new_with_random_ulid("test-index");
+    let source_runtime = parquet_source_runtime(index_uid, source_file_uri, input_format);
+    ParquetSourceFactory::new(plan)
+        .create_source(source_runtime)
+        .await
+}
+
+#[tokio::test]
+async fn test_parquet_source() {
+    let temp_dir = tempfile::tempdir().unwrap();
+    let file_uri = write_parquet_file(&temp_dir.path().join("test.parquet"), 10, 4);
+    let index_uid = IndexUid::new_with_random_ulid("test-index");
+
+    let plan = ParquetLoadPlan::try_new(file_uri.clone(), 3).unwrap();
+    assert_eq!(plan.num_rows(), 10);
+    assert_eq!(plan.num_row_groups(), 3);
+
+    let universe = Universe::with_accelerated_time();
+    let (doc_processor_mailbox, doc_processor_inbox) =
+        universe.create_test_mailbox::<DocProcessor>();
+    let source_runtime = parquet_source_runtime(index_uid, &file_uri, SourceInputFormat::Json);
+    let parquet_source = ParquetSourceFactory::new(Arc::new(plan))
+        .create_source(source_runtime)
+        .await
+        .unwrap();
+    let source_actor = SourceActor::new(parquet_source, doc_processor_mailbox);
+    let (_source_mailbox, source_handle) = universe.spawn_builder().spawn(source_actor);
+    let (exit_status, observable_state) = source_handle.join().await;
+    assert!(exit_status.is_success());
+    assert_eq!(observable_state["num_rows_emitted"], 10);
+
+    let messages = doc_processor_inbox.drain_for_test();
+    assert!(matches!(
+        messages.last().unwrap().downcast_ref::<Command>().unwrap(),
+        Command::ExitWithSuccess
+    ));
+    let raw_doc_batches: Vec<&RawDocBatch> = messages
+        .iter()
+        .filter_map(|message| message.downcast_ref::<RawDocBatch>())
+        .collect();
+    // Row groups of 4, 4 and 2 rows, read in batches of 3 rows.
+    assert_eq!(
+        raw_doc_batches
+            .iter()
+            .map(|batch| batch.docs.len())
+            .collect::<Vec<_>>(),
+        [3, 1, 3, 1, 2]
+    );
+    assert!(
+        raw_doc_batches
+            .iter()
+            .all(|raw_doc_batch| raw_doc_batch.checkpoint_delta.is_empty())
+    );
+    let ids: Vec<u64> = raw_doc_batches
+        .iter()
+        .flat_map(|raw_doc_batch| raw_doc_batch.docs.iter())
+        .map(|doc| {
+            let json_doc: serde_json::Value = serde_json::from_slice(doc).unwrap();
+            json_doc["id"].as_u64().unwrap()
+        })
+        .collect();
+    assert_eq!(ids, (0..10).collect::<Vec<u64>>());
+}
+
+#[tokio::test]
+async fn test_parquet_source_rejects_nonfinite_floats_in_later_batches() {
+    for value in [f64::NAN, f64::INFINITY, f64::NEG_INFINITY] {
+        let temp_dir = tempfile::tempdir().unwrap();
+        let path = temp_dir.path().join("nonfinite.parquet");
+        write_f64_values_as_parquet_file(&path, &[1.0, 2.0, value], 3).unwrap();
+        let file_uri = Uri::from_str(path.to_str().unwrap()).unwrap();
+        let plan = Arc::new(ParquetLoadPlan::try_new(file_uri.clone(), 1).unwrap());
+        let source_runtime = parquet_source_runtime(
+            IndexUid::new_with_random_ulid("test-index"),
+            &file_uri,
+            SourceInputFormat::Json,
+        );
+        let source = ParquetSourceFactory::new(plan)
+            .create_source(source_runtime)
+            .await
+            .unwrap();
+        let universe = Universe::with_accelerated_time();
+        let (mailbox, inbox) = universe.create_test_mailbox::<DocProcessor>();
+        let (_, handle) = universe
+            .spawn_builder()
+            .spawn(SourceActor::new(source, mailbox));
+        let (exit_status, state) = handle.join().await;
+        assert!(!exit_status.is_success());
+        let details = format!("{exit_status:?}");
+        assert!(details.contains("non-finite float"), "{details}");
+        assert!(details.contains("row group 0"), "{details}");
+        assert_eq!(state["num_rows_emitted"], 2);
+        let messages = inbox.drain_for_test();
+        let batches: Vec<_> = messages
+            .iter()
+            .filter_map(|message| message.downcast_ref::<RawDocBatch>())
+            .collect();
+        assert_eq!(batches.len(), 2);
+        for (batch, value) in batches.iter().zip([1.0, 2.0]) {
+            assert_eq!(
+                serde_json::from_slice::<serde_json::Value>(&batch.docs[0]).unwrap(),
+                json!({"value": value})
+            );
+        }
+        assert!(
+            !messages
+                .iter()
+                .any(|message| message.downcast_ref::<Command>().is_some())
+        );
+    }
+}
+
+#[tokio::test]
+async fn test_parquet_reader_acquisition_runs_on_blocking_runtime() {
+    use quickwit_common::runtimes::RuntimeType;
+
+    let temp_dir = tempfile::tempdir().unwrap();
+    let path = temp_dir.path().join("test.parquet");
+    for exhaust_first_group in [false, true] {
+        let file_uri = write_parquet_file(&path, 6, 3);
+        let plan = Arc::new(ParquetLoadPlan::try_new(file_uri, 3).unwrap());
+        let current_opt = if exhaust_first_group {
+            let (row_group_idx, mut reader) = plan.next_row_group_reader().unwrap().unwrap();
+            assert_eq!(reader.next().unwrap().unwrap().num_rows(), 3);
+            assert!(reader.next().is_none());
+            Some((row_group_idx, reader))
+        } else {
+            None
+        };
+        let (started_tx, started_rx) = tokio::sync::oneshot::channel();
+        let (release_tx, release_rx) = std::sync::mpsc::channel();
+        // The test runtime has one blocking worker. Hold it before polling the decode future.
+        let blocker = RuntimeType::Blocking
+            .get_runtime_handle()
+            .spawn(async move {
+                started_tx.send(()).unwrap();
+                let _ = release_rx.recv();
+            });
+        started_rx.await.unwrap();
+        let decode = super::source::decode_next_batch(plan, current_opt);
+        tokio::pin!(decode);
+        assert!(futures::poll!(&mut decode).is_pending());
+        // An async-thread acquisition would already have opened the now-unlinked file.
+        std::fs::remove_file(&path).unwrap();
+        release_tx.send(()).unwrap();
+        blocker.await.unwrap();
+        let Err(error) = decode.await else {
+            panic!("reader must be acquired after dispatch");
+        };
+        assert!(format!("{error:#}").contains("failed to open file"));
+    }
+}
+
+#[tokio::test]
+async fn test_parquet_decode_empty_file() {
+    let temp_dir = tempfile::tempdir().unwrap();
+    let path = temp_dir.path().join("empty.parquet");
+    write_f64_values_as_parquet_file(&path, &[], 3).unwrap();
+    let file_uri = Uri::from_str(path.to_str().unwrap()).unwrap();
+    let plan = Arc::new(ParquetLoadPlan::try_new(file_uri, 3).unwrap());
+    assert_eq!(plan.num_row_groups(), 0);
+    assert!(
+        super::source::decode_next_batch(plan, None)
+            .await
+            .unwrap()
+            .is_none()
+    );
+}
+
+#[tokio::test]
+async fn test_parquet_source_requires_a_file_path_source() {
+    let temp_dir = tempfile::tempdir().unwrap();
+    let file_uri = write_parquet_file(&temp_dir.path().join("test.parquet"), 3, 2);
+    let plan = Arc::new(ParquetLoadPlan::try_new(file_uri.clone(), 3).unwrap());
+    let notifications = serde_json::from_value(json!({
+        "notifications": [{
+            "type": "sqs", "queue_url": "http://localhost/queue", "message_type": "raw_uri"
+        }]
+    }))
+    .unwrap();
+    for (source_params, expected_error) in [
+        (SourceParams::void(), "requires a file source"),
+        (SourceParams::File(notifications), "not file notifications"),
+    ] {
+        let mut source_runtime = parquet_source_runtime(
+            IndexUid::new_with_random_ulid("test-index"),
+            &file_uri,
+            SourceInputFormat::Json,
+        );
+        source_runtime.source_config.source_params = source_params;
+        let error = ParquetSourceFactory::new(plan.clone())
+            .create_source(source_runtime)
+            .await
+            .err()
+            .unwrap();
+        assert!(error.to_string().contains(expected_error), "{error:#}");
+    }
+}
+
+#[tokio::test]
+async fn test_parquet_source_requires_the_plan_file() {
+    let temp_dir = tempfile::tempdir().unwrap();
+    let plan_file_uri = write_parquet_file(&temp_dir.path().join("plan.parquet"), 3, 2);
+    let other_file_uri = write_parquet_file(&temp_dir.path().join("other.parquet"), 3, 2);
+    let error = create_parquet_source(&plan_file_uri, &other_file_uri, SourceInputFormat::Json)
+        .await
+        .err()
+        .unwrap();
+    assert!(error.to_string().contains("the Parquet load plan reads"));
+}
+
+#[tokio::test]
+async fn test_parquet_source_requires_the_json_input_format() {
+    let temp_dir = tempfile::tempdir().unwrap();
+    let file_uri = write_parquet_file(&temp_dir.path().join("test.parquet"), 3, 2);
+    let error = create_parquet_source(&file_uri, &file_uri, SourceInputFormat::PlainText)
+        .await
+        .err()
+        .unwrap();
+    assert!(
+        error
+            .to_string()
+            .contains("require the `json` input format")
+    );
+}
+
+#[test]
+fn test_parquet_load_plan_rejects_remote_files() {
+    let file_uri = Uri::for_test("s3://bucket/test.parquet");
+    let error = ParquetLoadPlan::try_new(file_uri, 10).unwrap_err();
+    assert!(error.to_string().contains("only supports local files"));
+}
+
+#[test]
+fn test_record_batch_to_ndjson_docs() {
+    let inner_fields = Fields::from(vec![Field::new("flag", DataType::Boolean, true)]);
+    let schema = Arc::new(Schema::new(vec![
+        Field::new("id", DataType::Int64, false),
+        Field::new("message", DataType::Utf8, true),
+        Field::new("ts", DataType::Timestamp(TimeUnit::Millisecond, None), true),
+        Field::new(
+            "ts_utc",
+            DataType::Timestamp(TimeUnit::Millisecond, Some("UTC".into())),
+            true,
+        ),
+        Field::new("nested", DataType::Struct(inner_fields.clone()), true),
+    ]));
+    let nested = StructArray::new(
+        inner_fields,
+        vec![Arc::new(BooleanArray::from(vec![Some(true), None])) as ArrayRef],
+        None,
+    );
+    let columns: Vec<ArrayRef> = vec![
+        Arc::new(Int64Array::from(vec![1, 2])),
+        Arc::new(StringArray::from(vec![Some("hello\nworld"), None])),
+        Arc::new(TimestampMillisecondArray::from(vec![Some(1_000), None])),
+        Arc::new(TimestampMillisecondArray::from(vec![Some(1_000), None]).with_timezone("UTC")),
+        Arc::new(nested),
+    ];
+    let record_batch = RecordBatch::try_new(schema, columns).unwrap();
+    let docs = record_batch_to_ndjson_docs(&record_batch).unwrap();
+    assert_eq!(docs.len(), 2);
+
+    let doc_0: serde_json::Value = serde_json::from_slice(&docs[0]).unwrap();
+    assert_eq!(
+        doc_0,
+        serde_json::json!({
+            "id": 1,
+            "message": "hello\nworld",
+            "ts": "1970-01-01T00:00:01Z",
+            "ts_utc": "1970-01-01T00:00:01Z",
+            "nested": {"flag": true},
+        })
+    );
+    let doc_1: serde_json::Value = serde_json::from_slice(&docs[1]).unwrap();
+    assert_eq!(doc_1, serde_json::json!({"id": 2, "nested": {}}));
+}
diff --git a/quickwit/quickwit-indexing/src/source/parquet_file/testsuite.rs b/quickwit/quickwit-indexing/src/source/parquet_file/testsuite.rs
new file mode 100644
index 00000000000..9a6dd209433
--- /dev/null
+++ b/quickwit/quickwit-indexing/src/source/parquet_file/testsuite.rs
@@ -0,0 +1,68 @@
+// Copyright 2021-Present Datadog, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::path::Path;
+use std::sync::Arc;
+
+use arrow_array::{ArrayRef, Float64Array, RecordBatch};
+use arrow_json::ReaderBuilder;
+use arrow_json::reader::infer_json_schema_from_iterator;
+use parquet::arrow::ArrowWriter;
+use parquet::file::properties::WriterProperties;
+use serde_json::Value as JsonValue;
+
+/// Writes JSON as Parquet with an inferred schema and at most `row_group_num_rows` per group.
+pub fn write_json_docs_as_parquet_file(
+    path: &Path,
+    json_docs: &[JsonValue],
+    row_group_num_rows: usize,
+) -> anyhow::Result<()> {
+    let schema = Arc::new(infer_json_schema_from_iterator(
+        json_docs.iter().map(Ok::<_, arrow_schema::ArrowError>),
+    )?);
+    let mut decoder = ReaderBuilder::new(schema.clone())
+        .with_batch_size(json_docs.len().max(1))
+        .build_decoder()?;
+    decoder.serialize(json_docs)?;
+    let record_batch = decoder
+        .flush()?
+        .unwrap_or_else(|| RecordBatch::new_empty(schema));
+    write_record_batch_as_parquet_file(path, &record_batch, row_group_num_rows)
+}
+
+/// Writes native float values, including values that JSON cannot represent, in a `value` column.
+pub fn write_f64_values_as_parquet_file(
+    path: &Path,
+    values: &[f64],
+    row_group_num_rows: usize,
+) -> anyhow::Result<()> {
+    let array = Arc::new(Float64Array::from(values.to_vec())) as ArrayRef;
+    let record_batch = RecordBatch::try_from_iter([("value", array)])?;
+    write_record_batch_as_parquet_file(path, &record_batch, row_group_num_rows)
+}
+
+pub(super) fn write_record_batch_as_parquet_file(
+    path: &Path,
+    record_batch: &RecordBatch,
+    row_group_num_rows: usize,
+) -> anyhow::Result<()> {
+    let properties = WriterProperties::builder()
+        .set_max_row_group_row_count(Some(row_group_num_rows))
+        .build();
+    let file = std::fs::File::create(path)?;
+    let mut writer = ArrowWriter::try_new(file, record_batch.schema(), Some(properties))?;
+    writer.write(record_batch)?;
+    writer.close()?;
+    Ok(())
+}
diff --git a/quickwit/quickwit-integration-tests/src/test_utils/cluster_sandbox.rs b/quickwit/quickwit-integration-tests/src/test_utils/cluster_sandbox.rs
index 7b4980f428d..e72cf3a58ef 100644
--- a/quickwit/quickwit-integration-tests/src/test_utils/cluster_sandbox.rs
+++ b/quickwit/quickwit-integration-tests/src/test_utils/cluster_sandbox.rs
@@ -15,6 +15,7 @@
 use std::collections::{HashMap, HashSet};
 use std::io::Write;
 use std::net::SocketAddr;
+use std::num::NonZeroUsize;
 use std::str::FromStr;
 use std::time::Duration;
 
@@ -638,6 +639,8 @@ impl ClusterSandbox {
                     .to_str()
                     .context("temp path could not be converted to URI")?,
             )?),
+            num_pipelines: NonZeroUsize::MIN,
+            batch_num_rows_opt: None,
         })
         .await?;
         Ok(())