diff --git a/doc/api/cli.md b/doc/api/cli.md
index d3309ae6192d..9545f40f3460 100644
--- a/doc/api/cli.md
+++ b/doc/api/cli.md
@@ -1465,6 +1465,16 @@ added:
 
 Enable exposition of [EventSource Web API][] on the global scope.
 
+### `--experimental-fileapi`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+Enable exposition of the [File API][] globals `FileReader` and `ProgressEvent`
+on the global scope. `FileReaderSync` is exposed only inside a Web Worker
+started with `--experimental-web-worker`.
+
 ### `--experimental-import-meta-resolve`
 
 <!-- YAML
@@ -4305,6 +4315,7 @@ one is included in the list below.
 * `--experimental-detect-module`
 * `--experimental-dtls`
 * `--experimental-eventsource`
+* `--experimental-fileapi`
 * `--experimental-import-meta-resolve`
 * `--experimental-import-text`
 * `--experimental-json-modules`
@@ -4920,6 +4931,7 @@ node --stack-trace-limit=12 -p -e "Error.stackTraceLimit" # prints 12
 [EventSource Web API]: https://html.spec.whatwg.org/multipage/server-sent-events.html#server-sent-events
 [ExperimentalWarning: `vm.measureMemory` is an experimental feature]: vm.md#vmmeasurememoryoptions
 [FIPS mode]: crypto.md#fips-mode
+[File API]: https://w3c.github.io/FileAPI/
 [File System Permissions]: permissions.md#file-system-permissions
 [Loading ECMAScript modules using `require()`]: modules.md#loading-ecmascript-modules-using-require
 [Module resolution and loading]: packages.md#module-resolution-and-loading
diff --git a/doc/api/globals.md b/doc/api/globals.md
index f07ac97431b6..b6d54e620007 100644
--- a/doc/api/globals.md
+++ b/doc/api/globals.md
@@ -607,6 +607,62 @@ added: v20.0.0
 
 See {File}.
 
+## Class: `FileReader`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1.1 - Active development. Enable this API with the
+> [`--experimental-fileapi`][] CLI flag.
+
+An implementation of {FileReader} from the [File API][]. `readAsArrayBuffer()`,
+`readAsBinaryString()`, `readAsText()`, and `readAsDataURL()` read a {Blob}
+asynchronously and report the result through `loadstart`, `progress`, `load`,
+`abort`, `error`, and `loadend` events. `readyState` is `FileReader.EMPTY`
+(`0`), `FileReader.LOADING` (`1`), or `FileReader.DONE` (`2`).
+
+`readAsDataURL()` produces a base64 `data:` URL. When the blob's type is the
+empty string, the URL has no media type (`data:;base64,...`). Chrome and
+Firefox use `application/octet-stream` in that case.
+
+`readAsText()` follows {TextDecoder} for the chosen encoding, including its
+ICU requirement. Labels that the Encoding Standard maps to the replacement
+encoding, such as `'iso-2022-kr'`, decode to U+FFFD when the input is not
+empty.
+
+```js
+const reader = new FileReader();
+reader.addEventListener('load', () => {
+  console.log(reader.result); // Prints: hello
+});
+reader.readAsText(new Blob(['hello']));
+```
+
+## Class: `FileReaderSync`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1.1 - Active development. Enable this API with the
+> [`--experimental-fileapi`][] CLI flag.
+
+An implementation of {FileReaderSync} from the [File API][]. It is
+`[Exposed=(DedicatedWorker,SharedWorker)]`, so it exists only inside a
+[Web Worker][] (`--experimental-web-worker`). It is not available on the main
+thread or in threads created with `node:worker_threads`.
+
+`readAsArrayBuffer()`, `readAsBinaryString()`, `readAsText()`, and
+`readAsDataURL()` read a {Blob} synchronously. A file-backed blob, such as
+one returned by [`fs.openAsBlob()`][], throws a `NotReadableError`.
+
+```js
+// Inside a Web Worker (`--experimental-web-worker`):
+const text = new FileReaderSync().readAsText(new Blob(['hello']));
+postMessage(text); // Sends 'hello'
+```
+
 ## Class: `FormData`
 
 <!-- YAML
@@ -942,6 +998,33 @@ added: v0.1.7
 
 The process object. See the [`process` object][] section.
 
+## Class: `ProgressEvent`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1.1 - Active development. Enable this API with the
+> [`--experimental-fileapi`][] CLI flag.
+
+An implementation of {ProgressEvent} from the [XMLHttpRequest Standard][].
+`FileReader`
+dispatches `ProgressEvent`s for `loadstart`, `progress`, `load`, `abort`,
+`error`, and `loadend`. Those events do not bubble and are not cancelable.
+`lengthComputable`, `loaded`, and `total` return the values they were
+initialized to (`false`, `0`, and `0` when omitted). The File API's
+"fire a progress event" algorithm does not set those three fields, so events
+fired by `FileReader` leave them at the defaults.
+
+```js
+const event = new ProgressEvent('progress', {
+  lengthComputable: true,
+  loaded: 50,
+  total: 100,
+});
+console.log(event.loaded / event.total); // Prints: 0.5
+```
+
 ## `queueMicrotask(callback)`
 
 <!-- YAML
@@ -1475,12 +1558,16 @@ A browser-compatible implementation of [`WritableStreamDefaultWriter`][].
 [CommonJS module]: modules.md
 [CommonJS modules]: modules.md
 [ECMAScript module]: esm.md
+[File API]: https://w3c.github.io/FileAPI/
 [HTML Standard]: https://html.spec.whatwg.org/multipage/workers.html
 [Navigator API]: https://html.spec.whatwg.org/multipage/system-state.html#the-navigator-object
 [RFC 5646]: https://www.rfc-editor.org/rfc/rfc5646.txt
 [Refable protocol]: process.md#processrefmayberefable
 [Web Crypto API]: webcrypto.md
+[Web Worker]: #class-worker
+[XMLHttpRequest Standard]: https://xhr.spec.whatwg.org/#interface-progressevent
 [`--experimental-eventsource`]: cli.md#--experimental-eventsource
+[`--experimental-fileapi`]: cli.md#--experimental-fileapi
 [`--experimental-web-worker`]: cli.md#--experimental-web-worker
 [`--localstorage-file`]: cli.md#--localstorage-filefile
 [`--no-experimental-global-navigator`]: cli.md#--no-experimental-global-navigator
diff --git a/doc/node.1 b/doc/node.1
index 444da29eed3d..31d05dbb4b88 100644
--- a/doc/node.1
+++ b/doc/node.1
@@ -858,6 +858,11 @@ dtls documentation for details.
 .It Fl -experimental-eventsource
 Enable exposition of EventSource Web API on the global scope.
 .
+.It Fl -experimental-fileapi
+Enable exposition of the File API globals \fBFileReader\fR and \fBProgressEvent\fR
+on the global scope. \fBFileReaderSync\fR is exposed only inside a Web Worker
+started with \fB--experimental-web-worker\fR.
+.
 .It Fl -experimental-import-meta-resolve
 Enable experimental \fBimport.meta.resolve()\fR parent URL support, which allows
 passing a second \fBparentURL\fR argument for contextual resolution.
@@ -2266,6 +2271,8 @@ one is included in the list below.
 .It
 \fB--experimental-eventsource\fR
 .It
+\fB--experimental-fileapi\fR
+.It
 \fB--experimental-import-meta-resolve\fR
 .It
 \fB--experimental-import-text\fR
