diff --git a/parquet-hadoop/src/main/java/org/apache/parquet/hadoop/util/HadoopInputFile.java b/parquet-hadoop/src/main/java/org/apache/parquet/hadoop/util/HadoopInputFile.java
index fa6a7bdf42..adae5383e4 100644
--- a/parquet-hadoop/src/main/java/org/apache/parquet/hadoop/util/HadoopInputFile.java
+++ b/parquet-hadoop/src/main/java/org/apache/parquet/hadoop/util/HadoopInputFile.java
@@ -28,6 +28,7 @@
 import org.apache.hadoop.fs.FSDataInputStream;
 import org.apache.hadoop.fs.FileStatus;
 import org.apache.hadoop.fs.FileSystem;
+import org.apache.hadoop.fs.FutureDataInputStreamBuilder;
 import org.apache.hadoop.fs.Path;
 import org.apache.parquet.io.InputFile;
 import org.apache.parquet.io.SeekableInputStream;
@@ -39,6 +40,14 @@ public class HadoopInputFile implements InputFile {
    */
   private static final String OPENFILE_READ_POLICY_KEY = "fs.option.openfile.read.policy";
 
+  /**
+   * openFile() option name for passing a known file length: {@value}.
+   *
+   * <p>This is an optional filesystem hint, so retain the string form to support Hadoop versions before the
+   * constant was introduced.
+   */
+  private static final String OPENFILE_LENGTH_KEY = "fs.option.openfile.length";
+
   /**
    * Read policy when opening parquet files: {@value}.
    * <p>Policy-aware stores pick the first policy they recognize in the list.
@@ -53,6 +62,8 @@ public class HadoopInputFile implements InputFile {
   private static final String PARQUET_READ_POLICY = "parquet, vector, random, adaptive";
 
   private final FileSystem fs;
+  private final Path path;
+  private final long length;
   private final FileStatus stat;
   private final Configuration conf;
 
@@ -61,6 +72,32 @@ public static HadoopInputFile fromPath(Path path, Configuration conf) throws IOE
     return new HadoopInputFile(fs, fs.getFileStatus(path), conf);
   }
 
+  /**
+   * Creates an input file using a caller-supplied file length.
+   *
+   * <p>The length is trusted and no file status lookup is performed. Callers must provide the exact
+   * length of the file that will be opened. The file system may defer checking whether the file
+   * exists until the first read. If the supplied length is incorrect, reads may fail.
+   *
+   * <p>When a {@link FileStatus} is available, prefer {@link #fromStatus(FileStatus, Configuration)}.
+   * A length alone does not preserve file-system-specific identity metadata used when opening a file
+   * (for example, S3A ETags and version IDs), so initial-open change detection may be weaker.
+   *
+   * @param path file path
+   * @param length exact file length in bytes
+   * @param conf configuration used to resolve the file system
+   * @return an input file that uses the supplied length
+   * @throws IllegalArgumentException if {@code length} is negative
+   * @throws IOException if the file system cannot be resolved
+   */
+  public static HadoopInputFile fromPath(Path path, long length, Configuration conf) throws IOException {
+    if (length < 0) {
+      throw new IllegalArgumentException("Invalid file length: " + length);
+    }
+    FileSystem fs = path.getFileSystem(conf);
+    return new HadoopInputFile(fs, path, length, conf);
+  }
+
   public static HadoopInputFile fromPathUnchecked(Path path, Configuration conf) {
     try {
       return fromPath(path, conf);
@@ -76,28 +113,38 @@ public static HadoopInputFile fromStatus(FileStatus stat, Configuration conf) th
 
   private HadoopInputFile(FileSystem fs, FileStatus stat, Configuration conf) {
     this.fs = fs;
+    this.path = stat.getPath();
+    this.length = stat.getLen();
     this.stat = stat;
     this.conf = conf;
   }
 
+  private HadoopInputFile(FileSystem fs, Path path, long length, Configuration conf) {
+    this.fs = fs;
+    this.path = path;
+    this.length = length;
+    this.stat = null;
+    this.conf = conf;
+  }
+
   public Configuration getConfiguration() {
     return conf;
   }
 
   public Path getPath() {
-    return stat.getPath();
+    return path;
   }
 
   @Override
   public long getLength() {
-    return stat.getLen();
+    return length;
   }
 
   /**
    * Open the file.
-   * <p>Uses {@code FileSystem.openFile()} so that
-   * the existing FileStatus can be passed down: saves a HEAD request on cloud storage.
-   * and ignored everywhere else.
+   * <p>Uses {@code FileSystem.openFile()} so that the existing FileStatus, when available, or the
+   * known file length can be passed down. File systems may use either to avoid a metadata request
+   * when opening the file.
    *
    * @return the input stream.
    *
@@ -109,20 +156,24 @@ public long getLength() {
   public SeekableInputStream newStream() throws IOException {
     FSDataInputStream stream;
     try {
-      // this method is async so that implementations may do async HEAD head
+      // this method is async so that implementations may do async HEAD
       // requests, such as S3A/ABFS when a file status is passed down.
-      final CompletableFuture<FSDataInputStream> future = fs.openFile(stat.getPath())
-          .withFileStatus(stat)
-          .opt(OPENFILE_READ_POLICY_KEY, PARQUET_READ_POLICY)
-          .build();
+      FutureDataInputStreamBuilder builder = fs.openFile(path).opt(OPENFILE_READ_POLICY_KEY, PARQUET_READ_POLICY);
+      if (stat != null) {
+        builder.withFileStatus(stat);
+      } else {
+        builder.opt(OPENFILE_LENGTH_KEY, Long.toString(length));
+      }
+      final CompletableFuture<FSDataInputStream> future = builder.build();
       stream = awaitFuture(future);
     } catch (RuntimeException e) {
       // S3A < 3.3.5 would raise illegal path exception if the openFile path didn't
       // equal the path in the FileStatus; Hive virtual FS could create this condition.
-      // As the path to open is derived from stat.getPath(), this condition seems
-      // near-impossible to create -but is handled here for due diligence.
+      // When a status is supplied, the path to open is derived from stat.getPath(),
+      // so this condition seems near-impossible to create -but is handled here
+      // for due diligence.
       try {
-        stream = fs.open(stat.getPath());
+        stream = fs.open(path);
       } catch (IOException | RuntimeException ex) {
         // failure on this attempt attaches the failure of the openFile() call
         // so the stack trace is preserved.
@@ -136,6 +187,6 @@ public SeekableInputStream newStream() throws IOException {
 
   @Override
   public String toString() {
-    return stat.getPath().toString();
+    return path.toString();
   }
 }
diff --git a/parquet-hadoop/src/test/java/org/apache/parquet/hadoop/util/TestHadoopOpenFile.java b/parquet-hadoop/src/test/java/org/apache/parquet/hadoop/util/TestHadoopOpenFile.java
index b6476ccca0..937dae9633 100644
--- a/parquet-hadoop/src/test/java/org/apache/parquet/hadoop/util/TestHadoopOpenFile.java
+++ b/parquet-hadoop/src/test/java/org/apache/parquet/hadoop/util/TestHadoopOpenFile.java
@@ -44,6 +44,7 @@
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
 import org.mockito.Mockito;
 
 /**
@@ -58,7 +59,13 @@
  */
 public class TestHadoopOpenFile {
 
+  private static final String OPENFILE_LENGTH_KEY = "fs.option.openfile.length";
+
   private static final int FIRST = MockHadoopInputStream.TEST_ARRAY[0];
+
+  @TempDir
+  private java.nio.file.Path tempDir;
+
   private URI fsUri;
   private FileStatus status;
   private Path path;
@@ -101,10 +108,58 @@ public void testOpenFileGoodPath() throws Throwable {
     // this looks up the FS binding via the status file path.
     openAndRead(fileFromStatus());
 
+    assertThat(opener.getFileStatus()).as("file status").isSameAs(status);
+
     // The fallback call of open(path) never took place.
     Mockito.verify(mockFS, never()).open(path);
   }
 
+  /**
+   * A caller-supplied length avoids a status lookup and is passed to openFile().
+   */
+  @Test
+  public void testOpenFileWithKnownLength() throws Throwable {
+    final FileSystem mockFS = prepareMockFS();
+    final FSDataInputStream in = new FSDataInputStream(new MockHadoopInputStream());
+    final StubOpenFileBuilder opener = new StubOpenFileBuilder(mockFS, path, CompletableFuture.completedFuture(in));
+    doReturn(opener).when(mockFS).openFile(path);
+
+    final HadoopInputFile inputFile = HadoopInputFile.fromPath(path, status.getLen(), conf);
+    assertThat(inputFile.getPath()).as("path").isEqualTo(path);
+    assertThat(inputFile.getLength()).as("length").isEqualTo(status.getLen());
+    openAndRead(inputFile);
+
+    Mockito.verify(mockFS, never()).getFileStatus(path);
+    assertThat(opener.getFileStatus()).as("file status").isNull();
+    assertThat(opener.getOptions().get(OPENFILE_LENGTH_KEY))
+        .as("openFile length")
+        .isEqualTo(Long.toString(status.getLen()));
+  }
+
+  @Test
+  public void testRejectsNegativeKnownLength() {
+    assertThatThrownBy(() -> HadoopInputFile.fromPath(path, -1, conf))
+        .isInstanceOf(IllegalArgumentException.class)
+        .hasMessage("Invalid file length: -1");
+  }
+
+  /**
+   * Opening a nonexistent file with a caller-supplied length must fail either
+   * when opening the stream or on the first read.
+   */
+  @Test
+  public void testKnownLengthMissingFile() throws IOException {
+    final Path missingPath = new Path(new Path(tempDir.toUri()), "missing.parquet");
+    final HadoopInputFile inputFile = HadoopInputFile.fromPath(missingPath, 1, conf);
+
+    assertThatThrownBy(() -> {
+          try (SeekableInputStream stream = inputFile.newStream()) {
+            stream.read();
+          }
+        })
+        .isInstanceOf(FileNotFoundException.class);
+  }
+
   /**
    * The openFile() call raises a RuntimeException which it is caught and the
    * classic open() call invoked.
@@ -275,6 +330,10 @@ private StubOpenFileBuilder(
       this.result = result;
     }
 
+    private FileStatus getFileStatus() {
+      return getStatus();
+    }
+
     @Override
     public CompletableFuture<FSDataInputStream> build()
         throws IllegalArgumentException, UnsupportedOperationException {