diff --git a/include/ipmid/handler.hpp b/include/ipmid/handler.hpp
index 27ce370..229b0cf 100644
--- a/include/ipmid/handler.hpp
+++ b/include/ipmid/handler.hpp
@@ -107,6 +107,8 @@
   public:
     using ptr = std::shared_ptr<HandlerBase>;
 
+    virtual ~HandlerBase() = default;
+
     /** @brief wrap the call to the registered handler with the request
      *
      * This is called from the running queue context after it has already
