diff --git a/integraality/pages_processor.py b/integraality/pages_processor.py
index 9a41f04..e44211e 100644
--- a/integraality/pages_processor.py
+++ b/integraality/pages_processor.py
@@ -1,242 +1,243 @@
 #!/usr/bin/python
 # -*- coding: utf-8 -*-
 """
 Bot to generate statistics
 
 """
 
 import os
 import re
 
 from redis import StrictRedis
 
 import pywikibot
 
 from cache import RedisCache
 from column import ColumnMaker, ColumnSyntaxException
 from grouping import (
     GroupingConfigurationMaker,
     UnsupportedGroupingConfigurationException,
 )
 from page_saving import save_to_wiki_or_local
 from property_statistics import PropertyStatistics
 from sparql_utils import QueryException, SparqlEngineBuilder
 
 REQUIRED_CONFIG_FIELDS = ["selector_sparql", "grouping_property", "properties"]
 
 
 class ProcessingException(Exception):
     pass
 
 
 class ConfigException(ProcessingException):
     pass
 
 
 class NoEndTemplateException(ProcessingException):
     pass
 
 
 class NoStartTemplateException(ProcessingException):
     pass
 
 
 class PagesProcessor:
     def __init__(self, url="https://www.wikidata.org/wiki/", cache_client=None):
         self.site = pywikibot.Site(url=url)
         self.repo = self.site.data_repository()
         self.template_name = "Property dashboard"
         self.end_template_name = "Property dashboard end"
         self.summary = "Update property usage stats"
 
         self.outputs = []
 
         if not cache_client:
             host = os.getenv("REDIS_HOST", "tools-redis.svc.eqiad.wmflabs")
             cache_client = StrictRedis(host=host, decode_responses=False)
         self.cache = RedisCache(cache_client=cache_client)
 
     def make_cache_key(self, page_title):
         return ":".join([self.site.code, page_title]).replace(" ", "_")
 
     def get_all_pages(self):
         template = pywikibot.Page(self.site, self.template_name, ns=10)
         return template.getReferences(only_template_inclusion=True)
 
     @staticmethod
     def extract_elements_from_template_param(template_param):
         """Extract and sanitize the contents of a parsed template param."""
         (field, _, value) = template_param.partition("=")
         return (field.strip(), value.replace("{{!}}", "|"))
 
     def parse_config_from_params(self, params):
         return {
             key: value
             for (key, value) in [
                 self.extract_elements_from_template_param(param) for param in params
             ]
             if key
         }
 
     def make_stats_object_arguments_for_page(self, page):
         all_templates_with_params = page.templatesWithParams()
 
         if self.template_name not in [
             template.title(with_ns=False) for (template, _) in all_templates_with_params
         ]:
             msg = (
                 "No start template '%s' found."
                 "The likely explanation is that inteGraality was invoked from a page that transcludes the page with the template. "
                 "Please invoke inteGraality directly from the page with the template."
                 % self.template_name
             )
             raise NoStartTemplateException(msg)
 
         if self.end_template_name not in [
             template.title(with_ns=False) for (template, _) in all_templates_with_params
         ]:
             raise NoEndTemplateException(
                 "No end template '%s' provided" % self.end_template_name
             )
 
         start_templates_with_params = [
             (template, params)
             for (template, params) in all_templates_with_params
             if template.title(with_ns=False) == self.template_name
         ]
 
         if len(start_templates_with_params) > 1:
             pywikibot.warn("More than one template on the page %s" % page.title())
 
         (template, params) = start_templates_with_params[0]
         parsed_config = self.parse_config_from_params(params)
         config = self.parse_config(parsed_config)
         key = self.make_cache_key(page.title())
         self.cache.set_cache_value(key, config)
         return config
 
     def make_stats_object_for_page(self, page):
         config = self.make_stats_object_arguments_for_page(page)
         try:
             return PropertyStatistics(**config)
         except TypeError:
             raise ConfigException("The template parameters are incorrect.")
 
     def process_page(self, page):
         self.cache.invalidate(self.make_cache_key(page.title()))
         stats = self.make_stats_object_for_page(page)
         output = stats.retrieve_and_process_data()
         new_text = self.replace_in_page(output, page.get())
