self.assertEqual(context_cfg["host"], server_info)
         self.assertEqual(context_cfg["target"], server_info)
 
+    def test_set_dispatchers(self):
+        t = task.Task()
+        output_config = {"DEFAULT": {"dispatcher": "file, http"}}
+        t._set_dispatchers(output_config)
+        self.assertEqual(output_config, output_config)
+
+    @mock.patch('yardstick.benchmark.core.task.DispatcherBase')
+    def test__do_output(self, mock_dispatcher):
+        t = task.Task()
+        output_config = {"DEFAULT": {"dispatcher": "file, http"}}
+        mock_dispatcher.get = mock.MagicMock(return_value=[mock.MagicMock(),
+                                                           mock.MagicMock()])
+        self.assertEqual(None, t._do_output(output_config, {}))
+
     @mock.patch('yardstick.benchmark.core.task.Context')
     def test_parse_networks_from_nodes(self, mock_context):
         nodes = {
 
         self.contexts = []
         self.outputs = {}
 
+    def _set_dispatchers(self, output_config):
+        dispatchers = output_config.get('DEFAULT', {}).get('dispatcher',
+                                                           'file')
+        out_types = [s.strip() for s in dispatchers.split(',')]
+        output_config['DEFAULT']['dispatcher'] = out_types
+
     def start(self, args, **kwargs):
         """Start a benchmark scenario."""
 
         self._set_output_config(output_config, args.output_file)
         LOG.debug('Output configuration is: %s', output_config)
 
-        if output_config['DEFAULT'].get('dispatcher') == 'file':
+        self._set_dispatchers(output_config)
+
+        # update dispatcher list
+        if 'file' in output_config['DEFAULT']['dispatcher']:
             result = {'status': 0, 'result': {}}
             utils.write_json_to_file(args.output_file, result)
 
             return 'PASS'
 
     def _do_output(self, output_config, result):
+        dispatchers = DispatcherBase.get(output_config)
 
-        dispatcher = DispatcherBase.get(output_config)
-        dispatcher.flush_result_data(result)
+        for dispatcher in dispatchers:
+            dispatcher.flush_result_data(result)
 
     def _run(self, scenarios, run_in_parallel, output_file):
         """Deploys context and calls runners"""
 
     def get(config):
         """Returns instance of a dispatcher for dispatcher type.
         """
-        out_type = config['DEFAULT']['dispatcher']
+        list_dispatcher = \
+            [Base.get_cls(out_type.capitalize())(config)
+             for out_type in config['DEFAULT']['dispatcher']]
 
-        return Base.get_cls(out_type.capitalize())(config)
+        return list_dispatcher
 
     @abc.abstractmethod
     def flush_result_data(self, data):