diff --git a/nbclient/client.py b/nbclient/client.py
index 6d2caf9b..0c9577c3 100644
--- a/nbclient/client.py
+++ b/nbclient/client.py
@@ -24,6 +24,7 @@
 )
 from .util import run_sync, ensure_async
 from .output_widget import OutputWidget
+from .matplotlib import MatplotlibCommHandler
 
 
 def timestamp():
@@ -293,7 +294,8 @@ def __init__(self, nb, km=None, **kw):
         }
         # comm_open_handlers should return an object with a .handle_msg(msg) method or None
         self.comm_open_handlers = {
-            'jupyter.widget': self.on_comm_open_jupyter_widget
+            'jupyter.widget': self.on_comm_open_jupyter_widget,
+            'matplotlib': self.on_comm_open_matplotlib
         }
 
     def reset_execution_trackers(self):
@@ -914,6 +916,12 @@ def on_comm_open_jupyter_widget(self, msg):
             if widget_class:
                 return widget_class(comm_id, state, self.kc, self)
 
+    def on_comm_open_matplotlib(self, msg):
+        content = msg['content']
+        data = content['data']
+        return MatplotlibCommHandler(comm_id=content['comm_id'], kernel_client=self.kc,
+                                     parent_header=msg['parent_header'], nbagg_id=data['id'])
+
 
 def execute(nb, cwd=None, km=None, **kwargs):
     """Execute a notebook's code, updating outputs within the notebook object.
diff --git a/nbclient/matplotlib.py b/nbclient/matplotlib.py
new file mode 100644
index 00000000..543d19ca
--- /dev/null
+++ b/nbclient/matplotlib.py
@@ -0,0 +1,47 @@
+import json
+
+from .jsonutil import json_clean
+
+
+class MatplotlibCommHandler:
+    def __init__(self, comm_id, kernel_client, parent_header, nbagg_id):
+        self.comm_id = comm_id
+        self.kernel_client = kernel_client
+        self.parent_header = parent_header
+        self.nbagg_id = nbagg_id
+
+        # mimics https://github.com/matplotlib/matplotlib/blob/002b27e352b90410c9840233b6ce42c54e291403/lib/matplotlib/backends/web_backend/js/mpl.js#L63  # noqa
+        self.send('{"value":false,"type":"supports_binary","figure_id":"%s"}' % nbagg_id)
+        self.send('{"type":"send_image_mode","figure_id":"%s"}' % nbagg_id)
+        self.send('{"dpi_ratio":2,"type":"set_dpi_ratio","figure_id":"%s"}' % nbagg_id)
+        self.send('{"type":"refresh","figure_id":"%s"}' % nbagg_id)
+
+    def _publish_msg(self, msg_type, data=None, metadata=None, buffers=None, **keys):
+        """Helper for sending a comm message on IOPub"""
+        data = {} if data is None else data
+        metadata = {} if metadata is None else metadata
+        content = json_clean(dict(data=data, comm_id=self.comm_id, **keys))
+        # it seems from looking at the websocket output in Chrome, that parent header
+        # is always empty
+        msg = self.kernel_client.session.msg(msg_type, content=content, parent={},
+                                             metadata=metadata)
+        print("SEND", msg)
+        self.kernel_client.shell_channel.send(msg)
+
+    def send(self, data=None, metadata=None, buffers=None):
+        self._publish_msg('comm_msg', data=data, metadata=metadata, buffers=buffers)
+
+    def handle_msg(self, msg):
+        print("RECV", msg)
+        content = msg['content']
+        data = content['data']
+        nbagg_data = data.get('data')
+        if nbagg_data:
+            nbagg_data = json.loads(nbagg_data)
+            print(nbagg_data)
+            if nbagg_data.get('type') == 'refresh':
+                # cannot figure out when we should send this
+                self.send('{"type":"refresh","figure_id":"%s"}' % self.nbagg_id)
+            if nbagg_data.get('type') == 'resize':
+                # mimics https://github.com/matplotlib/matplotlib/blob/002b27e352b90410c9840233b6ce42c54e291403/lib/matplotlib/backends/web_backend/js/mpl.js#L354  # noqa
+                self.send('{"type":"draw","figure_id":"%s"}' % self.nbagg_id)
diff --git a/nbclient/tests/files/Matplotlib.ipynb b/nbclient/tests/files/Matplotlib.ipynb
new file mode 100644
index 00000000..b1d67a93
--- /dev/null
+++ b/nbclient/tests/files/Matplotlib.ipynb
@@ -0,0 +1,852 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2020-05-29T11:54:44.726585Z",
+     "start_time": "2020-05-29T11:54:44.408571Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "%matplotlib notebook\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2020-05-29T11:54:44.901749Z",
+     "start_time": "2020-05-29T11:54:44.839444Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/javascript": [
+       "/* Put everything inside the global mpl namespace */\n",
+       "window.mpl = {};\n",
+       "\n",
+       "\n",
+       "mpl.get_websocket_type = function() {\n",
+       "    if (typeof(WebSocket) !== 'undefined') {\n",
+       "        return WebSocket;\n",
+       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
+       "        return MozWebSocket;\n",
+       "    } else {\n",
+       "        alert('Your browser does not have WebSocket support. ' +\n",
+       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
+       "              'Firefox 4 and 5 are also supported but you ' +\n",
+       "              'have to enable WebSockets in about:config.');\n",
+       "    };\n",
+       "}\n",
+       "\n",
+       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
+       "    this.id = figure_id;\n",
+       "\n",
+       "    this.ws = websocket;\n",
+       "\n",
+       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
+       "\n",
+       "    if (!this.supports_binary) {\n",
+       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
+       "        if (warnings) {\n",
+       "            warnings.style.display = 'block';\n",
+       "            warnings.textContent = (\n",
+       "                \"This browser does not support binary websocket messages. \" +\n",
+       "                    \"Performance may be slow.\");\n",
+       "        }\n",
+       "    }\n",
+       "\n",
+       "    this.imageObj = new Image();\n",
+       "\n",
+       "    this.context = undefined;\n",
+       "    this.message = undefined;\n",
+       "    this.canvas = undefined;\n",
+       "    this.rubberband_canvas = undefined;\n",
+       "    this.rubberband_context = undefined;\n",
+       "    this.format_dropdown = undefined;\n",
+       "\n",
+       "    this.image_mode = 'full';\n",
+       "\n",
+       "    this.root = $('<div/>');\n",
+       "    this._root_extra_style(this.root)\n",
+       "    this.root.attr('style', 'display: inline-block');\n",
+       "\n",
+       "    $(parent_element).append(this.root);\n",
+       "\n",
+       "    this._init_header(this);\n",
+       "    this._init_canvas(this);\n",
+       "    this._init_toolbar(this);\n",
+       "\n",
+       "    var fig = this;\n",
+       "\n",
+       "    this.waiting = false;\n",
+       "\n",
+       "    this.ws.onopen =  function () {\n",
+       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
+       "            fig.send_message(\"send_image_mode\", {});\n",
+       "            if (mpl.ratio != 1) {\n",
+       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
+       "            }\n",
+       "            fig.send_message(\"refresh\", {});\n",
+       "        }\n",
+       "\n",
+       "    this.imageObj.onload = function() {\n",
+       "            if (fig.image_mode == 'full') {\n",
+       "                // Full images could contain transparency (where diff images\n",
+       "                // almost always do), so we need to clear the canvas so that\n",
+       "                // there is no ghosting.\n",
+       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
+       "            }\n",
+       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
+       "        };\n",
+       "\n",
+       "    this.imageObj.onunload = function() {\n",
+       "        fig.ws.close();\n",
+       "    }\n",
+       "\n",
+       "    this.ws.onmessage = this._make_on_message_function(this);\n",
+       "\n",
+       "    this.ondownload = ondownload;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_header = function() {\n",
+       "    var titlebar = $(\n",
+       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
+       "        'ui-helper-clearfix\"/>');\n",
+       "    var titletext = $(\n",
+       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
+       "        'text-align: center; padding: 3px;\"/>');\n",
+       "    titlebar.append(titletext)\n",
+       "    this.root.append(titlebar);\n",
+       "    this.header = titletext[0];\n",
+       "}\n",
+       "\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
+       "\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
+       "\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_canvas = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var canvas_div = $('<div/>');\n",
+       "\n",
+       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
+       "\n",
+       "    function canvas_keyboard_event(event) {\n",
+       "        return fig.key_event(event, event['data']);\n",
+       "    }\n",
+       "\n",
+       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
+       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
+       "    this.canvas_div = canvas_div\n",
+       "    this._canvas_extra_style(canvas_div)\n",
+       "    this.root.append(canvas_div);\n",
+       "\n",
+       "    var canvas = $('<canvas/>');\n",
+       "    canvas.addClass('mpl-canvas');\n",
+       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
+       "\n",
+       "    this.canvas = canvas[0];\n",
+       "    this.context = canvas[0].getContext(\"2d\");\n",
+       "\n",
+       "    var backingStore = this.context.backingStorePixelRatio ||\n",
+       "\tthis.context.webkitBackingStorePixelRatio ||\n",
+       "\tthis.context.mozBackingStorePixelRatio ||\n",
+       "\tthis.context.msBackingStorePixelRatio ||\n",
+       "\tthis.context.oBackingStorePixelRatio ||\n",
+       "\tthis.context.backingStorePixelRatio || 1;\n",
+       "\n",
+       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
+       "\n",
+       "    var rubberband = $('<canvas/>');\n",
+       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
+       "\n",
+       "    var pass_mouse_events = true;\n",
+       "\n",
+       "    canvas_div.resizable({\n",
+       "        start: function(event, ui) {\n",
+       "            pass_mouse_events = false;\n",
+       "        },\n",
+       "        resize: function(event, ui) {\n",
+       "            fig.request_resize(ui.size.width, ui.size.height);\n",
+       "        },\n",
+       "        stop: function(event, ui) {\n",
+       "            pass_mouse_events = true;\n",
+       "            fig.request_resize(ui.size.width, ui.size.height);\n",
+       "        },\n",
+       "    });\n",
+       "\n",
+       "    function mouse_event_fn(event) {\n",
+       "        if (pass_mouse_events)\n",
+       "            return fig.mouse_event(event, event['data']);\n",
+       "    }\n",
+       "\n",
+       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
+       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
+       "    // Throttle sequential mouse events to 1 every 20ms.\n",
+       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
+       "\n",
+       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
+       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
+       "\n",
+       "    canvas_div.on(\"wheel\", function (event) {\n",
+       "        event = event.originalEvent;\n",
+       "        event['data'] = 'scroll'\n",
+       "        if (event.deltaY < 0) {\n",
+       "            event.step = 1;\n",
+       "        } else {\n",
+       "            event.step = -1;\n",
+       "        }\n",
+       "        mouse_event_fn(event);\n",
+       "    });\n",
+       "\n",
+       "    canvas_div.append(canvas);\n",
+       "    canvas_div.append(rubberband);\n",
+       "\n",
+       "    this.rubberband = rubberband;\n",
+       "    this.rubberband_canvas = rubberband[0];\n",
+       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
+       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
+       "\n",
+       "    this._resize_canvas = function(width, height) {\n",
+       "        // Keep the size of the canvas, canvas container, and rubber band\n",
+       "        // canvas in synch.\n",
+       "        canvas_div.css('width', width)\n",
+       "        canvas_div.css('height', height)\n",
+       "\n",
+       "        canvas.attr('width', width * mpl.ratio);\n",
+       "        canvas.attr('height', height * mpl.ratio);\n",
+       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
+       "\n",
+       "        rubberband.attr('width', width);\n",
+       "        rubberband.attr('height', height);\n",
+       "    }\n",
+       "\n",
+       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
+       "    // upon first draw.\n",
+       "    this._resize_canvas(600, 600);\n",
+       "\n",
+       "    // Disable right mouse context menu.\n",
+       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
+       "        return false;\n",
+       "    });\n",
+       "\n",
+       "    function set_focus () {\n",
+       "        canvas.focus();\n",
+       "        canvas_div.focus();\n",
+       "    }\n",
+       "\n",
+       "    window.setTimeout(set_focus, 100);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_toolbar = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var nav_element = $('<div/>');\n",
+       "    nav_element.attr('style', 'width: 100%');\n",
+       "    this.root.append(nav_element);\n",
+       "\n",
+       "    // Define a callback function for later on.\n",
+       "    function toolbar_event(event) {\n",
+       "        return fig.toolbar_button_onclick(event['data']);\n",
+       "    }\n",
+       "    function toolbar_mouse_event(event) {\n",
+       "        return fig.toolbar_button_onmouseover(event['data']);\n",
+       "    }\n",
+       "\n",
+       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
+       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+       "\n",
+       "        if (!name) {\n",
+       "            // put a spacer in here.\n",
+       "            continue;\n",
+       "        }\n",
+       "        var button = $('<button/>');\n",
+       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
+       "                        'ui-button-icon-only');\n",
+       "        button.attr('role', 'button');\n",
+       "        button.attr('aria-disabled', 'false');\n",
+       "        button.click(method_name, toolbar_event);\n",
+       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
+       "\n",
+       "        var icon_img = $('<span/>');\n",
+       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
+       "        icon_img.addClass(image);\n",
+       "        icon_img.addClass('ui-corner-all');\n",
+       "\n",
+       "        var tooltip_span = $('<span/>');\n",
+       "        tooltip_span.addClass('ui-button-text');\n",
+       "        tooltip_span.html(tooltip);\n",
+       "\n",
+       "        button.append(icon_img);\n",
+       "        button.append(tooltip_span);\n",
+       "\n",
+       "        nav_element.append(button);\n",
+       "    }\n",
+       "\n",
+       "    var fmt_picker_span = $('<span/>');\n",
+       "\n",
+       "    var fmt_picker = $('<select/>');\n",
+       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
+       "    fmt_picker_span.append(fmt_picker);\n",
+       "    nav_element.append(fmt_picker_span);\n",
+       "    this.format_dropdown = fmt_picker[0];\n",
+       "\n",
+       "    for (var ind in mpl.extensions) {\n",
+       "        var fmt = mpl.extensions[ind];\n",
+       "        var option = $(\n",
+       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
+       "        fmt_picker.append(option);\n",
+       "    }\n",
+       "\n",
+       "    // Add hover states to the ui-buttons\n",
+       "    $( \".ui-button\" ).hover(\n",
+       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
+       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
+       "    );\n",
+       "\n",
+       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
+       "    nav_element.append(status_bar);\n",
+       "    this.message = status_bar[0];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
+       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
+       "    // which will in turn request a refresh of the image.\n",
+       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.send_message = function(type, properties) {\n",
+       "    properties['type'] = type;\n",
+       "    properties['figure_id'] = this.id;\n",
+       "    this.ws.send(JSON.stringify(properties));\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.send_draw_message = function() {\n",
+       "    if (!this.waiting) {\n",
+       "        this.waiting = true;\n",
+       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
+       "    var format_dropdown = fig.format_dropdown;\n",
+       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
+       "    fig.ondownload(fig, format);\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
+       "    var size = msg['size'];\n",
+       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
+       "        fig._resize_canvas(size[0], size[1]);\n",
+       "        fig.send_message(\"refresh\", {});\n",
+       "    };\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
+       "    var x0 = msg['x0'] / mpl.ratio;\n",
+       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
+       "    var x1 = msg['x1'] / mpl.ratio;\n",
+       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
+       "    x0 = Math.floor(x0) + 0.5;\n",
+       "    y0 = Math.floor(y0) + 0.5;\n",
+       "    x1 = Math.floor(x1) + 0.5;\n",
+       "    y1 = Math.floor(y1) + 0.5;\n",
+       "    var min_x = Math.min(x0, x1);\n",
+       "    var min_y = Math.min(y0, y1);\n",
+       "    var width = Math.abs(x1 - x0);\n",
+       "    var height = Math.abs(y1 - y0);\n",
+       "\n",
+       "    fig.rubberband_context.clearRect(\n",
+       "        0, 0, fig.canvas.width / mpl.ratio, fig.canvas.height / mpl.ratio);\n",
+       "\n",
+       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
+       "    // Updates the figure title.\n",
+       "    fig.header.textContent = msg['label'];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
+       "    var cursor = msg['cursor'];\n",
+       "    switch(cursor)\n",
+       "    {\n",
+       "    case 0:\n",
+       "        cursor = 'pointer';\n",
+       "        break;\n",
+       "    case 1:\n",
+       "        cursor = 'default';\n",
+       "        break;\n",
+       "    case 2:\n",
+       "        cursor = 'crosshair';\n",
+       "        break;\n",
+       "    case 3:\n",
+       "        cursor = 'move';\n",
+       "        break;\n",
+       "    }\n",
+       "    fig.rubberband_canvas.style.cursor = cursor;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
+       "    fig.message.textContent = msg['message'];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
+       "    // Request the server to send over a new figure.\n",
+       "    fig.send_draw_message();\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
+       "    fig.image_mode = msg['mode'];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.updated_canvas_event = function() {\n",
+       "    // Called whenever the canvas gets updated.\n",
+       "    this.send_message(\"ack\", {});\n",
+       "}\n",
+       "\n",
+       "// A function to construct a web socket function for onmessage handling.\n",
+       "// Called in the figure constructor.\n",
+       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
+       "    return function socket_on_message(evt) {\n",
+       "        if (evt.data instanceof Blob) {\n",
+       "            /* FIXME: We get \"Resource interpreted as Image but\n",
+       "             * transferred with MIME type text/plain:\" errors on\n",
+       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
+       "             * to be part of the websocket stream */\n",
+       "            evt.data.type = \"image/png\";\n",
+       "\n",
+       "            /* Free the memory for the previous frames */\n",
+       "            if (fig.imageObj.src) {\n",
+       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
+       "                    fig.imageObj.src);\n",
+       "            }\n",
+       "\n",
+       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
+       "                evt.data);\n",
+       "            fig.updated_canvas_event();\n",
+       "            fig.waiting = false;\n",
+       "            return;\n",
+       "        }\n",
+       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
+       "            fig.imageObj.src = evt.data;\n",
+       "            fig.updated_canvas_event();\n",
+       "            fig.waiting = false;\n",
+       "            return;\n",
+       "        }\n",
+       "\n",
+       "        var msg = JSON.parse(evt.data);\n",
+       "        var msg_type = msg['type'];\n",
+       "\n",
+       "        // Call the  \"handle_{type}\" callback, which takes\n",
+       "        // the figure and JSON message as its only arguments.\n",
+       "        try {\n",
+       "            var callback = fig[\"handle_\" + msg_type];\n",
+       "        } catch (e) {\n",
+       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
+       "            return;\n",
+       "        }\n",
+       "\n",
+       "        if (callback) {\n",
+       "            try {\n",
+       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
+       "                callback(fig, msg);\n",
+       "            } catch (e) {\n",
+       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
+       "            }\n",
+       "        }\n",
+       "    };\n",
+       "}\n",
+       "\n",
+       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
+       "mpl.findpos = function(e) {\n",
+       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
+       "    var targ;\n",
+       "    if (!e)\n",
+       "        e = window.event;\n",
+       "    if (e.target)\n",
+       "        targ = e.target;\n",
+       "    else if (e.srcElement)\n",
+       "        targ = e.srcElement;\n",
+       "    if (targ.nodeType == 3) // defeat Safari bug\n",
+       "        targ = targ.parentNode;\n",
+       "\n",
+       "    // jQuery normalizes the pageX and pageY\n",
+       "    // pageX,Y are the mouse positions relative to the document\n",
+       "    // offset() returns the position of the element relative to the document\n",
+       "    var x = e.pageX - $(targ).offset().left;\n",
+       "    var y = e.pageY - $(targ).offset().top;\n",
+       "\n",
+       "    return {\"x\": x, \"y\": y};\n",
+       "};\n",
+       "\n",
+       "/*\n",
+       " * return a copy of an object with only non-object keys\n",
+       " * we need this to avoid circular references\n",
+       " * http://stackoverflow.com/a/24161582/3208463\n",
+       " */\n",
+       "function simpleKeys (original) {\n",
+       "  return Object.keys(original).reduce(function (obj, key) {\n",
+       "    if (typeof original[key] !== 'object')\n",
+       "        obj[key] = original[key]\n",
+       "    return obj;\n",
+       "  }, {});\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
+       "    var canvas_pos = mpl.findpos(event)\n",
+       "\n",
+       "    if (name === 'button_press')\n",
+       "    {\n",
+       "        this.canvas.focus();\n",
+       "        this.canvas_div.focus();\n",
+       "    }\n",
+       "\n",
+       "    var x = canvas_pos.x * mpl.ratio;\n",
+       "    var y = canvas_pos.y * mpl.ratio;\n",
+       "\n",
+       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
+       "                             step: event.step,\n",
+       "                             guiEvent: simpleKeys(event)});\n",
+       "\n",
+       "    /* This prevents the web browser from automatically changing to\n",
+       "     * the text insertion cursor when the button is pressed.  We want\n",
+       "     * to control all of the cursor setting manually through the\n",
+       "     * 'cursor' event from matplotlib */\n",
+       "    event.preventDefault();\n",
+       "    return false;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
+       "    // Handle any extra behaviour associated with a key event\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.key_event = function(event, name) {\n",
+       "\n",
+       "    // Prevent repeat events\n",
+       "    if (name == 'key_press')\n",
+       "    {\n",
+       "        if (event.which === this._key)\n",
+       "            return;\n",
+       "        else\n",
+       "            this._key = event.which;\n",
+       "    }\n",
+       "    if (name == 'key_release')\n",
+       "        this._key = null;\n",
+       "\n",
+       "    var value = '';\n",
+       "    if (event.ctrlKey && event.which != 17)\n",
+       "        value += \"ctrl+\";\n",
+       "    if (event.altKey && event.which != 18)\n",
+       "        value += \"alt+\";\n",
+       "    if (event.shiftKey && event.which != 16)\n",
+       "        value += \"shift+\";\n",
+       "\n",
+       "    value += 'k';\n",
+       "    value += event.which.toString();\n",
+       "\n",
+       "    this._key_event_extra(event, name);\n",
+       "\n",
+       "    this.send_message(name, {key: value,\n",
+       "                             guiEvent: simpleKeys(event)});\n",
+       "    return false;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
+       "    if (name == 'download') {\n",
+       "        this.handle_save(this, null);\n",
+       "    } else {\n",
+       "        this.send_message(\"toolbar_button\", {name: name});\n",
+       "    }\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
+       "    this.message.textContent = tooltip;\n",
+       "};\n",
+       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
+       "\n",
+       "mpl.extensions = [\"eps\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\"];\n",
+       "\n",
+       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
+       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
+       "    // object with the appropriate methods. Currently this is a non binary\n",
+       "    // socket, so there is still some room for performance tuning.\n",
+       "    var ws = {};\n",
+       "\n",
+       "    ws.close = function() {\n",
+       "        comm.close()\n",
+       "    };\n",
+       "    ws.send = function(m) {\n",
+       "        //console.log('sending', m);\n",
+       "        comm.send(m);\n",
+       "    };\n",
+       "    // Register the callback with on_msg.\n",
+       "    comm.on_msg(function(msg) {\n",
+       "        //console.log('receiving', msg['content']['data'], msg);\n",
+       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
+       "        ws.onmessage(msg['content']['data'])\n",
+       "    });\n",
+       "    return ws;\n",
+       "}\n",
+       "\n",
+       "mpl.mpl_figure_comm = function(comm, msg) {\n",
+       "    // This is the function which gets called when the mpl process\n",
+       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
+       "\n",
+       "    var id = msg.content.data.id;\n",
+       "    // Get hold of the div created by the display call when the Comm\n",
+       "    // socket was opened in Python.\n",
+       "    var element = $(\"#\" + id);\n",
+       "    var ws_proxy = comm_websocket_adapter(comm)\n",
+       "\n",
+       "    function ondownload(figure, format) {\n",
+       "        window.open(figure.imageObj.src);\n",
+       "    }\n",
+       "\n",
+       "    var fig = new mpl.figure(id, ws_proxy,\n",
+       "                           ondownload,\n",
+       "                           element.get(0));\n",
+       "\n",
+       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
+       "    // web socket which is closed, not our websocket->open comm proxy.\n",
+       "    ws_proxy.onopen();\n",
+       "\n",
+       "    fig.parent_element = element.get(0);\n",
+       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
+       "    if (!fig.cell_info) {\n",
+       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
+       "        return;\n",
+       "    }\n",
+       "\n",
+       "    var output_index = fig.cell_info[2]\n",
+       "    var cell = fig.cell_info[0];\n",
+       "\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
+       "    var width = fig.canvas.width/mpl.ratio\n",
+       "    fig.root.unbind('remove')\n",
+       "\n",
+       "    // Update the output cell to use the data from the current canvas.\n",
+       "    fig.push_to_output();\n",
+       "    var dataURL = fig.canvas.toDataURL();\n",
+       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
+       "    // the notebook keyboard shortcuts fail.\n",
+       "    IPython.keyboard_manager.enable()\n",
+       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
+       "    fig.close_ws(fig, msg);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
+       "    fig.send_message('closing', msg);\n",
+       "    // fig.ws.close()\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
+       "    // Turn the data on the canvas into data in the output cell.\n",
+       "    var width = this.canvas.width/mpl.ratio\n",
+       "    var dataURL = this.canvas.toDataURL();\n",
+       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.updated_canvas_event = function() {\n",
+       "    // Tell IPython that the notebook contents must change.\n",
+       "    IPython.notebook.set_dirty(true);\n",
+       "    this.send_message(\"ack\", {});\n",
+       "    var fig = this;\n",
+       "    // Wait a second, then push the new image to the DOM so\n",
+       "    // that it is saved nicely (might be nice to debounce this).\n",
+       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_toolbar = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var nav_element = $('<div/>');\n",
+       "    nav_element.attr('style', 'width: 100%');\n",
+       "    this.root.append(nav_element);\n",
+       "\n",
+       "    // Define a callback function for later on.\n",
+       "    function toolbar_event(event) {\n",
+       "        return fig.toolbar_button_onclick(event['data']);\n",
+       "    }\n",
+       "    function toolbar_mouse_event(event) {\n",
+       "        return fig.toolbar_button_onmouseover(event['data']);\n",
+       "    }\n",
+       "\n",
+       "    for(var toolbar_ind in mpl.toolbar_items){\n",
+       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+       "\n",
+       "        if (!name) { continue; };\n",
+       "\n",
+       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
+       "        button.click(method_name, toolbar_event);\n",
+       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
+       "        nav_element.append(button);\n",
+       "    }\n",
+       "\n",
+       "    // Add the status bar.\n",
+       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
+       "    nav_element.append(status_bar);\n",
+       "    this.message = status_bar[0];\n",
+       "\n",
+       "    // Add the close button to the window.\n",
+       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
+       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
+       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
+       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
+       "    buttongrp.append(button);\n",
+       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
+       "    titlebar.prepend(buttongrp);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._root_extra_style = function(el){\n",
+       "    var fig = this\n",
+       "    el.on(\"remove\", function(){\n",
+       "\tfig.close_ws(fig, {});\n",
+       "    });\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
+       "    // this is important to make the div 'focusable\n",
+       "    el.attr('tabindex', 0)\n",
+       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
+       "    // off when our div gets focus\n",
+       "\n",
+       "    // location in version 3\n",
+       "    if (IPython.notebook.keyboard_manager) {\n",
+       "        IPython.notebook.keyboard_manager.register_events(el);\n",
+       "    }\n",
+       "    else {\n",
+       "        // location in version 2\n",
+       "        IPython.keyboard_manager.register_events(el);\n",
+       "    }\n",
+       "\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
+       "    var manager = IPython.notebook.keyboard_manager;\n",
+       "    if (!manager)\n",
+       "        manager = IPython.keyboard_manager;\n",
+       "\n",
+       "    // Check for shift+enter\n",
+       "    if (event.shiftKey && event.which == 13) {\n",
+       "        this.canvas_div.blur();\n",
+       "        event.shiftKey = false;\n",
+       "        // Send a \"J\" for go to next cell\n",
+       "        event.which = 74;\n",
+       "        event.keyCode = 74;\n",
+       "        manager.command_mode();\n",
+       "        manager.handle_keydown(event);\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
+       "    fig.ondownload(fig, null);\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.find_output_cell = function(html_output) {\n",
+       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
+       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
+       "    // IPython event is triggered only after the cells have been serialised, which for\n",
+       "    // our purposes (turning an active figure into a static one), is too late.\n",
+       "    var cells = IPython.notebook.get_cells();\n",
+       "    var ncells = cells.length;\n",
+       "    for (var i=0; i<ncells; i++) {\n",
+       "        var cell = cells[i];\n",
+       "        if (cell.cell_type === 'code'){\n",
+       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
+       "                var data = cell.output_area.outputs[j];\n",
+       "                if (data.data) {\n",
+       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
+       "                    data = data.data;\n",
+       "                }\n",
+       "                if (data['text/html'] == html_output) {\n",
+       "                    return [cell, data, j];\n",
+       "                }\n",
+       "            }\n",
+       "        }\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "// Register the function which deals with the matplotlib target/channel.\n",
+       "// The kernel may be null if the page has been refreshed.\n",
+       "if (IPython.notebook.kernel != null) {\n",
+       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
+       "}\n"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Javascript object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<img src=\"data:image/png;base64,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\" width=\"640\">"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig = plt.figure()\n",
+    "x = np.arange(10)\n",
+    "y = x**2\n",
+    "plt.plot(x, y)\n",
+    "fig.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/nbclient/tests/test_client.py b/nbclient/tests/test_client.py
index de41435a..513b5084 100644
--- a/nbclient/tests/test_client.py
+++ b/nbclient/tests/test_client.py
@@ -243,6 +243,7 @@ def notebook_resources():
 @pytest.mark.parametrize(
     ["input_name", "opts"],
     [
+        ("Matplotlib.ipynb", dict(kernel_name="python")),
         ("Clear Output.ipynb", dict(kernel_name="python")),
         ("Empty Cell.ipynb", dict(kernel_name="python")),
         ("Factorials.ipynb", dict(kernel_name="python")),
diff --git a/requirements-dev.txt b/requirements-dev.txt
index 484c6fe8..c48540dc 100644
--- a/requirements-dev.txt
+++ b/requirements-dev.txt
@@ -15,3 +15,4 @@ pip>=18.1
 wheel>=0.31.0
 setuptools>=38.6.0
 twine>=1.11.0
+matplotlib