-        save_to_wiki_or_local(page, self.summary, new_text)
+        summary = self.summary + f" using {stats.get_sparql_engine_name()}"
+        save_to_wiki_or_local(page, summary, new_text)
 
     def parse_config(self, config):
         for field in REQUIRED_CONFIG_FIELDS:
             if field not in config:
                 pywikibot.output("Missing required field %s" % field)
                 raise ConfigException("A required field is missing: %s" % field)
         config["columns"] = self.parse_config_properties(config["properties"])
         del config["properties"]
         try:
             config["grouping_configuration"] = GroupingConfigurationMaker.make(
                 self.repo,
                 config.pop("grouping_property"),
                 config.pop("higher_grouping", None),
                 int(config.pop("grouping_threshold", 20)),
                 config.pop("grouping_link", None),
             )
         except UnsupportedGroupingConfigurationException as e:
             raise ConfigException(e)
         config["stats_for_no_group"] = bool(config.get("stats_for_no_group", False))
         config["sparql_query_engine"] = SparqlEngineBuilder.make(
             config.pop("sparql_endpoint", None)
         )
         return config
 
     @staticmethod
     def parse_config_properties(properties_string):
         properties = [x.strip() for x in properties_string.split(",")]
         properties_data = []
         for prop in properties:
             try:
                 (key, title) = prop.split(":")
             except ValueError:
                 (key, title) = (prop, None)
             if key:
                 try:
                     properties_data.append(ColumnMaker.make(key, title))
                 except ColumnSyntaxException as e:
                     raise ConfigException(e)
         return properties_data
 
     def replace_in_page(self, output, page_text):
         regex_text = f"({{{{{self.template_name}.*?(?<!{{{{!)}}}}).*?({{{{{self.end_template_name}}}}})"
         regex = re.compile(regex_text, re.MULTILINE | re.DOTALL)
         new_text = re.sub(regex, r"\1\n%s\n\2" % output, page_text, count=1)
         return new_text
 
     def process_all(self):
         self.summary = "Weekly update of property usage stats"
         pywikibot.output("Processing pages on site %s" % self.site.sitename)
         for page in self.get_all_pages():
             pywikibot.output("Processing page %s" % page.title())
             try:
                 self.process_page(page)
             except NoStartTemplateException:
                 pywikibot.output(
                     "No start template on page %s, skipping" % page.title()
                 )
             except NoEndTemplateException:
                 pywikibot.output("No end template on page %s, skipping" % page.title())
             except ConfigException:
                 pywikibot.output(
                     "Bad configuration on page %s, skipping" % page.title()
                 )
             except QueryException:
                 pywikibot.output(
                     "A SPARQL query went wrong on page %s, skipping" % page.title()
                 )
             except Exception as e:
                 pywikibot.output("Unknown error with page %s: %s" % (page.title(), e))
 
     def process_one_page(self, page_title):
         page = pywikibot.Page(self.site, page_title)
         pywikibot.output("Processing page %s" % page.title())
         self.process_page(page)
 
     def make_stats_object_for_page_title(self, page_title):
         key = self.make_cache_key(page_title)
         result = self.cache.get_cache_value(key)
         if not result:
             print("No result in cache for %s, computing..." % key)
             page = pywikibot.Page(self.site, page_title)
             result = self.make_stats_object_arguments_for_page(page)
         try:
             return PropertyStatistics(**result)
         except TypeError:
             raise ConfigException("The template parameters are incorrect.")
 
 
 def args_parser():
     import argparse
 
     parser = argparse.ArgumentParser(description="Update Property dashboards on a wiki")
     parser.add_argument(
         "url",
         nargs="?",
         help="the URL of the wiki to update",
         default="https://www.wikidata.org/wiki/",
     )
     return parser.parse_args()
 
 
 def main():
     """
     Main function. Bot does all the work.
     """
     args = args_parser()
     processor = PagesProcessor(url=args.url)
     processor.process_all()
 
 
 if __name__ == "__main__":
     main()
