diff --git a/lib/Server.js b/lib/Server.js
index cb7da1a6de..b82789eaae 100644
--- a/lib/Server.js
+++ b/lib/Server.js
@@ -311,6 +311,8 @@ const DEFAULT_ALLOWED_PROTOCOLS = /^(file|.+-extension):/i;
  * @property {typeof useFn} use
  */
 
+const pluginName = "webpack-dev-server";
+
 /**
  * @template {BasicApplication} [A=ExpressApplication]
  * @template {BasicServer} [S=HTTPServer]
@@ -326,11 +328,14 @@ class Server {
       baseDataPath: "options",
     });
 
-    this.compiler = compiler;
-    /**
-     * @type {ReturnType<Compiler["getInfrastructureLogger"]>}
-     */
-    this.logger = this.compiler.getInfrastructureLogger("webpack-dev-server");
+    if (compiler) {
+      this.compiler = compiler;
+
+      /**
+       * @type {ReturnType<Compiler["getInfrastructureLogger"]>}
+       */
+      this.logger = this.compiler.getInfrastructureLogger(pluginName);
+    }
     this.options = options;
     /**
      * @type {FSWatcher[]}
@@ -357,6 +362,11 @@ class Server {
      */
 
     this.currentHash = undefined;
+    /**
+     * @private
+     * @type {boolean}
+     */
+    this.isPlugin = false;
   }
 
   static get schema() {
@@ -1587,6 +1597,9 @@ class Server {
    * @returns {void}
    */
   setupProgressPlugin() {
+    // In the case where there is no compiler and it’s not being used as a plugin.
+    if (this.compiler === undefined) return;
+
     const { ProgressPlugin } =
       /** @type {MultiCompiler} */
       (this.compiler).compilers
@@ -1631,6 +1644,7 @@ class Server {
    * @returns {Promise<void>}
    */
   async initialize() {
+    if (this.compiler === undefined) return;
     this.setupHooks();
 
     await this.setupApp();
@@ -1706,7 +1720,7 @@ class Server {
           needForceShutdown = true;
 
           this.stopCallback(() => {
-            if (typeof this.compiler.close === "function") {
+            if (typeof this.compiler?.close === "function") {
               this.compiler.close(() => {
                 // eslint-disable-next-line n/no-process-exit
                 process.exit();
@@ -1781,11 +1795,14 @@ class Server {
    * @returns {void}
    */
   setupHooks() {
+    if (this.compiler === undefined) return;
+
     this.compiler.hooks.invalid.tap("webpack-dev-server", () => {
       if (this.webSocketServer) {
         this.sendMessage(this.webSocketServer.clients, "invalid");
       }
     });
+
     this.compiler.hooks.done.tap(
       "webpack-dev-server",
       /**
@@ -1840,6 +1857,7 @@ class Server {
    * @returns {void}
    */
   setupMiddlewares() {
+    if (this.compiler === undefined) return;
     /**
      * @type {Array<Middleware>}
      */
@@ -2346,8 +2364,10 @@ class Server {
         // middleware for serving webpack bundle
         /** @type {import("webpack-dev-middleware").API<Request, Response>} */
         this.middleware = webpackDevMiddleware(
+          // @ts-expect-error
           this.compiler,
           this.options.devMiddleware,
+          this.isPlugin,
         );
       }
 
@@ -3414,6 +3434,30 @@ class Server {
       .then(() => callback(), callback)
       .catch(callback);
   }
+
+  /**
+   * @param {Compiler} compiler compiler
+   * @returns {void}
+   */
+  apply(compiler) {
+    this.compiler = compiler;
+    this.isPlugin = true;
+    this.logger = this.compiler.getInfrastructureLogger(pluginName);
+
+    let started = false;
+
+    this.compiler.hooks.watchRun.tapPromise(pluginName, async () => {
+      if (!started) {
+        started = true;
+        await this.start();
+      }
+    });
+
+    this.compiler.hooks.shutdown.tapPromise(pluginName, async () => {
+      started = false;
+      await this.stop();
+    });
+  }
 }
 
 module.exports = Server;
diff --git a/test/e2e/__snapshots__/api.test.js.snap.webpack5 b/test/e2e/__snapshots__/api.test.js.snap.webpack5
index 14c74e33ea..7c143f91c9 100644
--- a/test/e2e/__snapshots__/api.test.js.snap.webpack5
+++ b/test/e2e/__snapshots__/api.test.js.snap.webpack5
@@ -165,3 +165,13 @@ exports[`API latest async API should work with callback API: console messages 1`
 `;
 
 exports[`API latest async API should work with callback API: page errors 1`] = `[]`;
+
+exports[`API should work with plugin API: console messages 1`] = `
+[
+  "[webpack-dev-server] Server started: Hot Module Replacement enabled, Live Reloading enabled, Progress disabled, Overlay enabled.",
+  "[HMR] Waiting for update signal from WDS...",
+  "Hey.",
+]
+`;
+
+exports[`API should work with plugin API: page errors 1`] = `[]`;
diff --git a/test/e2e/__snapshots__/logging.test.js.snap.webpack5 b/test/e2e/__snapshots__/logging.test.js.snap.webpack5
index 4c8cc479f7..f9d55c0f6c 100644
--- a/test/e2e/__snapshots__/logging.test.js.snap.webpack5
+++ b/test/e2e/__snapshots__/logging.test.js.snap.webpack5
@@ -1,5 +1,55 @@
 // Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
 
+exports[`logging plugin mode should work and do not log messages about hot and live reloading is enabled 1`] = `
+[
+  "[webpack-dev-server] Server started: Hot Module Replacement disabled, Live Reloading disabled, Progress disabled, Overlay enabled.",
+  "Hey.",
+]
+`;
+
+exports[`logging plugin mode should work and log errors by default 1`] = `
+[
+  "[webpack-dev-server] Server started: Hot Module Replacement enabled, Live Reloading enabled, Progress disabled, Overlay enabled.",
+  "[HMR] Waiting for update signal from WDS...",
+  "Hey.",
+  "[webpack-dev-server] Errors while compiling. Reload prevented.",
+  "[webpack-dev-server] ERROR
+Error from compilation",
+]
+`;
+
+exports[`logging plugin mode should work and log message about live reloading is enabled 1`] = `
+[
+  "[webpack-dev-server] Server started: Hot Module Replacement disabled, Live Reloading enabled, Progress disabled, Overlay enabled.",
+  "Hey.",
+]
+`;
+
+exports[`logging plugin mode should work and log messages about hot and live reloading is enabled 1`] = `
+[
+  "[webpack-dev-server] Server started: Hot Module Replacement enabled, Live Reloading enabled, Progress disabled, Overlay enabled.",
+  "[HMR] Waiting for update signal from WDS...",
+  "Hey.",
+]
+`;
+
+exports[`logging plugin mode should work and log warnings by default 1`] = `
+[
+  "[webpack-dev-server] Server started: Hot Module Replacement enabled, Live Reloading enabled, Progress disabled, Overlay enabled.",
+  "[HMR] Waiting for update signal from WDS...",
+  "Hey.",
+  "[webpack-dev-server] Warnings while compiling.",
+  "[webpack-dev-server] WARNING
+Warning from compilation",
+]
+`;
+
+exports[`logging plugin mode should work when the "client.logging" is "none" 1`] = `
+[
+  "Hey.",
+]
+`;
+
 exports[`logging should work and do not log messages about hot and live reloading is enabled (ws) 1`] = `
 [
   "[webpack-dev-server] Server started: Hot Module Replacement disabled, Live Reloading disabled, Progress disabled, Overlay enabled.",
diff --git a/test/e2e/api.test.js b/test/e2e/api.test.js
index ee09842d04..56543611d0 100644
--- a/test/e2e/api.test.js
+++ b/test/e2e/api.test.js
@@ -4,11 +4,94 @@ const path = require("node:path");
 const webpack = require("webpack");
 const Server = require("../../lib/Server");
 const config = require("../fixtures/client-config/webpack.config");
+const compile = require("../helpers/compile");
 const runBrowser = require("../helpers/run-browser");
 const sessionSubscribe = require("../helpers/session-subscribe");
 const port = require("../ports-map").api;
 
 describe("API", () => {
+  it("should work with plugin API", async () => {
+    const compiler = webpack(config);
+    const server = new Server({ port });
+
+    server.apply(compiler);
+
+    await compile(compiler, port);
+
+    const { page, browser } = await runBrowser();
+
+    const pageErrors = [];
+    const consoleMessages = [];
+
+    page
+      .on("console", (message) => {
+        consoleMessages.push(message);
+      })
+      .on("pageerror", (error) => {
+        pageErrors.push(error);
+      });
+
+    await page.goto(`http://127.0.0.1:${port}/`, {
+      waitUntil: "networkidle0",
+    });
+
+    expect(consoleMessages.map((message) => message.text())).toMatchSnapshot(
+      "console messages",
+    );
+    expect(pageErrors).toMatchSnapshot("page errors");
+
+    await browser.close();
+    await new Promise((resolve) => {
+      compiler.close(resolve);
+    });
+  });
+
+  it("should not start the server multiple times on recompilation", async () => {
+    const compiler = webpack(config);
+    const server = new Server({ port });
+    const startSpy = jest.spyOn(server, "start");
+
+    server.apply(compiler);
+
+    const { watching } = await compile(compiler, port);
+
+    // Trigger a recompilation by invalidating
+    await new Promise((resolve) => {
+      watching.invalidate(() => {
+        resolve();
+      });
+    });
+
+    // Wait for the recompilation to finish
+    await new Promise((resolve) => {
+      setTimeout(resolve, 2000);
+    });
+
+    expect(startSpy).toHaveBeenCalledTimes(1);
+
+    startSpy.mockRestore();
+    await new Promise((resolve) => {
+      compiler.close(resolve);
+    });
+  });
+
+  it("should stop the server cleanly via compiler.close()", async () => {
+    const compiler = webpack(config);
+    const server = new Server({ port });
+    const stopSpy = jest.spyOn(server, "stop");
+
+    server.apply(compiler);
+
+    await compile(compiler, port);
+
+    await new Promise((resolve) => {
+      compiler.close(resolve);
+    });
+
+    expect(stopSpy).toHaveBeenCalledTimes(1);
+    stopSpy.mockRestore();
+  });
+
   describe("WEBPACK_SERVE environment variable", () => {
     const OLD_ENV = process.env;
     let server;
diff --git a/test/e2e/logging.test.js b/test/e2e/logging.test.js
index 9ba530ba3d..aed449463f 100644
--- a/test/e2e/logging.test.js
+++ b/test/e2e/logging.test.js
@@ -5,6 +5,7 @@ const fs = require("graceful-fs");
 const webpack = require("webpack");
 const Server = require("../../lib/Server");
 const config = require("../fixtures/client-config/webpack.config");
+const compile = require("../helpers/compile");
 const HTMLGeneratorPlugin = require("../helpers/html-generator-plugin");
 const runBrowser = require("../helpers/run-browser");
 const port = require("../ports-map").logging;
@@ -241,4 +242,124 @@ describe("logging", () => {
       });
     }
   }
+
+  describe("plugin mode", () => {
+    const pluginCases = [
+      {
+        title:
+          "should work and log messages about hot and live reloading is enabled",
+        devServerOptions: {
+          hot: true,
+        },
+      },
+      {
+        title: "should work and log message about live reloading is enabled",
+        devServerOptions: {
+          hot: false,
+        },
+      },
+      {
+        title:
+          "should work and do not log messages about hot and live reloading is enabled",
+        devServerOptions: {
+          liveReload: false,
+          hot: false,
+        },
+      },
+      {
+        title: "should work and log warnings by default",
+        webpackOptions: {
+          plugins: [
+            {
+              apply(compiler) {
+                compiler.hooks.thisCompilation.tap(
+                  "warnings-webpack-plugin",
+                  (compilation) => {
+                    compilation.warnings.push(
+                      new Error("Warning from compilation"),
+                    );
+                  },
+                );
+              },
+            },
+            new HTMLGeneratorPlugin(),
+          ],
+        },
+      },
+      {
+        title: "should work and log errors by default",
+        webpackOptions: {
+          plugins: [
+            {
+              apply(compiler) {
+                compiler.hooks.thisCompilation.tap(
+                  "warnings-webpack-plugin",
+                  (compilation) => {
+                    compilation.errors.push(
+                      new Error("Error from compilation"),
+                    );
+                  },
+                );
+              },
+            },
+            new HTMLGeneratorPlugin(),
+          ],
+        },
+      },
+      {
+        title: 'should work when the "client.logging" is "none"',
+        devServerOptions: {
+          client: {
+            logging: "none",
+          },
+        },
+      },
+    ];
+
+    for (const testCase of pluginCases) {
+      it(`${testCase.title}`, async () => {
+        const compiler = webpack({ ...config, ...testCase.webpackOptions });
+        const devServerOptions = {
+          port,
+          ...testCase.devServerOptions,
+        };
+        const server = new Server(devServerOptions);
+
+        server.apply(compiler);
+
+        await compile(compiler, port);
+
+        const { page, browser } = await runBrowser();
+
+        try {
+          const consoleMessages = [];
+
+          page.on("console", (message) => {
+            consoleMessages.push(message);
+          });
+
+          await page.goto(`http://127.0.0.1:${port}/`, {
+            waitUntil: "networkidle0",
+          });
+
+          expect(
+            consoleMessages.map((message) =>
+              message
+                .text()
+                .replaceAll("\\", "/")
+                .replaceAll(
+                  new RegExp(process.cwd().replaceAll("\\", "/"), "g"),
+                  "<cwd>",
+                ),
+            ),
+          ).toMatchSnapshot();
+        } finally {
+          await browser.close();
+          await new Promise((resolve) => {
+            compiler.close(resolve);
+          });
+        }
+      });
+    }
+  });
 });
diff --git a/test/helpers/compile.js b/test/helpers/compile.js
new file mode 100644
index 0000000000..36f1c480c9
--- /dev/null
+++ b/test/helpers/compile.js
@@ -0,0 +1,44 @@
+"use strict";
+
+// Helper function to check if server is ready using fetch
+const waitForServer = async (port, timeout = 10000) => {
+  const start = Date.now();
+
+  while (Date.now() - start < timeout) {
+    try {
+      // eslint-disable-next-line n/no-unsupported-features/node-builtins
+      await fetch(`http://127.0.0.1:${port}/`);
+      return; // Server is ready
+    } catch {
+      // Server not ready yet, wait and retry
+      await new Promise((resolve) => {
+        setTimeout(resolve, 100);
+      });
+    }
+  }
+
+  throw new Error(`Server on port ${port} not ready after ${timeout}ms`);
+};
+
+module.exports = (compiler, port = null) =>
+  new Promise((resolve, reject) => {
+    const watching = compiler.watch({}, async (error, stats) => {
+      if (error) {
+        watching.close();
+        return reject(error);
+      }
+
+      // If a port is provided, wait for the server to be ready
+      if (port) {
+        try {
+          await waitForServer(port);
+        } catch (err) {
+          watching.close();
+          return reject(err);
+        }
+      }
+
+      // Return both stats and watching for caller to manage
+      resolve({ stats, watching });
+    });
+  });
diff --git a/types/lib/Server.d.ts b/types/lib/Server.d.ts
index dd895e2e3c..b7d842dd21 100644
--- a/types/lib/Server.d.ts
+++ b/types/lib/Server.d.ts
@@ -1,8 +1,4 @@
 export = Server;
-/**
- * @typedef {object} BasicApplication
- * @property {typeof useFn} use
- */
 /**
  * @template {BasicApplication} [A=ExpressApplication]
  * @template {BasicServer} [S=HTTPServer]
@@ -1167,7 +1163,10 @@ declare class Server<
    * @param {Compiler | MultiCompiler} compiler compiler
    */
   constructor(options: Configuration<A, S>, compiler: Compiler | MultiCompiler);
-  compiler: import("webpack").Compiler | import("webpack").MultiCompiler;
+  compiler:
+    | import("webpack").Compiler
+    | import("webpack").MultiCompiler
+    | undefined;
   /**
    * @type {ReturnType<Compiler["getInfrastructureLogger"]>}
    */
@@ -1196,6 +1195,11 @@ declare class Server<
    * @type {string | undefined}
    */
   private currentHash;
+  /**
+   * @private
+   * @type {boolean}
+   */
+  private isPlugin;
   /**
    * @private
    * @param {Compiler} compiler compiler
@@ -1409,6 +1413,11 @@ declare class Server<
    * @param {((err?: Error) => void)=} callback callback
    */
   stopCallback(callback?: ((err?: Error) => void) | undefined): void;
+  /**
+   * @param {Compiler} compiler compiler
+   * @returns {void}
+   */
+  apply(compiler: Compiler): void;
   #private;
 }
 declare namespace Server {