diff --git a/eslint.config.mjs b/eslint.config.mjs
index 9c4ad8f05651..cebc1b482e36 100644
--- a/eslint.config.mjs
+++ b/eslint.config.mjs
@@ -131,10 +131,13 @@ export default [
         DisposableStack: 'readonly',
         EventSource: 'readonly',
         fetch: 'readonly',
+        FileReader: 'readonly',
+        FileReaderSync: 'readonly',
         Float16Array: 'readonly',
         FormData: 'readonly',
         localStorage: 'readonly',
         navigator: 'readonly',
+        ProgressEvent: 'readonly',
         QuotaExceededError: 'readonly',
         ReadableByteStreamController: 'readonly',
         ReadableStream: 'readonly',
diff --git a/lib/internal/bootstrap/web/exposed-window-or-worker.js b/lib/internal/bootstrap/web/exposed-window-or-worker.js
index 35cb1d5120e1..974261639ea9 100644
--- a/lib/internal/bootstrap/web/exposed-window-or-worker.js
+++ b/lib/internal/bootstrap/web/exposed-window-or-worker.js
@@ -57,6 +57,10 @@ exposeLazyInterfaces(globalThis, 'internal/webworker', ['Worker']);
 exposeLazyInterfaces(globalThis, 'internal/blob', ['Blob']);
 // https://www.w3.org/TR/FileAPI/#dfn-file
 exposeLazyInterfaces(globalThis, 'internal/file', ['File']);
+// https://w3c.github.io/FileAPI/#APIASynch
+exposeLazyInterfaces(globalThis, 'internal/filereader', ['FileReader']);
+// https://xhr.spec.whatwg.org/#interface-progressevent
+exposeLazyInterfaces(globalThis, 'internal/progress_event', ['ProgressEvent']);
 // https://www.w3.org/TR/hr-time-2/#the-performance-attribute
 exposeLazyInterfaces(globalThis, 'perf_hooks', [
   'Performance', 'PerformanceEntry', 'PerformanceMark', 'PerformanceMeasure',
diff --git a/lib/internal/file.js b/lib/internal/file.js
index aa05a602975e..bd1e2c3ef3d6 100644
--- a/lib/internal/file.js
+++ b/lib/internal/file.js
@@ -149,4 +149,5 @@ ObjectDefineProperties(File.prototype, {
 module.exports = {
   File,
   TransferableFile,
+  isFile,
 };
diff --git a/lib/internal/filereader.js b/lib/internal/filereader.js
new file mode 100644
index 000000000000..26db994e70b8
--- /dev/null
+++ b/lib/internal/filereader.js
@@ -0,0 +1,728 @@
+'use strict';
+
+// The Web IDL and specification prose quoted below is reproduced verbatim
+// from the specification, including its original (lowercase) casing.
+// Refs: https://w3c.github.io/FileAPI/
+/* eslint-disable capitalized-comments */
+
+const {
+  ArrayPrototypePush,
+  DateNow,
+  ObjectDefineProperties,
+  ObjectDefineProperty,
+  PromisePrototypeThen,
+  Symbol,
+  SymbolToStringTag,
+  TypedArrayPrototypeGetByteLength,
+  TypedArrayPrototypeSet,
+  TypedArrayPrototypeSubarray,
+  Uint8Array,
+} = primordials;
+
+const { Buffer } = require('buffer');
+
+const { setImmediate } = require('timers');
+
+const {
+  EventTarget,
+  defineEventHandler,
+  kTrustEvent,
+} = require('internal/event_target');
+
+const {
+  createBlobReaderStream,
+  getBlobDataSync,
+  isBlob,
+  kHandle,
+  kType,
+} = require('internal/blob');
+
+const { TextDecoder, getEncodingFromLabel } = require('internal/encoding');
+
+const { MIMEType } = require('internal/mime');
+
+const { ProgressEvent } = require('internal/progress_event');
+
+const {
+  kEnumerableProperty,
+  lazyDOMException,
+} = require('internal/util');
+
+const { isUint8Array } = require('internal/util/types');
+
+const {
+  validateThisInternalField,
+} = require('internal/validators');
+
+const {
+  converters,
+  createInterfaceConverter,
+  requiredArguments,
+} = require('internal/webidl');
+
+const kError = Symbol('error');
+const kGeneration = Symbol('generation');
+const kReader = Symbol('reader');
+const kResult = Symbol('result');
+const kState = Symbol('state');
+const kSync = Symbol('sync');
+
+const kProgressInterval = 50;
+
+const convertBlob = createInterfaceConverter('Blob', isBlob);
+
+// "When this specification says to fire a progress event called e (for some
+// ProgressEvent e at a given FileReader reader), the following are normative:
+//
+// * The progress event e does not bubble. e.bubbles must be false
+// * The progress event e is NOT cancelable. e.cancelable must be false"
+const kTrustedProgressEventInit = {
+  __proto__: null,
+  [kTrustEvent]: true,
+};
+
+function fireAProgressEvent(name, reader) {
+  reader.dispatchEvent(new ProgressEvent(name, kTrustedProgressEventInit));
+}
+
+// "Use the file reading task source for all these tasks."
+function queueFileReadingTask(fr, generation, steps) {
+  setImmediate(() => {
+    if (fr[kGeneration] !== generation) {
+      return;
+    }
+    steps();
+  });
+}
+
+function combineByteSequences(chunks, totalBytes) {
+  const bytes = new Uint8Array(totalBytes);
+  let offset = 0;
+  for (let i = 0; i < chunks.length; i++) {
+    const chunk = chunks[i];
+    TypedArrayPrototypeSet(bytes, chunk, offset);
+    offset += TypedArrayPrototypeGetByteLength(chunk);
+  }
+  return bytes;
+}
+
+// https://encoding.spec.whatwg.org/#bom-sniff
+//
+// "To BOM sniff an I/O queue of bytes ioQueue:"
+function bomSniff(bytes) {
+  // "Let BOM be the result of peeking 3 bytes from ioQueue, converted to a
+  // byte sequence."
+  const length = TypedArrayPrototypeGetByteLength(bytes);
+  // "For each of the rows in the table below, starting with the first one
+  // and going down, if BOM starts with the bytes given in the first column,
+  // then return the encoding given in the cell in the second column of that
+  // row. Otherwise, return null."
+  //
+  // 0xEF 0xBB 0xBF  UTF-8
+  // 0xFE 0xFF       UTF-16BE
+  // 0xFF 0xFE       UTF-16LE
+  if (length >= 3 &&
+      bytes[0] === 0xEF && bytes[1] === 0xBB && bytes[2] === 0xBF) {
+    return 'utf-8';
+  }
+  if (length >= 2) {
+    const a = bytes[0];
+    const b = bytes[1];
+    if (a === 0xFE && b === 0xFF) {
+      return 'utf-16be';
+    }
+    if (a === 0xFF && b === 0xFE) {
+      return 'utf-16le';
+    }
+  }
+  return null;
+}
+
+// https://encoding.spec.whatwg.org/#decode
+//
+// "To decode an I/O queue of bytes ioQueue given a fallback encoding
+// encoding:"
+function decode(bytes, encoding) {
+  // "Let BOMEncoding be the result of BOM sniffing ioQueue."
+  const bomEncoding = bomSniff(bytes);
+  let offset = 0;
+  // "If BOMEncoding is non-null:
+  //  1. Set encoding to BOMEncoding.
+  //  2. Read three bytes from ioQueue, if BOMEncoding is UTF-8; otherwise
+  //     read two bytes. (Do nothing with those bytes.)"
+  if (bomEncoding !== null) {
+    encoding = bomEncoding;
+    offset = bomEncoding === 'utf-8' ? 3 : 2;
+  }
+  const view = offset === 0 ? bytes :
+    TypedArrayPrototypeSubarray(bytes, offset);
+  // "replacement's decoder's handler, given unused and byte, runs these
+  // steps:
+  //  1. If byte is end-of-queue, then return finished.
+  //  2. If replacement error returned is false, then set replacement error
+  //     returned to true and return error.
+  //  3. Return finished."
+  // Error mode "replacement" turns that error into U+FFFD.
+  if (encoding === 'replacement') {
+    return TypedArrayPrototypeGetByteLength(view) === 0 ? '' : '\uFFFD';
+  }
+  // "Process a queue with an instance of encoding's decoder, ioQueue,
+  // output, and "replacement"."
+  // "Return output."
+  return new TextDecoder(encoding, { ignoreBOM: true }).decode(view);
+}
+
+// https://w3c.github.io/FileAPI/#packaging-data
+//
+// "A Blob has an associated package data algorithm, given bytes, a type,
+// a mimeType, and an optional encodingLabel, which switches on type and
+// runs the associated steps:"
+function packageData(bytes, type, mimeType, encodingLabel) {
+  switch (type) {
+    case 'DataURL': {
+      // "Return bytes as a DataURL subject to the considerations below:
+      //  * Use mimeType as part of the Data URL if it is not the empty
+      //    string in keeping with the Data URL specification.
+      //  * Otherwise, return a Data URL without a media-type."
+      const encoded = Buffer.from(
+        bytes.buffer,
+        bytes.byteOffset,
+        bytes.byteLength,
+      ).toString('base64');
+      if (mimeType === '') {
+        return `data:;base64,${encoded}`;
+      }
+      return `data:${mimeType};base64,${encoded}`;
+    }
+    case 'Text': {
+      // "1. Let encoding be failure."
+      let encoding;
+      // "2. If the encodingLabel is present, set encoding to the result of
+      // getting an encoding from encodingLabel."
+      if (encodingLabel !== undefined) {
+        encoding = getEncodingFromLabel(encodingLabel);
+      }
+      // "3. If encoding is failure:"
+      if (encoding === undefined) {
+        // "1. Let type be the result of parse a MIME type given mimeType."
+        const parsed = mimeType === '' ? null : MIMEType.parse(mimeType);
+        // "2. If type is not failure, set encoding to the result of getting
+        // an encoding from type's parameters["charset"]."
+        if (parsed !== null) {
+          const charset = parsed.params.get('charset');
+          if (charset !== null) {
+            encoding = getEncodingFromLabel(charset);
+          }
+        }
+      }
+      // "4. If encoding is failure, then set encoding to UTF-8."
+      if (encoding === undefined) {
+        encoding = 'utf-8';
+      }
+      // "5. Decode bytes using fallback encoding encoding, and return the
+      // result."
+      return decode(bytes, encoding);
+    }
+    case 'ArrayBuffer':
+      // "Return a new ArrayBuffer whose contents are bytes."
+      return combineByteSequences([bytes], bytes.byteLength).buffer;
+    case 'BinaryString':
+      // "Return bytes as a binary string, in which every byte is
+      // represented by a code unit of equal value [0..255]."
+      return Buffer.from(
+        bytes.buffer,
+        bytes.byteOffset,
+        bytes.byteLength,
+      ).toString('latin1');
+  }
+}
+
+function settleWithError(fr, generation, error) {
+  // "Otherwise, if chunkPromise is rejected with an error error, queue a
+  // task to run the following steps and abort this algorithm:"
+  queueFileReadingTask(fr, generation, () => {
+    // "1. Set fr's state to "done"."
+    fr[kState] = 'done';
+    // "2. Set fr's error to error."
+    fr[kError] = error;
+    // "3. Fire a progress event called error at fr."
+    fireAProgressEvent('error', fr);
+    queueLoadEnd(fr, generation);
+  });
+}
+
+function queueLoadEnd(fr, generation) {
+  // "If fr's state is not "loading", fire a progress event called loadend
+  // at the fr."
+  //
+  // "Event handler for the load or error events could have started another
+  // load, if that happens the loadend event for this load is not fired."
+  queueFileReadingTask(fr, generation, () => {
+    if (fr[kState] !== 'loading') {
+      fireAProgressEvent('loadend', fr);
+    }
+  });
+}
+
+// "A FileReader fr has an associated read operation algorithm, which given
+// blob, a type and an optional encodingLabel, runs the following steps:"
+function readOperation(fr, blob, type, encodingLabel) {
+  // "1. If fr's state is "loading", throw an InvalidStateError DOMException."
+  if (fr[kState] === 'loading') {
+    throw lazyDOMException(
+      'The object is in an invalid state.',
+      'InvalidStateError');
+  }
+  const previousState = fr[kState];
+  const previousResult = fr[kResult];
+  const previousError = fr[kError];
+  // "2. Set fr's state to "loading"."
+  fr[kState] = 'loading';
+  // "3. Set fr's result to null."
+  fr[kResult] = null;
+  // "4. Set fr's error to null."
+  fr[kError] = null;
+
+  const generation = ++fr[kGeneration];
+  // "5. Let stream be the result of calling get stream on blob."
+  let stream;
+  try {
+    stream = createBlobReaderStream(blob[kHandle].getReader());
+  } catch (error) {
+    fr[kState] = previousState;
+    fr[kResult] = previousResult;
+    fr[kError] = previousError;
+    throw error;
+  }
+  // "6. Let reader be the result of getting a reader from stream."
+  const reader = stream.getReader();
+  fr[kReader] = reader;
+  // "7. Let bytes be an empty byte sequence."
+  const chunks = [];
+  let totalBytes = 0;
+  // "8. Let chunkPromise be the result of reading a chunk from stream with
+  // reader."
+  let chunkPromise = reader.read();
+  // "9. Let isFirstChunk be true."
+  let isFirstChunk = true;
+  let lastStepsAt;
+
+  // "10. In parallel, while true:"
+  async function readInParallel() {
+    while (true) {
+      if (fr[kGeneration] !== generation) {
+        return;
+      }
+
+      // "1. Wait for chunkPromise to be fulfilled or rejected."
+      let chunk;
+      try {
+        chunk = await chunkPromise;
+      } catch (error) {
+        if (fr[kGeneration] !== generation) {
+          return;
+        }
+        settleWithError(fr, generation, error);
+        return;
+      }
+
+      if (fr[kGeneration] !== generation) {
+        return;
+      }
+
+      // "2. If chunkPromise is fulfilled, and isFirstChunk is true, queue a
+      // task to fire a progress event called loadstart at fr."
+      if (isFirstChunk) {
+        queueFileReadingTask(fr, generation, () => {
+          fireAProgressEvent('loadstart', fr);
+        });
+      }
+      // "3. Set isFirstChunk to false."
+      isFirstChunk = false;
+
+      // "4. If chunkPromise is fulfilled with an object whose done property
+      // is false and whose value property is a Uint8Array object, run these
+      // steps:"
+      if (chunk.done !== true && isUint8Array(chunk.value)) {
+        // "1. Let bs be the byte sequence represented by the Uint8Array
+        // object."
+        const bs = chunk.value;
+        // "2. Append bs to bytes."
+        ArrayPrototypePush(chunks, bs);
+        totalBytes += bs.byteLength;
+        // "3. If roughly 50ms have passed since these steps were last
+        // invoked, queue a task to fire a progress event called progress
+        // at fr."
+        const now = DateNow();
+        if (lastStepsAt !== undefined && now - lastStepsAt >= kProgressInterval) {
+          queueFileReadingTask(fr, generation, () => {
+            fireAProgressEvent('progress', fr);
+          });
+        }
+        lastStepsAt = now;
+        // "4. Set chunkPromise to the result of reading a chunk from stream
+        // with reader."
+        chunkPromise = reader.read();
+        continue;
+      }
+
+      // "5. Otherwise, if chunkPromise is fulfilled with an object whose
+      // done property is true, queue a task to run the following steps and
+      // abort this algorithm:"
+      if (chunk.done === true) {
+        const bytes = combineByteSequences(chunks, totalBytes);
+        const mimeType = blob[kType];
+        // "One progress event will fire when blob has been completely read
+        // into memory."
+        if (totalBytes > 0) {
+          queueFileReadingTask(fr, generation, () => {
+            fireAProgressEvent('progress', fr);
+          });
+        }
+        queueFileReadingTask(fr, generation, () => {
+          // "1. Set fr's state to "done"."
+          fr[kState] = 'done';
+          fr[kReader] = undefined;
+          try {
+            // "2. Let result be the result of package data given bytes,
+            // type, blob's type, and encodingLabel."
+            const result = packageData(bytes, type, mimeType, encodingLabel);
+            // "4. Else:
+            //  1. Set fr's result to result.
+            //  2. Fire a progress event called load at the fr."
+            fr[kResult] = result;
+            fireAProgressEvent('load', fr);
+          } catch (error) {
+            // "3. If package data threw an exception error:
+            //  1. Set fr's error to error.
+            //  2. Fire a progress event called error at fr."
+            fr[kError] = error;
+            fireAProgressEvent('error', fr);
+          }
+          queueLoadEnd(fr, generation);
+        });
+        return;
+      }
+
+      return;
+    }
+  }
+
+  readInParallel().catch((error) => {
+    if (fr[kGeneration] !== generation) {
+      return;
+    }
+    settleWithError(fr, generation, error);
+  });
+}
+
+function defineReadStateConstants(target) {
+  // const unsigned short EMPTY = 0;
+  ObjectDefineProperty(target, 'EMPTY', {
+    __proto__: null,
+    writable: false,
+    enumerable: true,
+    configurable: false,
+    value: 0,
+  });
+  // const unsigned short LOADING = 1;
+  ObjectDefineProperty(target, 'LOADING', {
+    __proto__: null,
+    writable: false,
+    enumerable: true,
+    configurable: false,
+    value: 1,
+  });
+  // const unsigned short DONE = 2;
+  ObjectDefineProperty(target, 'DONE', {
+    __proto__: null,
+    writable: false,
+    enumerable: true,
+    configurable: false,
+    value: 2,
+  });
+}
+
+// https://w3c.github.io/FileAPI/#APIASynch
+//
+// [Exposed=(Window,Worker)]
+// interface FileReader: EventTarget {
+class FileReader extends EventTarget {
+  // constructor();
+  constructor() {
+    super();
+    // "The FileReader() constructor, when invoked, must return a new
+    // FileReader object."
+    //
+    // "A FileReader has an associated state, that is "empty", "loading",
+    // or "done". It is initially "empty"."
+    this[kState] = 'empty';
+    // "A FileReader has an associated result (null, a DOMString or an
+    // ArrayBuffer). It is initially null."
+    this[kResult] = null;
+    // "A FileReader has an associated error (null or a DOMException).
+    // It is initially null."
+    this[kError] = null;
+    this[kGeneration] = 0;
+  }
+
+  // undefined readAsArrayBuffer(Blob blob);
+  readAsArrayBuffer(blob) {
+    const prefix = "Failed to execute 'readAsArrayBuffer' on 'FileReader'";
+    validateThisInternalField(this, kState, 'FileReader');
+    requiredArguments(arguments.length, 1, { prefix });
+    blob = convertBlob(blob, { prefix, context: 'Argument 1' });
+    // "The readAsArrayBuffer(blob) method, when invoked, must initiate a
+    // read operation for blob with ArrayBuffer."
+    readOperation(this, blob, 'ArrayBuffer');
+  }
+
+  // undefined readAsBinaryString(Blob blob);
+  readAsBinaryString(blob) {
+    const prefix = "Failed to execute 'readAsBinaryString' on 'FileReader'";
+    validateThisInternalField(this, kState, 'FileReader');
+    requiredArguments(arguments.length, 1, { prefix });
+    blob = convertBlob(blob, { prefix, context: 'Argument 1' });
+    // "The readAsBinaryString(blob) method, when invoked, must initiate a
+    // read operation for blob with BinaryString."
+    readOperation(this, blob, 'BinaryString');
+  }
+
+  // undefined readAsText(Blob blob, optional DOMString encoding);
+  readAsText(blob, encoding = undefined) {
+    const prefix = "Failed to execute 'readAsText' on 'FileReader'";
+    validateThisInternalField(this, kState, 'FileReader');
+    requiredArguments(arguments.length, 1, { prefix });
+    blob = convertBlob(blob, { prefix, context: 'Argument 1' });
+    let encodingLabel;
+    if (arguments.length > 1) {
+      encodingLabel = converters.DOMString(encoding, {
+        prefix,
+        context: 'Argument 2',
+      });
+    }
+    // "The readAsText(blob, encoding) method, when invoked, must initiate a
+    // read operation for blob with Text and encoding."
+    readOperation(this, blob, 'Text', encodingLabel);
+  }
+
+  // undefined readAsDataURL(Blob blob);
+  readAsDataURL(blob) {
+    const prefix = "Failed to execute 'readAsDataURL' on 'FileReader'";
+    validateThisInternalField(this, kState, 'FileReader');
+    requiredArguments(arguments.length, 1, { prefix });
+    blob = convertBlob(blob, { prefix, context: 'Argument 1' });
+    // "The readAsDataURL(blob) method, when invoked, must initiate a read
+    // operation for blob with DataURL."
+    readOperation(this, blob, 'DataURL');
+  }
+
+  // undefined abort();
+  abort() {
+    validateThisInternalField(this, kState, 'FileReader');
+    // "When the abort() method is called, the user agent must run the steps
+    // below:"
+    // "1. If this's state is "empty" or if this's state is "done" set
+    // this's result to null and terminate this algorithm."
+    if (this[kState] === 'empty' || this[kState] === 'done') {
+      this[kResult] = null;
+      return;
+    }
+    // "2. If this's state is "loading" set this's state to "done" and set
+    // this's result to null."
+    if (this[kState] === 'loading') {
+      this[kState] = 'done';
+      this[kResult] = null;
+    }
+    // "3. If there are any tasks from this on the file reading task source
+    // in an affiliated task queue, then remove those tasks from that task
+    // queue."
+    // "4. Terminate the algorithm for the read method being processed."
+    this[kGeneration]++;
+    const reader = this[kReader];
+    this[kReader] = undefined;
+    if (reader !== undefined) {
+      PromisePrototypeThen(reader.cancel(), undefined, () => {});
+    }
+    // "5. Fire a progress event called abort at this."
+    fireAProgressEvent('abort', this);
+    // "6. If this's state is not "loading", fire a progress event called
+    // loadend at this."
+    if (this[kState] !== 'loading') {
+      fireAProgressEvent('loadend', this);
+    }
+  }
+
+  // readonly attribute unsigned short readyState;
+  get readyState() {
+    validateThisInternalField(this, kState, 'FileReader');
+    // "The readyState attribute's getter, when invoked, switches on this's
+    // state and runs the associated step:"
+    switch (this[kState]) {
+      case 'empty':
+        // `"empty"`
+        // Return EMPTY
+        return 0;
+      case 'loading':
+        // `"loading"`
+        // Return LOADING
+        return 1;
+      case 'done':
+        // `"done"`
+        // Return DONE
+        return 2;
+      default:
+        return 0;
+    }
+  }
+
+  // readonly attribute (DOMString or ArrayBuffer)? result;
+  get result() {
+    validateThisInternalField(this, kState, 'FileReader');
+    // "The result attribute's getter, when invoked, must return this's
+    // result."
+    return this[kResult];
+  }
+
+  // readonly attribute DOMException? error;
+  get error() {
+    validateThisInternalField(this, kState, 'FileReader');
+    // "The error attribute's getter, when invoked, must return this's
+    // error."
+    return this[kError];
+  }
+}
+// };
+
+defineReadStateConstants(FileReader);
+defineReadStateConstants(FileReader.prototype);
+
+ObjectDefineProperties(FileReader.prototype, {
+  readAsArrayBuffer: kEnumerableProperty,
+  readAsBinaryString: kEnumerableProperty,
+  readAsText: kEnumerableProperty,
+  readAsDataURL: kEnumerableProperty,
+  abort: kEnumerableProperty,
+  readyState: kEnumerableProperty,
+  result: kEnumerableProperty,
+  error: kEnumerableProperty,
+  [SymbolToStringTag]: {
+    __proto__: null,
+    configurable: true,
+    value: 'FileReader',
+  },
+});
+
+// "The following are the event handler content attributes (and their
+// corresponding event handler event types) that user agents must support
+// on FileReader as DOM attributes:"
+// onloadstart / loadstart
+defineEventHandler(FileReader.prototype, 'loadstart');
+// onprogress / progress
+defineEventHandler(FileReader.prototype, 'progress');
+// onload / load
+defineEventHandler(FileReader.prototype, 'load');
+// onabort / abort
+defineEventHandler(FileReader.prototype, 'abort');
+// onerror / error
+defineEventHandler(FileReader.prototype, 'error');
+// onloadend / loadend
+defineEventHandler(FileReader.prototype, 'loadend');
+
+function readSync(blob, type, encodingLabel) {
+  // "Let stream be the result of calling get stream on blob."
+  // "Let reader be the result of getting a reader from stream."
+  // "Let promise be the result of reading all bytes from stream with
+  // reader."
+  // "Wait for promise to be fulfilled or rejected."
+  const buffer = getBlobDataSync(blob);
+  // "If promise fulfilled with a byte sequence bytes:"
+  if (buffer !== undefined) {
+    return packageData(new Uint8Array(buffer), type, blob[kType], encodingLabel);
+  }
+  // "Throw promise's rejection reason."
+  throw lazyDOMException(
+    'The blob could not be read',
+    'NotReadableError');
+}
+
+// https://w3c.github.io/FileAPI/#FileReaderSync
+//
+// [Exposed=(DedicatedWorker,SharedWorker)]
+// interface FileReaderSync {
+class FileReaderSync {
+  // constructor();
+  constructor() {
+    // "When the FileReaderSync() constructor is invoked, the user agent
+    // must return a new FileReaderSync object."
+    this[kSync] = true;
+  }
+
+  // ArrayBuffer readAsArrayBuffer(Blob blob);
+  readAsArrayBuffer(blob) {
+    const prefix = "Failed to execute 'readAsArrayBuffer' on 'FileReaderSync'";
+    validateThisInternalField(this, kSync, 'FileReaderSync');
+    requiredArguments(arguments.length, 1, { prefix });
+    blob = convertBlob(blob, { prefix, context: 'Argument 1' });
+    // "The readAsArrayBuffer(blob) method, when invoked, must run these
+    // steps:"
+    return readSync(blob, 'ArrayBuffer');
+  }
+
+  // DOMString readAsBinaryString(Blob blob);
+  readAsBinaryString(blob) {
+    const prefix = "Failed to execute 'readAsBinaryString' on 'FileReaderSync'";
+    validateThisInternalField(this, kSync, 'FileReaderSync');
+    requiredArguments(arguments.length, 1, { prefix });
+    blob = convertBlob(blob, { prefix, context: 'Argument 1' });
+    // "The readAsBinaryString(blob) method, when invoked, must run these
+    // steps:"
+    return readSync(blob, 'BinaryString');
+  }
+
+  // DOMString readAsText(Blob blob, optional DOMString encoding);
+  readAsText(blob, encoding = undefined) {
+    const prefix = "Failed to execute 'readAsText' on 'FileReaderSync'";
+    validateThisInternalField(this, kSync, 'FileReaderSync');
+    requiredArguments(arguments.length, 1, { prefix });
+    blob = convertBlob(blob, { prefix, context: 'Argument 1' });
+    let encodingLabel;
+    if (arguments.length > 1) {
+      encodingLabel = converters.DOMString(encoding, {
+        prefix,
+        context: 'Argument 2',
+      });
+    }
+    // "The readAsText(blob, encoding) method, when invoked, must run these
+    // steps:"
+    return readSync(blob, 'Text', encodingLabel);
+  }
+
+  // DOMString readAsDataURL(Blob blob);
+  readAsDataURL(blob) {
+    const prefix = "Failed to execute 'readAsDataURL' on 'FileReaderSync'";
+    validateThisInternalField(this, kSync, 'FileReaderSync');
+    requiredArguments(arguments.length, 1, { prefix });
+    blob = convertBlob(blob, { prefix, context: 'Argument 1' });
+    // "The readAsDataURL(blob) method, when invoked, must run these steps:"
+    return readSync(blob, 'DataURL');
+  }
+}
+// };
+
+ObjectDefineProperties(FileReaderSync.prototype, {
+  readAsArrayBuffer: kEnumerableProperty,
+  readAsBinaryString: kEnumerableProperty,
+  readAsText: kEnumerableProperty,
+  readAsDataURL: kEnumerableProperty,
+  [SymbolToStringTag]: {
+    __proto__: null,
+    configurable: true,
+    value: 'FileReaderSync',
+  },
+});
+
+module.exports = {
+  FileReader,
+  FileReaderSync,
+};
diff --git a/lib/internal/process/pre_execution.js b/lib/internal/process/pre_execution.js
index 0f5aaf857aeb..0fe8ca417482 100644
--- a/lib/internal/process/pre_execution.js
+++ b/lib/internal/process/pre_execution.js
@@ -122,6 +122,7 @@ function prepareExecution(options) {
   setupWebStorage();
   removeWebWorkersIfDisabled();
   setupEventsource();
+  removeFileAPIIfDisabled();
   setupCodeCoverage();
   setupDebugEnv();
   // Process initial diagnostic reporting configuration, if present.
@@ -463,6 +464,15 @@ function removeWebWorkersIfDisabled() {
   }
 }
 
+// https://w3c.github.io/FileAPI/
+function removeFileAPIIfDisabled() {
+  if (!getOptionValue('--experimental-fileapi')) {
+    delete globalThis.FileReader;
+    delete globalThis.FileReaderSync;
+    delete globalThis.ProgressEvent;
+  }
+}
+
 // https://html.spec.whatwg.org/multipage/server-sent-events.html
 function setupEventsource() {
   if (!getOptionValue('--experimental-eventsource')) {
diff --git a/lib/internal/progress_event.js b/lib/internal/progress_event.js
new file mode 100644
index 000000000000..a08278ef7c09
--- /dev/null
+++ b/lib/internal/progress_event.js
@@ -0,0 +1,149 @@
+'use strict';
+
+// The Web IDL and specification prose quoted below is reproduced verbatim
+// from the specification, including its original (lowercase) casing.
+// Refs: https://xhr.spec.whatwg.org/#interface-progressevent
+/* eslint-disable capitalized-comments */
+
+const {
+  ObjectDefineProperties,
+  Symbol,
+  SymbolToStringTag,
+} = primordials;
+
+const {
+  Event,
+  kTrustEvent,
+} = require('internal/event_target');
+
+const {
+  kEnumerableProperty,
+  kEmptyObject,
+} = require('internal/util');
+
+const {
+  validateThisInternalField,
+} = require('internal/validators');
+
+const {
+  converters,
+  createDictionaryConverter,
+  requiredArguments,
+} = require('internal/webidl');
+
+const kLengthComputable = Symbol('lengthComputable');
+const kLoaded = Symbol('loaded');
+const kTotal = Symbol('total');
+
+// dictionary EventInit {
+const kEventInit = [
+  {
+    // boolean bubbles = false;
+    key: 'bubbles',
+    converter: converters.boolean,
+    defaultValue: () => false,
+  },
+  {
+    // boolean cancelable = false;
+    key: 'cancelable',
+    converter: converters.boolean,
+    defaultValue: () => false,
+  },
+  {
+    // boolean composed = false;
+    key: 'composed',
+    converter: converters.boolean,
+    defaultValue: () => false,
+  },
+];
+// };
+
+// dictionary ProgressEventInit : EventInit {
+const kProgressEventInit = [
+  {
+    // boolean lengthComputable = false;
+    key: 'lengthComputable',
+    converter: converters.boolean,
+    defaultValue: () => false,
+  },
+  {
+    // double loaded = 0;
+    key: 'loaded',
+    converter: converters.double,
+    defaultValue: () => 0,
+  },
+  {
+    // double total = 0;
+    key: 'total',
+    converter: converters.double,
+    defaultValue: () => 0,
+  },
+];
+// };
+
+const convertProgressEventInit = createDictionaryConverter(
+  'ProgressEventInit',
+  [kEventInit, kProgressEventInit],
+);
+
+// [Exposed=(Window,Worker)]
+// interface ProgressEvent : Event {
+class ProgressEvent extends Event {
+  // constructor(DOMString type, optional ProgressEventInit eventInitDict = {});
+  constructor(type, eventInitDict = kEmptyObject) {
+    const prefix = "Failed to construct 'ProgressEvent'";
+    requiredArguments(arguments.length, 1, { prefix });
+    const trusted = eventInitDict != null &&
+      typeof eventInitDict === 'object' &&
+      eventInitDict[kTrustEvent] === true;
+    type = converters.DOMString(type, { prefix, context: 'Argument 1' });
+    eventInitDict = convertProgressEventInit(eventInitDict, {
+      prefix,
+      context: 'Argument 2',
+    });
+    if (trusted) {
+      eventInitDict[kTrustEvent] = true;
+    }
+    super(type, eventInitDict);
+
+    // "The lengthComputable, loaded, and total getter steps are to return
+    // the value they were initialized to."
+    this[kLengthComputable] = eventInitDict.lengthComputable;
+    this[kLoaded] = eventInitDict.loaded;
+    this[kTotal] = eventInitDict.total;
+  }
+
+  // readonly attribute boolean lengthComputable;
+  get lengthComputable() {
+    validateThisInternalField(this, kLengthComputable, 'ProgressEvent');
+    return this[kLengthComputable];
+  }
+
+  // readonly attribute double loaded;
+  get loaded() {
+    validateThisInternalField(this, kLengthComputable, 'ProgressEvent');
+    return this[kLoaded];
+  }
+
+  // readonly attribute double total;
+  get total() {
+    validateThisInternalField(this, kLengthComputable, 'ProgressEvent');
+    return this[kTotal];
+  }
+}
+// };
+
+ObjectDefineProperties(ProgressEvent.prototype, {
+  lengthComputable: kEnumerableProperty,
+  loaded: kEnumerableProperty,
+  total: kEnumerableProperty,
+  [SymbolToStringTag]: {
+    __proto__: null,
+    configurable: true,
+    value: 'ProgressEvent',
+  },
+});
+
+module.exports = {
+  ProgressEvent,
+};
diff --git a/lib/internal/webidl.js b/lib/internal/webidl.js
index 819b5af205b7..4983801a6e51 100644
--- a/lib/internal/webidl.js
+++ b/lib/internal/webidl.js
@@ -544,6 +544,27 @@ converters.boolean = (V) => {
   return !!V;
 };
 
+/**
+ * Converts a JavaScript value to the IDL double type.
+ * @see https://webidl.spec.whatwg.org/#es-double
+ * @param {any} V JavaScript value.
+ * @param {ConversionOptions} [options] Conversion options.
+ * @returns {number}
+ */
+converters.double = (V, options = kEmptyObject) => {
+  // Step 1: Let x be ? ToNumber(V).
+  const x = toNumber(V, options);
+  // Step 2: If x is NaN, +Infinity, or -Infinity, then throw a TypeError.
+  if (!NumberIsFinite(x)) {
+    throw makeException(
+      'is not a finite floating-point value.',
+      options);
+  }
+  // Step 3: Return the IDL double value that represents the same
+  // numeric value as x.
+  return x;
+};
+
 /**
  * Converts a JavaScript value to the IDL object type.
  * @see https://webidl.spec.whatwg.org/#es-object
diff --git a/lib/internal/webworker.js b/lib/internal/webworker.js
index 1361b6daa6e3..2df2d46a5069 100644
--- a/lib/internal/webworker.js
+++ b/lib/internal/webworker.js
@@ -43,6 +43,7 @@ const {
   assignFunctionName,
   defineOperation,
   exposeInterface,
+  exposeLazyInterfaces,
   getCWDURL,
   getLazy,
   kEmptyObject,
@@ -1002,6 +1003,8 @@ function installDedicatedWorkerGlobalScope(url, {
     globalThis, 'DedicatedWorkerGlobalScope', DedicatedWorkerGlobalScope);
   exposeInterface(globalThis, 'WorkerNavigator', WorkerNavigator);
   exposeInterface(globalThis, 'WorkerLocation', WorkerLocation);
+  // [Exposed=(DedicatedWorker,SharedWorker)]
+  exposeLazyInterfaces(globalThis, 'internal/filereader', ['FileReaderSync']);
   return globalThis;
 }
 
diff --git a/src/node_options.cc b/src/node_options.cc
index 4ba4801ad1dc..11dda59af97c 100644
--- a/src/node_options.cc
+++ b/src/node_options.cc
@@ -776,6 +776,11 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
             BOOL_FIELD(experimental_eventsource),
             kAllowedInEnvvar,
             false);
+  AddOption("--experimental-fileapi",
+            "experimental File API globals",
+            BOOL_FIELD(experimental_fileapi),
+            kAllowedInEnvvar,
+            false);
   AddOption("--experimental-fetch", "", NoOp{}, kAllowedInEnvvar);
 #if HAVE_FFI
   AddOption("--experimental-ffi",
diff --git a/src/node_options.h b/src/node_options.h
index f8aa58253862..ae75f9e301eb 100644
--- a/src/node_options.h
+++ b/src/node_options.h
@@ -210,6 +210,7 @@ class EnvironmentOptions : public Options {
   DEFINE_BOOL_FIELD(experimental_addon_modules) = true;
   DEFINE_BOOL_FIELD(experimental_bench) = EXPERIMENTALS_DEFAULT_VALUE;
   DEFINE_BOOL_FIELD(experimental_eventsource) = EXPERIMENTALS_DEFAULT_VALUE;
+  DEFINE_BOOL_FIELD(experimental_fileapi) = EXPERIMENTALS_DEFAULT_VALUE;
   DEFINE_BOOL_FIELD(experimental_ffi) = HAVE_FFI;
   DEFINE_BOOL_FIELD(experimental_web_worker) = EXPERIMENTALS_DEFAULT_VALUE;
   DEFINE_BOOL_FIELD(experimental_websocket) = true;
diff --git a/test/parallel/test-filereader-flag.js b/test/parallel/test-filereader-flag.js
new file mode 100644
index 000000000000..f660ee46f80a
--- /dev/null
+++ b/test/parallel/test-filereader-flag.js
@@ -0,0 +1,9 @@
+'use strict';
+
+require('../common');
+const assert = require('node:assert');
+
+// Without --experimental-fileapi, the File API globals are not exposed.
+assert.strictEqual(typeof FileReader, 'undefined');
+assert.strictEqual(typeof FileReaderSync, 'undefined');
+assert.strictEqual(typeof ProgressEvent, 'undefined');
diff --git a/test/parallel/test-filereader.js b/test/parallel/test-filereader.js
new file mode 100644
index 000000000000..42b41895b1c7
--- /dev/null
+++ b/test/parallel/test-filereader.js
@@ -0,0 +1,267 @@
+// Flags: --expose-internals --experimental-web-worker --experimental-fileapi
+'use strict';
+
+const common = require('../common');
+const assert = require('node:assert');
+
+{
+  assert.strictEqual(typeof FileReader, 'function');
+  assert.strictEqual(typeof ProgressEvent, 'function');
+  assert.strictEqual(typeof FileReaderSync, 'undefined');
+}
+
+{
+  const reader = new FileReader();
+  assert.strictEqual(reader.readyState, FileReader.EMPTY);
+  assert.strictEqual(reader.result, null);
+  assert.strictEqual(reader.error, null);
+  for (const name of [
+    'onloadstart', 'onprogress', 'onload', 'onabort', 'onerror', 'onloadend',
+  ]) {
+    assert.strictEqual(reader[name], null);
+  }
+  assert.strictEqual(FileReader.EMPTY, 0);
+  assert.strictEqual(FileReader.LOADING, 1);
+  assert.strictEqual(FileReader.DONE, 2);
+  assert.strictEqual(FileReader.prototype.EMPTY, 0);
+  assert.throws(() => {
+    reader.readAsText({});
+  }, { code: 'ERR_INVALID_ARG_TYPE' });
+  assert.throws(() => {
+    FileReader.prototype.readAsText.call({}, new Blob());
+  }, { code: 'ERR_INVALID_THIS' });
+  reader.abort();
+  assert.strictEqual(reader.readyState, FileReader.EMPTY);
+  assert.strictEqual(reader.result, null);
+}
+
+{
+  const reader = new FileReader();
+  const events = [];
+  reader.addEventListener('loadstart', common.mustCall((event) => {
+    events.push('loadstart');
+    assert.ok(event instanceof ProgressEvent);
+    assert.strictEqual(event.isTrusted, true);
+    assert.strictEqual(reader.readyState, FileReader.LOADING);
+    assert.strictEqual(reader.result, null);
+  }));
+  reader.addEventListener('progress', common.mustCall((event) => {
+    events.push('progress');
+    assert.ok(event instanceof ProgressEvent);
+    assert.strictEqual(event.isTrusted, true);
+    assert.strictEqual(reader.readyState, FileReader.LOADING);
+    assert.strictEqual(reader.result, null);
+  }));
+  reader.addEventListener('load', common.mustCall((event) => {
+    events.push('load');
+    assert.ok(event instanceof ProgressEvent);
+    assert.strictEqual(event.isTrusted, true);
+    assert.strictEqual(reader.readyState, FileReader.DONE);
+    assert.strictEqual(reader.result, 'TEST');
+  }));
+  reader.addEventListener('loadend', common.mustCall((event) => {
+    events.push('loadend');
+    assert.ok(event instanceof ProgressEvent);
+    assert.strictEqual(event.isTrusted, true);
+    assert.deepStrictEqual(events, ['loadstart', 'progress', 'load', 'loadend']);
+  }));
+  reader.readAsText(new Blob(['TEST']));
+}
+
+{
+  const reader = new FileReader();
+  const events = [];
+  reader.onloadstart = common.mustCall(() => events.push('loadstart'));
+  reader.onprogress = common.mustNotCall();
+  reader.onload = common.mustCall(() => {
+    events.push('load');
+    assert.strictEqual(reader.result, '');
+  });
+  reader.onloadend = common.mustCall(() => {
+    events.push('loadend');
+    assert.deepStrictEqual(events, ['loadstart', 'load', 'loadend']);
+  });
+  reader.readAsText(new Blob());
+}
+
+{
+  const reader = new FileReader();
+  reader.onload = common.mustCall(() => {
+    assert.strictEqual(reader.result, '\u4554\u5453');
+  });
+  reader.readAsText(new Blob(['TEST']), 'UTF-16');
+}
+
+{
+  const data = [0xFE, 0xFF, 0x00, 0x68, 0x00, 0x65, 0x00, 0x6C, 0x00, 0x6C, 0x00, 0x6F];
+  const reader = new FileReader();
+  reader.onload = common.mustCall(() => {
+    assert.strictEqual(reader.result, 'hello');
+  });
+  reader.readAsText(new Blob([new Uint8Array(data)], {
+    type: 'text/plain;charset=UTF-16BE',
+  }));
+}
+
+{
+  const reader = new FileReader();
+  reader.onload = common.mustCall(() => {
+    assert.strictEqual(reader.result, 'data:text/plain;base64,VEVTVA==');
+    assert.strictEqual(reader.result instanceof ArrayBuffer, false);
+  });
+  reader.readAsDataURL(new Blob(['TEST'], { type: 'text/plain' }));
+}
+
+{
+  const reader = new FileReader();
+  reader.onload = common.mustCall(() => {
+    assert.strictEqual(
+      reader.result,
+      'data:;base64,VEVTVA==');
+  });
+  reader.readAsDataURL(new Blob(['TEST']));
+}
+
+{
+  const reader = new FileReader();
+  reader.onload = common.mustCall(() => {
+    assert.ok(reader.result instanceof ArrayBuffer);
+    assert.deepStrictEqual(
+      new Uint8Array(reader.result),
+      new Uint8Array([84, 69, 83, 84]));
+  });
+  reader.readAsArrayBuffer(new Blob(['TEST']));
+}
+
+{
+  const reader = new FileReader();
+  reader.onload = common.mustCall(() => {
+    assert.strictEqual(reader.result, '\xcf\x83');
+  });
+  reader.readAsBinaryString(new Blob(['σ']));
+}
+
+{
+  const reader = new FileReader();
+  const blob = new Blob(['TEST THE ABORT METHOD']);
+  reader.onloadstart = common.mustCall(() => {
+    assert.strictEqual(reader.readyState, FileReader.LOADING);
+    reader.onabort = common.mustCall((event) => {
+      assert.strictEqual(event.type, 'abort');
+      assert.strictEqual(event.bubbles, false);
+      assert.strictEqual(event.cancelable, false);
+      assert.ok(event instanceof ProgressEvent);
+      assert.strictEqual(reader.readyState, FileReader.DONE);
+      assert.strictEqual(reader.result, null);
+    });
+    reader.onloadend = common.mustCall(() => {
+      assert.strictEqual(reader.readyState, FileReader.DONE);
+    });
+    reader.onload = common.mustNotCall();
+    reader.abort();
+  });
+  reader.readAsText(blob);
+}
+
+{
+  const reader = new FileReader();
+  reader.readAsText(new Blob(['one']));
+  assert.throws(() => {
+    reader.readAsText(new Blob(['two']));
+  }, { name: 'InvalidStateError' });
+}
+
+{
+  const first = new FileReader();
+  first.onloadstart = common.mustCall(() => {
+    first.abort();
+    first.onloadstart = null;
+    first.onloadend = common.mustCall(() => {
+      assert.strictEqual(first.result, 'second');
+    });
+    first.readAsText(new Blob(['second']));
+  });
+  first.readAsText(new Blob(['first']));
+}
+
+{
+  const event = new ProgressEvent('progress', {
+    lengthComputable: true,
+    loaded: 3,
+    total: 4,
+    bubbles: true,
+  });
+  assert.strictEqual(event.type, 'progress');
+  assert.strictEqual(event.lengthComputable, true);
+  assert.strictEqual(event.loaded, 3);
+  assert.strictEqual(event.total, 4);
+  assert.strictEqual(event.bubbles, true);
+  assert.strictEqual(event.cancelable, false);
+  assert.throws(() => new ProgressEvent('load', { loaded: Infinity }), {
+    code: 'ERR_INVALID_ARG_TYPE',
+  });
+  assert.throws(() => ProgressEvent.prototype.loaded, {
+    code: 'ERR_INVALID_THIS',
+  });
+  assert.strictEqual(new ProgressEvent('load').isTrusted, false);
+}
+
+{
+  const reader = new FileReader();
+  reader.onload = common.mustCall(() => {
+    assert.strictEqual(reader.result, '\uFFFD');
+  });
+  reader.readAsText(new Blob(['hello']), 'iso-2022-kr');
+}
+
+{
+  const reader = new FileReader();
+  reader.onload = common.mustCall(() => {
+    assert.strictEqual(reader.result, '');
+  });
+  reader.readAsText(new Blob(), 'iso-2022-kr');
+}
+
+{
+  const blob = new Blob(['TEST']);
+  blob.stream = () => {
+    throw new Error('public stream should not be used');
+  };
+  Object.defineProperty(blob, 'type', {
+    get() { return 'text/evil'; },
+  });
+  const reader = new FileReader();
+  reader.onload = common.mustCall(() => {
+    assert.strictEqual(reader.result, 'data:;base64,VEVTVA==');
+  });
+  reader.readAsDataURL(blob);
+}
+
+if (common.hasCrypto) {
+  const source = `
+    const sync = new FileReaderSync();
+    const blob = new Blob(['test']);
+    const empty = new Blob();
+    postMessage({
+      hasReader: typeof FileReader === 'function',
+      text: sync.readAsText(blob),
+      empty: sync.readAsText(empty),
+      binary: sync.readAsBinaryString(blob),
+      url: sync.readAsDataURL(empty),
+      bytes: sync.readAsArrayBuffer(blob).byteLength,
+    });
+  `;
+  const url = URL.createObjectURL(new Blob([source], { type: 'text/javascript' }));
+  const worker = new Worker(url);
+  URL.revokeObjectURL(url);
+  worker.onerror = common.mustNotCall('worker failed');
+  worker.onmessage = common.mustCall(({ data }) => {
+    worker.terminate();
+    assert.strictEqual(data.hasReader, true);
+    assert.strictEqual(data.text, 'test');
+    assert.strictEqual(data.empty, '');
+    assert.strictEqual(data.binary, 'test');
+    assert.strictEqual(data.url.indexOf('data:'), 0);
+    assert.strictEqual(data.bytes, 4);
+  });
+}
diff --git a/test/wpt/status/FileAPI.json b/test/wpt/status/FileAPI.json
new file mode 100644
index 000000000000..0967ef424bce
--- /dev/null
+++ b/test/wpt/status/FileAPI.json
@@ -0,0 +1 @@
+{}
diff --git a/test/wpt/status/FileAPI/reading-data-section.json b/test/wpt/status/FileAPI/reading-data-section.json
new file mode 100644
index 000000000000..27c8c41fb141
--- /dev/null
+++ b/test/wpt/status/FileAPI/reading-data-section.json
@@ -0,0 +1,11 @@
+{
+  "filereader_readAsDataURL.any.js": {
+    "fail": {
+      "note": "package data returns a data URL without a media type when the blob type is empty",
+      "expected": [
+        "readAsDataURL result for Blob with unspecified MIME type",
+        "readAsDataURL result for empty Blob"
+      ]
+    }
+  }
+}
diff --git a/test/wpt/status/workers.json b/test/wpt/status/workers.json
index 015ac98d0084..86f2ec1c39db 100644
--- a/test/wpt/status/workers.json
+++ b/test/wpt/status/workers.json
@@ -112,7 +112,7 @@
   },
   "semantics/interface-objects/001.worker.js": {
     "fail": {
-      "note": "Canvas, XHR, EventSource, PromiseRejectionEvent, ProgressEvent, the File API reader classes and IndexedDB are not implemented",
+      "note": "Canvas, XHR, EventSource, PromiseRejectionEvent, FileList, and IndexedDB are not implemented",
       "expected": [
         "The ImageData interface object should be exposed.",
         "The ImageBitmap interface object should be exposed.",
@@ -121,14 +121,11 @@
         "The TextMetrics interface object should be exposed.",
         "The Path2D interface object should be exposed.",
         "The PromiseRejectionEvent interface object should be exposed.",
+        "The FileList interface object should be exposed.",
         "The EventSource interface object should be exposed.",
         "The XMLHttpRequestEventTarget interface object should be exposed.",
         "The XMLHttpRequestUpload interface object should be exposed.",
         "The XMLHttpRequest interface object should be exposed.",
-        "The ProgressEvent interface object should be exposed.",
-        "The FileList interface object should be exposed.",
-        "The FileReader interface object should be exposed.",
-        "The FileReaderSync interface object should be exposed.",
         "The IDBRequest interface object should be exposed.",
         "The IDBOpenDBRequest interface object should be exposed.",
         "The IDBVersionChangeEvent interface object should be exposed.",
diff --git a/test/wpt/test-fileapi.js b/test/wpt/test-fileapi.js
new file mode 100644
index 000000000000..7c7f6bc136a8
--- /dev/null
+++ b/test/wpt/test-fileapi.js
@@ -0,0 +1,20 @@
+'use strict';
+
+require('../common');
+const { WPTRunner } = require('../common/wpt');
+
+// FileAPI/blob, FileAPI/file, and FileAPI/reading-data-section have their own
+// runners. These two tests live in the FileAPI root.
+const included = new Set([
+  'fileReader.any.js',
+  'FileReaderSync.worker.js',
+]);
+
+const runner = new WPTRunner('FileAPI');
+runner.setFlags(['--experimental-fileapi']);
+for (const spec of runner.specs) {
+  if (!included.has(spec.filename)) {
+    runner.specs.delete(spec);
+  }
+}
+runner.runJsTests();
diff --git a/test/wpt/test-filereader.js b/test/wpt/test-filereader.js
new file mode 100644
index 000000000000..678a315c1f3a
--- /dev/null
+++ b/test/wpt/test-filereader.js
@@ -0,0 +1,9 @@
+'use strict';
+
+require('../common');
+const { WPTRunner } = require('../common/wpt');
+
+const runner = new WPTRunner('FileAPI/reading-data-section');
+runner.setFlags(['--experimental-fileapi']);
+
+runner.runJsTests();
diff --git a/test/wpt/test-workers.js b/test/wpt/test-workers.js
index 21ec86057b6e..d1595a716846 100644
--- a/test/wpt/test-workers.js
+++ b/test/wpt/test-workers.js
@@ -5,5 +5,6 @@ const { WPTRunner } = require('../common/wpt');
 
 const runner = new WPTRunner('workers');
 
+runner.setFlags(['--experimental-fileapi']);
 runner.pretendGlobalThisAs('Window');
 runner.runJsTests();