diff --git a/integraality/property_statistics.py b/integraality/property_statistics.py
index 475a79c..6aaa7f7 100644
--- a/integraality/property_statistics.py
+++ b/integraality/property_statistics.py
@@ -1,327 +1,330 @@
 #!/usr/bin/python
 # -*- coding: utf-8 -*-
 """
 Calculate and generate statistics
 
 """
 
 import collections
 import logging
 from enum import Enum
 
 from column import ColumnMaker, GroupingType
 from grouping import ItemGroupingConfiguration
 from line import (
     ItemGrouping,
     NoGroupGrouping,
     SitelinkGrouping,
     TotalsGrouping,
     UnknownValueGrouping,
     YearGrouping,
 )
 from sparql_utils import (
     UNKNOWN_VALUE_PREFIX,
     QueryException,
     WdqsSparqlQueryEngine,
 )
 
 
 class PropertyStatistics:
     """
     Generate statitics
 
     """
 
     GROUP_MAPPING = Enum(
         "GROUP_MAPPING",
         {
             "NO_GROUPING": "None",
             "TOTALS": "",
             "UNKNOWN_VALUE": "{{int:wikibase-snakview-variations-somevalue-label}}",
         },
     )
 
     def __init__(
         self,
         selector_sparql,
         columns,
         grouping_configuration,
         grouping_type=None,
         higher_grouping_type=None,
         stats_for_no_group=False,
         property_threshold=0,
         sparql_query_engine=WdqsSparqlQueryEngine(),
     ):
         """
         Set what to work on and other variables here.
         """
         self.columns = {column.get_key(): column for column in columns}
         self.grouping_configuration = grouping_configuration
         if grouping_type:
             self.grouping_type = GroupingType(grouping_type)
         else:
             self.grouping_type = None
         self.higher_grouping_type = higher_grouping_type
         self.selector_sparql = selector_sparql
         self.stats_for_no_group = stats_for_no_group
         self.property_threshold = property_threshold
         self.sparql_query_engine = sparql_query_engine
 
         self.cell_template = "Integraality cell"
 
