diff --git a/package-lock.json b/package-lock.json
index 3beabd3..6d8f388 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "jsmodbus",
-  "version": "5.0.0",
+  "version": "5.0.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "jsmodbus",
-      "version": "5.0.0",
+      "version": "5.0.1",
       "license": "MIT",
       "dependencies": {
         "commander": "^11.1.0",
diff --git a/package.json b/package.json
index a992265..5e93f4f 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "jsmodbus",
-  "version": "5.0.0",
+  "version": "5.0.1",
   "description": "Implementation for the Serial/TCP Modbus protocol.",
   "author": "Stefan Poeter <stefan.poeter@cloud-automation.de>",
   "main": "./dist/modbus.js",
diff --git a/src/client-response-handler.ts b/src/client-response-handler.ts
index 1225cb4..5488aa3 100644
--- a/src/client-response-handler.ts
+++ b/src/client-response-handler.ts
@@ -1,4 +1,6 @@
 import MBAbstractResponse from './abstract-response'
+import IResponseBodyHandler from './response/response-body-handler.js'
+import ResponseFactory from './response/response-factory.js'
 
 /** Modbus Client Repsonse Handler
  * @abstract
@@ -6,6 +8,7 @@ import MBAbstractResponse from './abstract-response'
 export default abstract class ModbusClientResponseHandler<ResType extends MBAbstractResponse = MBAbstractResponse> {
   protected _buffer: Buffer
   protected abstract _messages: ResType[]
+  protected readonly _customHandlers = new Map<number, IResponseBodyHandler>()
 
   /** Create new Modbus Client Response Handler */
   constructor () {
@@ -23,4 +26,38 @@ export default abstract class ModbusClientResponseHandler<ResType extends MBAbst
   public shift () {
     return this._messages.shift()
   }
+
+  /** Drop whatever is left in the receive buffer.
+   * @returns {number} The number of discarded bytes.
+   */
+  public discardBuffer (): number {
+    const discarded = this._buffer.length
+    this._buffer = Buffer.alloc(0)
+    return discarded
+  }
+
+  /** Parse responses of a function code with a custom handler instead of the built-in one. */
+  public registerResponseHandler (fc: number, handler: IResponseBodyHandler) {
+    this._customHandlers.set(fc, handler)
+  }
+
+  /** Go back to the built-in parser for a function code. Returns true if a custom handler was removed. */
+  public unregisterResponseHandler (fc: number) {
+    return this._customHandlers.delete(fc)
+  }
+
+  /** Parse a response body with the custom handler of its function code, if there is one. */
+  protected _parseBody = (buffer: Buffer) => {
+    const handler = this._customHandlers.get(buffer[0])
+
+    if (!handler) {
+      return ResponseFactory.fromBuffer(buffer)
+    }
+
+    try {
+      return handler.fromBuffer(buffer)
+    } catch (e) {
+      return null
+    }
+  }
 }
diff --git a/src/modbus-client.ts b/src/modbus-client.ts
index 9208e78..aec2c4a 100644
--- a/src/modbus-client.ts
+++ b/src/modbus-client.ts
@@ -22,6 +22,7 @@ import MBClientResponseHandler from './client-response-handler.js'
 import { UserRequestError } from './errors'
 import { CastRequestBody } from './request-response-map'
 import { WriteMultipleCoilsResponseBody } from './response'
+import IResponseBodyHandler from './response/response-body-handler.js'
 import { PromiseUserRequest } from './user-request.js'
 
 /** Common Modbus Client
@@ -342,6 +343,32 @@ export default abstract class MBClient<S extends Stream.Duplex, Req extends Modb
     return this._requestHandler.customErrorRequest(err)
   }
 
+  /** Drop whatever is left in the receive buffer, e.g. the rest of a response whose request
+   * timed out.
+   * @returns {number} The number of discarded bytes.
+   */
+  public discardResponseBuffer (): number {
+    return this._responseHandler.discardBuffer()
+  }
+
+  /** Parse responses of a function code with a custom handler instead of the built-in one.
+   * The returned body is matched against the pending request as usual, so it has to carry
+   * the function code of the request (or be an exception response).
+   * @param {number} fc Function code
+   * @param {IResponseBodyHandler} handler Object with a fromBuffer (buffer) method.
+   */
+  public registerResponseHandler (fc: number, handler: IResponseBodyHandler) {
+    this._responseHandler.registerResponseHandler(fc, handler)
+  }
+
+  /** Remove a custom response handler and go back to the built-in parser.
+   * @param {number} fc Function code
+   * @returns {boolean} true if a custom handler was removed.
+   */
+  public unregisterResponseHandler (fc: number) {
+    return this._responseHandler.unregisterResponseHandler(fc)
+  }
+
   private _onData (data: Buffer) {
     debug('received data')
 
diff --git a/src/modbus.ts b/src/modbus.ts
index 7be1d90..f6e0899 100644
--- a/src/modbus.ts
+++ b/src/modbus.ts
@@ -68,6 +68,7 @@ export { default as ModbusAbstractRequest } from './abstract-request'
 export { default as ModbusAbstractResponse } from './abstract-response'
 export { default as MBClientRequestHandler } from './client-request-handler'
 export { default as ModbusClientResponseHandler } from './client-response-handler'
+export { default as ResponseBodyHandler } from './response/response-body-handler'
 export { default as ModbusClient } from './modbus-client'
 export * from './request-response-map'
 export { default as ModbusTCPRequest } from './tcp-request'
diff --git a/src/response/response-body-handler.ts b/src/response/response-body-handler.ts
new file mode 100644
index 0000000..740de32
--- /dev/null
+++ b/src/response/response-body-handler.ts
@@ -0,0 +1,12 @@
+import ModbusResponseBody from './response-body.js'
+
+/** Parses the response body of a single function code. The built-in response body
+ * classes (e.g. ReadHoldingRegistersResponseBody) satisfy it through their static fromBuffer.
+ */
+export default interface IResponseBodyHandler<Body extends ModbusResponseBody = ModbusResponseBody> {
+  /** @param {Buffer} buffer Starts at the function code. With Modbus/RTU the returned body's
+   *   byteCount decides how many bytes are consumed before the CRC.
+   * @returns {ModbusResponseBody | null} null if not enough data has arrived yet.
+   */
+  fromBuffer (buffer: Buffer): Body | null
+}
diff --git a/src/rtu-client-response-handler.ts b/src/rtu-client-response-handler.ts
index 71fade0..3c21c28 100644
--- a/src/rtu-client-response-handler.ts
+++ b/src/rtu-client-response-handler.ts
@@ -21,7 +21,7 @@ export default class ModbusRTUClientResponseHandler extends ModbusClientResponse
     debug('buffer', this._buffer)
 
     do {
-      const response = ModbusRTUResponse.fromBuffer(this._buffer)
+      const response = ModbusRTUResponse.fromBuffer(this._buffer, this._parseBody)
 
       if (!response) {
         debug('not enough data available to parse')
diff --git a/src/rtu-response.ts b/src/rtu-response.ts
index c903738..060f22e 100644
--- a/src/rtu-response.ts
+++ b/src/rtu-response.ts
@@ -49,7 +49,10 @@ export default class ModbusRTUResponse<ResBody extends ModbusResponseBody = Modb
       modbusBody)
   }
 
-  public static fromBuffer (buffer: Buffer) {
+  public static fromBuffer (
+    buffer: Buffer,
+    parseBody: (body: Buffer) => ModbusResponseBody | null = ResponseFactory.fromBuffer
+  ) {
     if (buffer.length < 1) {
       return null
     }
@@ -58,7 +61,7 @@ export default class ModbusRTUResponse<ResBody extends ModbusResponseBody = Modb
 
     debug('address', address, 'buffer', buffer)
 
-    const body = ResponseFactory.fromBuffer(buffer.slice(1))
+    const body = parseBody(buffer.slice(1))
 
     if (!body) {
       return null
diff --git a/src/tcp-client-response-handler.ts b/src/tcp-client-response-handler.ts
index a499870..295a936 100644
--- a/src/tcp-client-response-handler.ts
+++ b/src/tcp-client-response-handler.ts
@@ -23,7 +23,7 @@ export default class ModbusTCPClientResponseHandler extends ModbusClientResponse
     debug('buffer', this._buffer)
 
     do {
-      const response = ModbusTCPResponse.fromBuffer(this._buffer)
+      const response = ModbusTCPResponse.fromBuffer(this._buffer, this._parseBody)
 
       if (!response) {
         debug('not enough data available to parse')
diff --git a/src/tcp-response.ts b/src/tcp-response.ts
index 8fbb8c1..3f7adf7 100644
--- a/src/tcp-response.ts
+++ b/src/tcp-response.ts
@@ -70,7 +70,10 @@ export default class ModbusTCPResponse<ResBody extends ModbusResponseBody = Modb
    * @param {Buffer} buffer
    * @returns {ModbusTCPResponse} Returns null if not enough data located in the buffer.
    */
-  public static fromBuffer (buffer: Buffer) {
+  public static fromBuffer (
+    buffer: Buffer,
+    parseBody: (body: Buffer) => ModbusResponseBody | null = ResponseFactory.fromBuffer
+  ) {
     try {
       const id = buffer.readUInt16BE(0)
       const protocol = buffer.readUInt16BE(2)
@@ -80,7 +83,7 @@ export default class ModbusTCPResponse<ResBody extends ModbusResponseBody = Modb
       debug('tcp header complete, id', id, 'protocol', protocol, 'length', length, 'unitId', unitId)
       debug('buffer', buffer)
 
-      const body = ResponseFactory.fromBuffer(buffer.slice(7, 7 + length - 1))
+      const body = parseBody(buffer.slice(7, 7 + length - 1))
 
       if (!body) {
         debug('not enough data for a response body')
diff --git a/test/custom-response-handler.test.js b/test/custom-response-handler.test.js
new file mode 100644
index 0000000..2d4a6f5
--- /dev/null
+++ b/test/custom-response-handler.test.js
@@ -0,0 +1,208 @@
+'use strict'
+
+/* global describe, it, beforeEach */
+
+const assert = require('assert')
+const EventEmitter = require('events')
+const Modbus = require('../')
+
+const ModbusRTUClientResponseHandler = require('../dist/rtu-client-response-handler.js').default
+const ModbusTCPClientResponseHandler = require('../dist/tcp-client-response-handler.js').default
+
+const { ReadHoldingRegistersResponseBody } = Modbus.responses
+
+/* Parses a read holding registers response that always carries a single register,
+ * whatever the byte count field says. */
+const singleRegisterHandler = {
+  calls: 0,
+  fromBuffer (buffer) {
+    this.calls++
+    if (buffer.length < 4) {
+      return null
+    }
+    const payload = buffer.slice(2, 4)
+    return new ReadHoldingRegistersResponseBody(2, [payload.readUInt16BE(0)], payload)
+  }
+}
+
+describe('Custom Response Handler Tests.', function () {
+  beforeEach(function () {
+    singleRegisterHandler.calls = 0
+  })
+
+  describe('Modbus/RTU Client Response Handler.', function () {
+    let handler
+
+    beforeEach(function () {
+      handler = new ModbusRTUClientResponseHandler()
+    })
+
+    it('should consume as many bytes as the custom body reports', function () {
+      handler.registerResponseHandler(0x03, singleRegisterHandler)
+
+      handler.handleData(Buffer.from([
+        0x01, // address
+        0x03, // function code
+        0xff, // broken byte count
+        0x12, 0x34, // register
+        0xcd, 0xab, // crc
+        0x01, // address of the next response
+        0x03, 0x02, 0x56, 0x78, 0x34, 0x12
+      ]))
+
+      const first = handler.shift()
+      const second = handler.shift()
+
+      assert.deepEqual([0x1234], first.body.valuesAsArray)
+      assert.equal(0xabcd, first.crc)
+      assert.deepEqual([0x5678], second.body.valuesAsArray)
+      assert.equal(0x1234, second.crc)
+      assert.strictEqual(undefined, handler.shift())
+    })
+
+    it('should wait for more data while the custom handler returns null', function () {
+      handler.registerResponseHandler(0x03, singleRegisterHandler)
+
+      handler.handleData(Buffer.from([0x01, 0x03, 0xff, 0x12]))
+      assert.strictEqual(undefined, handler.shift())
+
+      handler.handleData(Buffer.from([0x34, 0xcd, 0xab]))
+      assert.deepEqual([0x1234], handler.shift().body.valuesAsArray)
+    })
+
+    it('should leave other function codes to the built-in parser', function () {
+      handler.registerResponseHandler(0x03, singleRegisterHandler)
+
+      handler.handleData(Buffer.from([0x01, 0x01, 0x01, 0x01, 0xcd, 0xab]))
+
+      assert.equal(0, singleRegisterHandler.calls)
+      assert.equal(0x01, handler.shift().body.fc)
+    })
+
+    it('should use the built-in parser after unregistering', function () {
+      handler.registerResponseHandler(0x03, singleRegisterHandler)
+
+      assert.equal(true, handler.unregisterResponseHandler(0x03))
+      assert.equal(false, handler.unregisterResponseHandler(0x03))
+
+      handler.handleData(Buffer.from([0x01, 0x03, 0x04, 0x12, 0x34, 0x56, 0x78, 0xcd, 0xab]))
+
+      assert.equal(0, singleRegisterHandler.calls)
+      assert.deepEqual([0x1234, 0x5678], handler.shift().body.valuesAsArray)
+    })
+
+    it('should treat a throwing handler like an incomplete response', function () {
+      handler.registerResponseHandler(0x03, { fromBuffer: () => { throw new Error('boom') } })
+
+      handler.handleData(Buffer.from([0x01, 0x03, 0x02, 0x12, 0x34, 0xcd, 0xab]))
+
+      assert.strictEqual(undefined, handler.shift())
+    })
+  })
+
+  describe('Modbus/TCP Client Response Handler.', function () {
+    it('should pass exactly the PDU to the custom handler', function () {
+      const handler = new ModbusTCPClientResponseHandler()
+      let received
+
+      handler.registerResponseHandler(0x03, {
+        fromBuffer (buffer) {
+          received = buffer
+          return singleRegisterHandler.fromBuffer(buffer)
+        }
+      })
+
+      handler.handleData(Buffer.from([
+        0x00, 0x01, // transaction id
+        0x00, 0x00, // protocol
+        0x00, 0x05, // length
+        0x01, // unit id
+        0x03, 0xff, 0x12, 0x34 // pdu with broken byte count
+      ]))
+
+      assert.deepEqual(Buffer.from([0x03, 0xff, 0x12, 0x34]), received)
+      assert.deepEqual([0x1234], handler.shift().body.valuesAsArray)
+    })
+  })
+
+  describe('Modbus Client.', function () {
+    let socket
+
+    beforeEach(function () {
+      socket = new EventEmitter()
+      socket.write = function () {}
+    })
+
+    it('should resolve the request with the body of the custom handler', function (done) {
+      const client = new Modbus.client.TCP(socket)
+      client.registerResponseHandler(0x03, singleRegisterHandler)
+
+      socket.emit('connect')
+
+      client.readHoldingRegisters(0, 1)
+        .then(function (resp) {
+          assert.equal(1, singleRegisterHandler.calls)
+          assert.deepEqual([0x1234], resp.response.body.valuesAsArray)
+          done()
+        }).catch(done)
+
+      socket.emit('data', Buffer.from([
+        0x00, 0x01, // transaction id
+        0x00, 0x00, // protocol
+        0x00, 0x05, // length
+        0x01, // unit id
+        0x03, 0xff, 0x12, 0x34
+      ]))
+    })
+
+    it('should parse the next response after discarding a truncated one', function (done) {
+      const client = new Modbus.client.TCP(socket)
+
+      socket.emit('connect')
+
+      /* the rest of a frame whose request was given up on */
+      socket.emit('data', Buffer.from([0x00, 0x07, 0x00, 0x00, 0x00, 0x05]))
+      assert.equal(6, client.discardResponseBuffer())
+      assert.equal(0, client.discardResponseBuffer())
+
+      client.readHoldingRegisters(0, 1)
+        .then(function (resp) {
+          assert.deepEqual([0x1234], resp.response.body.valuesAsArray)
+          done()
+        }).catch(done)
+
+      socket.emit('data', Buffer.from([
+        0x00, 0x01, 0x00, 0x00, 0x00, 0x05, 0x01,
+        0x03, 0x02, 0x12, 0x34
+      ]))
+    })
+
+    it('should unregister a custom handler on the client', function () {
+      const client = new Modbus.client.RTU(new EventEmitter(), 1)
+      client.registerResponseHandler(0x03, singleRegisterHandler)
+
+      assert.equal(true, client.unregisterResponseHandler(0x03))
+      assert.equal(false, client.unregisterResponseHandler(0x03))
+    })
+
+    it('should keep custom handlers per client', function (done) {
+      const otherClient = new Modbus.client.TCP(new EventEmitter())
+      const client = new Modbus.client.TCP(socket)
+      otherClient.registerResponseHandler(0x03, singleRegisterHandler)
+
+      socket.emit('connect')
+
+      client.readHoldingRegisters(0, 1)
+        .then(function (resp) {
+          assert.equal(0, singleRegisterHandler.calls)
+          assert.deepEqual([0x1234], resp.response.body.valuesAsArray)
+          done()
+        }).catch(done)
+
+      socket.emit('data', Buffer.from([
+        0x00, 0x01, 0x00, 0x00, 0x00, 0x05, 0x01,
+        0x03, 0x02, 0x12, 0x34
+      ]))
+    })
+  })
+})