+    def get_sparql_engine_name(self):
+        return self.sparql_query_engine.name
+
     def get_grouping_information(self):
         """
         Get all groupings and their counts.
 
         :return: List of Grouping objects
         """
         return self.grouping_configuration.get_grouping_information(
             self.selector_sparql, self.sparql_query_engine
         )
 
     def get_query_for_items_for_property_positive(self, column, grouping):
         grouping_predicate = self.grouping_configuration.get_predicate()
 
         if grouping == self.GROUP_MAPPING.TOTALS:
             line = TotalsGrouping(None)
         elif grouping == self.GROUP_MAPPING.NO_GROUPING:
             line = NoGroupGrouping(None)
         elif grouping == self.GROUP_MAPPING.UNKNOWN_VALUE:
             line = UnknownValueGrouping(None)
         elif self.grouping_type == GroupingType.YEAR:
             line = YearGrouping(None)
         elif grouping.startswith("https://"):
             line = SitelinkGrouping(None)
         else:
             line = ItemGrouping(None)
 
         query = "\n"
         query += line.postive_query(self.selector_sparql, grouping_predicate, grouping)
         query += column.get_filter_for_positive_query()
         query += column.get_service_wikibase_label()
         query += """}
 """
         return query
 
     def get_query_for_items_for_property_negative(self, column, grouping):
         grouping_predicate = self.grouping_configuration.get_predicate()
 
         if grouping == self.GROUP_MAPPING.TOTALS:
             line = TotalsGrouping(None)
         elif grouping == self.GROUP_MAPPING.NO_GROUPING:
             line = NoGroupGrouping(None)
         elif grouping == self.GROUP_MAPPING.UNKNOWN_VALUE:
             line = UnknownValueGrouping(None)
         elif self.grouping_type == GroupingType.YEAR:
             line = YearGrouping(None)
         elif grouping.startswith("https://"):
             line = SitelinkGrouping(None)
         else:
             line = ItemGrouping(None)
 
         query = "\n"
         query += line.negative_query(self.selector_sparql, grouping_predicate, grouping)
         query += column.get_filter_for_negative_query()
         query += column.get_service_wikibase_label()
         query += """}
 """
         return query
 
     def get_totals_no_grouping(self):
         grouping_predicate = self.grouping_configuration.get_predicate()
         query = f"""
 SELECT (COUNT(*) as ?count) WHERE {{
   ?entity {self.selector_sparql}
   MINUS {{ ?entity {grouping_predicate} _:b28. }}
 }}
 """
         return self._get_count_from_sparql(query)
 
     def get_totals(self):
         query = f"""
 SELECT (COUNT(*) as ?count) WHERE {{
   ?entity {self.selector_sparql}
 }}
 """
         return self._get_count_from_sparql(query)
 
     def _get_count_from_sparql(self, query):
         try:
             queryresult = self.sparql_query_engine.select(query)
             if not queryresult:
                 raise QueryException(
                     "No result when running a SPARQL query.", query=query
                 )
 
         except QueryException:
             raise
 
         return int(queryresult[0].get("count"))
 
     def _get_grouping_counts_from_sparql(self, query):
         result = collections.OrderedDict()
         try:
             queryresult = self.sparql_query_engine.select(query)
             if not queryresult:
                 return None
 
         except QueryException:
             raise
 
         for resultitem in queryresult:
             if not resultitem.get("grouping") or resultitem.get("grouping").startswith(
                 UNKNOWN_VALUE_PREFIX
             ):
                 if self.GROUP_MAPPING.UNKNOWN_VALUE.name not in result.keys():
                     result[self.GROUP_MAPPING.UNKNOWN_VALUE.name] = 0
                 result[self.GROUP_MAPPING.UNKNOWN_VALUE.name] += int(
                     resultitem.get("count")
                 )
             else:
                 qid = resultitem.get("grouping").replace(
                     "http://www.wikidata.org/entity/", ""
                 )
                 result[qid] = int(resultitem.get("count"))
 
         return result
 
     def get_header(self):
         text = '{| class="wikitable sortable"\n'
         colspan = 3 if self.grouping_configuration.higher_grouping else 2
         text += f'! colspan="{colspan}" |Top groupings (Minimum {self.grouping_configuration.grouping_threshold} items)\n'
         text += f'! colspan="{len(self.columns)}"|Top Properties (used at least {self.property_threshold} times per grouping)\n'  # noqa
         text += "|-\n"
 
         if self.grouping_configuration.higher_grouping:
             text += "! \n"
 
         text += "! Name\n"
         text += "! Count\n"
         for column_entry in self.columns.values():
             text += column_entry.make_column_header()
 
         return text
 
     def make_stats_for_no_group(self):
         """
         Query the data for no_group, return the wikitext
         """
         count = self.get_totals_no_grouping()
         grouping_object = NoGroupGrouping(
             count=count, higher_grouping=self.grouping_configuration.higher_grouping
         )
 
         for column_entry_key, column_entry in self.columns.items():
             value = self._get_count_from_sparql(
                 column_entry.get_info_no_grouping_query(self)
             )
             grouping_object.cells[column_entry_key] = value
 
         return self.format_stats_for_one_grouping(grouping_object)
 
     def format_stats_for_one_grouping(self, grouping_object):
         """
         Query the data for one group, return the wikitext.
         """
         text = grouping_object.row_opener()
 
         text += grouping_object.format_header_cell(
             self.grouping_configuration, self.grouping_type
         )
         text += grouping_object.format_count_cell()
         for column_entry in self.columns.values():
             text += grouping_object.format_cell(column_entry, self.cell_template)
         return text
 
     def make_totals(self):
         count = self.get_totals()
         grouping_object = TotalsGrouping(
             count=count,
             title="",
             higher_grouping=self.grouping_configuration.higher_grouping,
         )
 
         for column_entry_key, column_entry in self.columns.items():
             value = self._get_count_from_sparql(column_entry.get_totals_query(self))
             grouping_object.cells[column_entry_key] = value
 
         return self.format_stats_for_one_grouping(grouping_object)
 
     def retrieve_and_process_data(self):
         """
         Query the data, output wikitext
         """
         groupings = self.retrieve_data()
         text = self.process_data(groupings)
         return text
 
     def populate_groupings(self, groupings):
         for column_entry_key, column_entry in self.columns.items():
             data = self._get_grouping_counts_from_sparql(
                 column_entry.get_info_query(self)
             )
             if not data:
                 continue
             for grouping_item, value in data.items():
                 grouping = groupings.get(grouping_item)
                 if grouping:
                     grouping.cells[column_entry_key] = value
                 else:
                     logging.debug(
                         f"Discarding data on {grouping_item}, not in the groupings"
                     )
         return groupings
 
     def retrieve_data(self):
         logging.info("Retrieving grouping information...")
 
         try:
             groupings = self.get_grouping_information()
         except QueryException as e:
             logging.error("No groupings found.")
             raise e
 
         logging.info(f"Grouping retrieved: {len(groupings)}")
         groupings = self.populate_groupings(groupings)
         return groupings
 
     def process_data(self, groupings):
         text = self.get_header()
 
         for grouping in sorted(groupings.values(), key=lambda t: t.count, reverse=True):
             text += self.format_stats_for_one_grouping(grouping)
 
         if self.stats_for_no_group:
             text += self.make_stats_for_no_group()
 
         text += self.make_totals()
         text += "|}\n"
 
         return text
 
 
 def main(*args):
     """
     Main function.
     """
     columns = [
         ColumnMaker.make("P21", None),
         ColumnMaker.make("P19", None),
         ColumnMaker.make("Lde", None),
         ColumnMaker.make("Dde", None),
     ]
     logging.info("Main function...")
     stats = PropertyStatistics(
         columns=columns,
         selector_sparql="wdt:P10241 wd:Q41960",
         grouping_configuration=ItemGroupingConfiguration(
             property="P551", grouping_threshold=5
         ),
         stats_for_no_group=True,
         property_threshold=1,
     )
     print(stats.retrieve_and_process_data())
 
 
 if __name__ == "__main__":
     main()
diff --git a/integraality/sparql_utils.py b/integraality/sparql_utils.py
index 1df829e..96388b5 100644
--- a/integraality/sparql_utils.py
+++ b/integraality/sparql_utils.py
@@ -1,114 +1,118 @@
 #!/usr/bin/python
 # -*- coding: utf-8 -*-
 
 import pywikibot
 import pywikibot.data.sparql
 
 import requests
 
 
 class QueryException(Exception):
     def __init__(self, message, query):
         super().__init__(message)
         self.query = query
 
 
 UNKNOWN_VALUE_PREFIX = "http://www.wikidata.org/.well-known/genid/"
 
 
 class UnsupportedSparqlEngineException(Exception):
     pass
 
 
 class SparqlEngineBuilder:
     @staticmethod
     def make(sparql_endpoint=None):
         """Create appropriate SPARQL engine based on endpoint URL."""
         if sparql_endpoint:
             if "qlever" in sparql_endpoint.lower():
                 return QLeverSparqlQueryEngine()
             elif "query.wikidata.org" in sparql_endpoint.lower():
                 return WdqsSparqlQueryEngine()
             else:
                 raise UnsupportedSparqlEngineException(
                     f"The {sparql_endpoint} URL provided is not supported"
                 )
         return WdqsSparqlQueryEngine()
 
 
 class SparqlQueryEngine:
     pass
 
 
 class WdqsSparqlQueryEngine(SparqlQueryEngine):
+    name = "Wikidata Query Service"
+
     def __init__(self):
         self.sq = pywikibot.data.sparql.SparqlQuery()
 
     def select(self, query):
         try:
             return self.sq.select(query)
         except (pywikibot.exceptions.TimeoutError, pywikibot.exceptions.ServerError):
             raise QueryException(
                 "The Wikidata Query Service timed out when running a SPARQL query."
                 "You might be trying to do something too expensive.",
                 query=query,
             )
 
 
 def add_prefixes_to_query(query):
     """Add standard Wikidata prefixes to a SPARQL query for QLever."""
     prefixes = [
         "PREFIX wd: <http://www.wikidata.org/entity/>",
         "PREFIX wdt: <http://www.wikidata.org/prop/direct/>",
         "PREFIX p: <http://www.wikidata.org/prop/>",
         "PREFIX ps: <http://www.wikidata.org/prop/statement/>",
         "PREFIX pq: <http://www.wikidata.org/prop/qualifier/>",
         "PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>",
         "PREFIX schema: <http://schema.org/>",
         "PREFIX bd: <http://www.bigdata.com/rdf#>",
         "PREFIX wikibase: <http://wikiba.se/ontology#>",
         "PREFIX wdno: <http://www.wikidata.org/prop/novalue/>",
     ]
     return "\n".join(prefixes) + "\n" + query
 
 
 class QLeverSparqlQueryEngine(SparqlQueryEngine):
+    name = "QLever"
+
     def __init__(self, endpoint="https://qlever.dev/api/wikidata"):
         self.endpoint = endpoint
 
     def select(self, query):
         try:
             query = add_prefixes_to_query(query)
 
             params = {"query": query}
             response = requests.get(self.endpoint, params=params, timeout=30)
             response.raise_for_status()
 
             data = response.json()
 
             return self._transform_response(data)
 
         except requests.exceptions.HTTPError as e:
             raise QueryException(
                 "QLever is not available, please try again later.",
                 query=query,
             ) from e
 
         except (requests.exceptions.Timeout, requests.exceptions.RequestException):
             raise QueryException(
                 "QLever timed out when running a SPARQL query."
                 "You might be trying to do something too expensive.",
                 query=query,
             )
 
     def _transform_response(self, data):
         """Transform QLever response to expected format."""
         if "results" in data and "bindings" in data["results"]:
             result = []
             for binding in data["results"]["bindings"]:
                 row = {}
                 for var, value in binding.items():
                     row[var] = value["value"]
                 result.append(row)
             return result
         return []