diff --git a/checksit/check.py b/checksit/check.py
index c8ef3ca7..e1eec1fe 100644
--- a/checksit/check.py
+++ b/checksit/check.py
@@ -10,6 +10,7 @@
 import re
 import difflib
 import yaml
+import json
 import urllib.request
 import urllib.error
 from typing import Optional, Union, List, Dict, Tuple
@@ -37,6 +38,7 @@ class Checker:
     results of the checks.
 
     Attributes:
+        file_path: File to check.
         template: Template to use for checking. Options are "auto" (default), "off", or
           `<template file>`. File location is relative to the top level of the checksit
           repository.
@@ -54,10 +56,13 @@ class Checker:
         ignore_warnings: Ignore warnings when checking the file, only return errors.
         skip_spellcheck: Skip the spellcheck in rules and functions that utilise spell
           checking.
+        errors: Errors found in file by checks.
+        warnings: Warnings found in file by checks.
     """
 
     def __init__(
         self,
+        file_path: str,
         template: str = "auto",
         mappings: Optional[Dict[str, str]] = None,
         extra_rules: Optional[Dict[str, str]] = None,
@@ -72,6 +77,7 @@ def __init__(
         """Initialise the Checker class.
 
         Args:
+            file_path: File to check.
             template: Template to use for checking. Options are "auto" (default), "off",
               or `<template file>`. File location is relative to the top level of the
               checksit repository.
@@ -90,6 +96,7 @@ def __init__(
             skip_spellcheck: Skip the spellcheck in rules and functions that utilise spell
               checking.
         """
+        self.file_path = file_path
         self.template = template
         self.mappings = mappings or {}
         self.extra_rules = extra_rules or {}
@@ -101,39 +108,33 @@ def __init__(
         self.log_mode = log_mode
         self.skip_spellcheck = skip_spellcheck
         self._check_context = {}
+        self.errors: List[str] = []
+        self.warnings: List[str] = []
 
-    def _update_check_context(self, file_path: str, template: str) -> None:
-        self._check_context["file_path"] = file_path
-        self._check_context["size"] = os.path.getsize(file_path)
-        self._check_context["template"] = template
+    def _update_check_context(self) -> None:
+        self._check_context["file_path"] = self.file_path
+        self._check_context["size"] = os.path.getsize(self.file_path)
+        self._check_context["template"] = self.template
 
     def _compare_items(
-        self, rec, tmpl, key, label, mappings=None, extra_rules=None, ignore_attrs=None
+        self, rec, tmpl, key, label
     ):
-
-        mappings = mappings or self.mappings
-        extra_rules = extra_rules or self.extra_rules
-        ignore_attrs = ignore_attrs or self.ignore_attrs
         errors = []
-
         label_key = f"{label}:{key}"
 
-        if label_key in ignore_attrs:
+        if label_key in self.ignore_attrs:
             # Ignore if told to ignore
             return errors
 
         # Map key if required
-        rec_key = mappings.get(key, key)
+        rec_key = self.mappings.get(key, key)
 
         if isinstance(tmpl[key], dict):
             errors.extend(
-                self._compare_dicts(
-                    rec, tmpl, key, mappings=mappings, ignore_attrs=ignore_attrs
-                )
+                self._compare_dicts(rec, tmpl, key)
             )
         else:
             tmpl_value = str(tmpl[key])
-
             if label_key in conf["settings"]["excludes"]:
                 pass
             elif key.startswith(f"{vocabs_prefix}:"):
@@ -159,11 +160,11 @@ def _compare_items(
                     )
                 )
             # Rule defined in `extra_rules` dictionary
-            elif [rule for rule in extra_rules if rule.startswith(label_key)]:
-                rule_key = [rule for rule in extra_rules if rule.startswith(label_key)][
+            elif [rule for rule in self.extra_rules if rule.startswith(label_key)]:
+                rule_key = [rule for rule in self.extra_rules if rule.startswith(label_key)][
                     0
                 ]
-                rule = extra_rules[rule_key]
+                rule = self.extra_rules[rule_key]
                 errors.extend(
                     rules.check(
                         rule,
@@ -177,28 +178,21 @@ def _compare_items(
                 errors.append(
                     f"{label_key}: '{rec.get(rec_key, UNDEFINED)}' does not match expected: '{tmpl[key]}'"
                 )
-
         return errors
 
-    def _compare_dicts(self, record, template, label, mappings=None, ignore_attrs=None):
-        mappings = mappings or self.mappings
+    def _compare_dicts(self, record, template, label):
         errors = []
-
         do_sort = False
         if label in ("dimensions", "global_attributes"):
             do_sort = True
-
         # Recursively check dicts
         tmpl = template[label]
-        rec_key = mappings.get(label, label)
-
+        rec_key = self.mappings.get(label, label)
         if rec_key in record:
             rec = record[rec_key]
-
             keys = tmpl.keys()
             if do_sort:
                 keys = sorted(keys)
-
             for key in keys:
                 errors.extend(
                     self._compare_items(
@@ -206,28 +200,16 @@ def _compare_dicts(self, record, template, label, mappings=None, ignore_attrs=No
                         tmpl,
                         key,
                         label=label,
-                        mappings=mappings,
-                        ignore_attrs=ignore_attrs,
                     )
                 )
-
         else:
             errors.append(f"Expected item '{label}' not found in data file.")
-
         return errors
 
     def _check_file(
         self,
         file_content: Union[cdl.CDLParser, image.ImageParser, pp.PPHeader, badc_csv.BADCCSVHeader, yml.YAMLFile],
         template: Union[cdl.CDLParser, image.ImageParser, pp.PPHeader, badc_csv.BADCCSVHeader, yml.YAMLFile, str],
-        mappings: Optional[Dict[str, str]] =None,
-        extra_rules: Optional[Dict[str, str]] = None,
-        specs: Optional[List[str]] = None,
-        ignore_attrs: Optional[List[str]] = None,
-        log_mode: str = "standard",
-        #fmt_errors=None,
-        ignore_warnings: bool =False,
-        skip_spellcheck: bool = False,
     ) -> None:
         """Check the content of a file against a template and specs.
 
@@ -236,36 +218,19 @@ def _check_file(
             template: Template to use for checking. Options are "auto" (default), "off",
               or `<template file>`. File location is relative to the top level of the
               checksit repository.
-            mappings: Dictionary of mappings to use when checking data files. Keys are the
-              template keys and values are the data file keys.
-            extra_rules: Dictionary of extra rules to use when checking data files. Keys
-              are the template keys and values are the rules to apply.
-            specs: List of spec files to use when checking data files. File location and
-              path relative to the specs folder in the checksit repository.
-            ignore_attrs: List of attributes to ignore when checking variables.
-            log_mode: How the output should be printed. Options are "standard" (default)
-              and "compact".
-            ignore_warnings: Ignore warnings when checking the file, only return errors.
-            skip_spellcheck: Skip the spellcheck in rules and functions that utilise spell
-              checking.
         """
-        if hasattr(file_content, "to_dict"):
-            record = file_content.to_dict()
+        record = file_content.to_dict()
 
         if hasattr(template, "to_dict"):
             template = template.to_dict()
 
-        if log_mode == "standard":
+        if self.log_mode == "standard":
             print("\n\n---------------- Running checks ------------------\n")
 
-        # Create a container for collecting errors
-        errors = getattr(file_content, "fmt_errors", [])
-        warnings = []
+        if hasattr(file_content, "fmt_errors"):
+            self.errors.extend(file_content.fmt_errors)
 
-        # Use check specifications if requested
-        specs = specs or self.specs
-
-        for spec in specs:
+        for spec in self.specs:
             sr = SpecificationChecker(spec)
             if "file-name" in spec:
                 spec_errors, spec_warnings = sr.run_checks(
@@ -273,12 +238,12 @@ def _check_file(
                 )
             else:
                 spec_errors, spec_warnings = sr.run_checks(
-                    record, skip_spellcheck=skip_spellcheck
+                    record, skip_spellcheck=self.skip_spellcheck
                 )
-            errors.extend(spec_errors)
-            warnings.extend(spec_warnings)
+            self.errors.extend(spec_errors)
+            self.warnings.extend(spec_warnings)
 
-        if template == "off" and log_mode == "standard":
+        if template == "off" and self.log_mode == "standard":
             print("[WARNING] Template checks switched off!")
         elif template != "off":
             sections = "dimensions", "variables", "global_attributes"
@@ -288,73 +253,25 @@ def _check_file(
                     record,
                     template,
                     section,
-                    mappings=mappings,
-                    ignore_attrs=ignore_attrs,
                 )
-                errors.extend([f"[{section}] {err}" for err in errs])
-
-        if log_mode == "compact":
-            if len(errors) > 0:
-                highest = "ERROR"
-                endstr = ""
-                number = len(errors)
-            elif len(warnings) > 0 and not ignore_warnings:
-                highest = "WARNING"
-                endstr = "\n"
-                number = len(warnings)
-            else:
-                highest = "NONE"
-                endstr = "\n"
-                number = 0
-            print(f"{highest} | {number} ", end=endstr)
-            err_string = " | ".join(
-                [err.replace("|", "__VERTICAL_BAR_REPLACED__") for err in errors]
-            )
-            if err_string:
-                print(f"| {err_string}")
-
-        else:
-            if errors:
-                print(f"[FAILED] with {len(errors)} errors:\n")
-                for i, error in enumerate(errors):
-                    count = i + 1
-                    print(f"\t{count:02d}. {error}")
-                compliant = False
-            else:
-                compliant = True
-
-            if warnings and not ignore_warnings:
-                print(f"\n[WARNING] {len(warnings)} warnings about file:\n")
-                for i, warning in enumerate(warnings):
-                    count = i + 1
-                    print(f"\t{count:02d}. {warning}")
-
-            if compliant:
-                print("[INFO] File is compliant!")
+                self.errors.extend([f"[{section}] {err}" for err in errs])
 
     def _get_ncas_specs(
         self,
-        file_path: str,
         file_content: Union[cdl.CDLParser, image.ImageParser, pp.PPHeader, badc_csv.BADCCSVHeader, yml.YAMLFile],
-        log_mode: str = "standard",
-        verbose: bool = False,
     ) -> Tuple[str, List[str]]:
         """Get the correct specs for NCAS data files.
 
         Args:
-            file_path: Path to the file to check.
             file_content: Content of the file to check.
-            log_mode: How the output should be printed. Options are "standard" (default)
-              and "compact".
-            verbose: Print additional information.
 
         Returns:
             Template and list of specs to use for checking the file.
         """
         template = "auto"
-        specs = None
+        specs = []
         # find appropriate specs depending on convention
-        if file_path.split(".")[-1] == "nc" and ":conventions" in file_content.cdl.lower():
+        if self.file_path.split(".")[-1] == "nc" and ":conventions" in file_content.cdl.lower():
             conventions = (
                 file_content.cdl.lower().split(":conventions =")[1].split(";")[0].strip()
             )
@@ -363,7 +280,7 @@ def _get_ncas_specs(
                 name in conventions.upper()
                 for name in GENERAL_CONVENTION_PREFIXES
             ):
-                if verbose:
+                if self.verbose:
                     print("\nNCAS-AMOF file detected, finding correct spec files")
                     print("Finding correct AMOF version...")
                 version_number = (
@@ -374,7 +291,7 @@ def _get_ncas_specs(
                 if version_number.count(".") == 1:
                     version_number = f"{version_number}.0"
                 spec_folder = f"ncas-amof-{version_number}"
-                if verbose:
+                if self.verbose:
                     print(f"  {version_number}")
 
                 # check specs exist for that version
@@ -383,7 +300,7 @@ def _get_ncas_specs(
                     f"groups/{spec_folder}",
                 )
                 if not os.path.exists(specs_dir):
-                    if verbose:
+                    if self.verbose:
                         print(
                             f"Specs for version NCAS-GENERAL-{version_number} not found, attempting download..."
                         )
@@ -418,12 +335,12 @@ def _get_ncas_specs(
                                     ) as f:
                                         _ = f.write(cv.read().decode())
                         make_amof_specs(version_number)
-                        if verbose:
+                        if self.verbose:
                             print("  Downloaded of specs successful")
                     except urllib.error.HTTPError:
-                        if log_mode == "compact":
+                        if self.log_mode == "compact":
                             print(
-                                f"{file_path} | ABORTED | FATAL | Cannot download data for NCAS-AMOF-{version_number}"
+                                f"{self.file_path} | ABORTED | FATAL | Cannot download data for NCAS-AMOF-{version_number}"
                             )
                         else:
                             print(
@@ -432,9 +349,9 @@ def _get_ncas_specs(
                             print("Aborting...")
                         sys.exit()
                     except PermissionError:
-                        if log_mode == "compact":
+                        if self.log_mode == "compact":
                             print(
-                                f"{file_path} | ABORTED | FATAL | Permission Error when trying to create folders or files within checksit."
+                                f"{self.file_path} | ABORTED | FATAL | Permission Error when trying to create folders or files within checksit."
                             )
                         else:
                             print(
@@ -446,7 +363,6 @@ def _get_ncas_specs(
                         sys.exit()
                     except:
                         raise
-
                 # get deployment mode and data product, to then get specs
                 deployment_mode = (
                     file_content.cdl.split(":deployment_mode =")[1]
@@ -455,10 +371,10 @@ def _get_ncas_specs(
                     .strip('"')
                 )
                 deploy_spec = f"{spec_folder}/amof-common-{deployment_mode}"
-                product = file_path.split("/")[-1].split("_")[3]
+                product = self.file_path.split("/")[-1].split("_")[3]
                 product_spec = f"{spec_folder}/amof-{product}"
-                file_name_spec = f"{spec_folder}/amof-file-name" if file_path.split("/")[-1].startswith("ncas-") else f"{spec_folder}/community-file-name"
-                global_attrs_spec = f"{spec_folder}/amof-global-attrs" if file_path.split("/")[-1].startswith("ncas-") else f"{spec_folder}/community-global-attrs"
+                file_name_spec = f"{spec_folder}/amof-file-name" if self.file_path.split("/")[-1].startswith("ncas-") else f"{spec_folder}/community-file-name"
+                global_attrs_spec = f"{spec_folder}/amof-global-attrs" if self.file_path.split("/")[-1].startswith("ncas-") else f"{spec_folder}/community-global-attrs"
                 specs = [
                     file_name_spec,
                     deploy_spec,
@@ -467,7 +383,6 @@ def _get_ncas_specs(
                 ]
                 # don't need to do template check
                 template = "off"
-
             # NCAS-Radar
             elif any(
                 name in conventions.upper()
@@ -497,9 +412,8 @@ def _get_ncas_specs(
                     "sweep-variables",
                 ]
                 specs = [f"ncas-radar-{version_number}/{spec}" for spec in spec_names]
-
         elif (
-            file_path.split(".")[-1].lower() in IMAGE_EXTENSIONS
+            self.file_path.split(".")[-1].lower() in IMAGE_EXTENSIONS
             and "XMP-photoshop:Instructions" in file_content.global_attrs.keys()
         ):
             conventions = file_content.global_attrs["XMP-photoshop:Instructions"]
@@ -509,7 +423,7 @@ def _get_ncas_specs(
                     "\n", " "
                 )
             ):
-                if verbose:
+                if self.verbose:
                     print("\nNCAS-IMAGE file detected, finding correct spec files")
                     print("Finding correct IMAGE version...")
                 version_number = (
@@ -518,7 +432,7 @@ def _get_ncas_specs(
                     .split(":")[0]
                 )
                 spec_folder = f"ncas-image-{version_number}"
-                if verbose:
+                if self.verbose:
                     print(f"  {version_number}")
                 specs_dir = os.path.join(
                     conf["settings"].get("specs_dir", "./specs"),
@@ -530,58 +444,72 @@ def _get_ncas_specs(
                     )
                     print("Aborting...")
                     sys.exit()
-                product = file_path.split("/")[-1].split("_")[3]
+                product = self.file_path.split("/")[-1].split("_")[3]
                 product_spec = f"{spec_folder}/amof-{product}"
                 specs = [product_spec, f"{spec_folder}/amof-image-global-attrs"]
                 template = "off"
-
         return template, specs
 
-    def check_file(
-        self,
-        file_path: str,
-        template: str = "auto",
-        mappings: Optional[Dict[str, str]] = None,
-        extra_rules: Optional[Dict[str, str]] = None,
-        specs: Optional[List[str]] = None,
-        ignore_attrs: Optional[List[str]] = None,
-        auto_cache: bool = False,
-        verbose: bool = False,
-        log_mode: str = "standard",
-        ignore_warnings: bool = False,
-        skip_spellcheck: bool = False,
-    ) -> None:
+    def _print_output(self) -> None:
+        """Print output from checks"""
+        if self.log_mode == "compact":
+            if len(self.errors) > 0:
+                highest = "ERROR"
+                endstr = ""
+                number = len(self.errors)
+            elif len(self.warnings) > 0 and not self.ignore_warnings:
+                highest = "WARNING"
+                endstr = "\n"
+                number = len(self.warnings)
+            else:
+                highest = "NONE"
+                endstr = "\n"
+                number = 0
+            print(f"{highest} | {number} ", end=endstr)
+            err_string = " | ".join(
+                [err.replace("|", "__VERTICAL_BAR_REPLACED__") for err in self.errors]
+            )
+            if err_string:
+                print(f"| {err_string}")
+        elif self.log_mode == "standard":
+            if self.errors:
+                print(f"[FAILED] with {len(self.errors)} errors:\n")
+                for i, error in enumerate(self.errors):
+                    count = i + 1
+                    print(f"\t{count:02d}. {error}")
+                compliant = False
+            else:
+                compliant = True
+            if self.warnings and not self.ignore_warnings:
+                print(f"\n[WARNING] {len(self.warnings)} warnings about file:\n")
+                for i, warning in enumerate(self.warnings):
+                    count = i + 1
+                    print(f"\t{count:02d}. {warning}")
+            if compliant:
+                print("[INFO] File is compliant!")
+        elif self.log_mode == "json":
+            data = {
+                "input_file": self.file_path,
+                "specs": self.specs,
+                "template": self.template,
+                "compliant": len(self.errors) == 0,
+                "errors": self.errors,
+                "warnings": self.warnings
+            }
+            print(json.dumps(data))
+
+    def check_file(self) -> None:
         """Check a data file against a template or specs.
 
         Read in the given file, checks specified options for template and specs, and
         gets NCAS specs if required.
-
-        Args:
-            file_path: Path to the file to check.
-            template: Template to use for checking. Options are "auto" (default), "off",
-              or `<template file>`. File location is relative to the top level of the
-              checksit repository.
-            mappings: Dictionary of mappings to use when checking data files. Keys are the
-              template keys and values are the data file keys.
-            extra_rules: Dictionary of extra rules to use when checking data files. Keys
-              are the template keys and values are the rules to apply.
-            specs: List of spec files to use when checking data files. File location and
-              path relative to the specs folder in the checksit repository.
-            ignore_attrs: List of attributes to ignore when checking variables.
-            auto_cache: Store the file in the template cache for future use as a template.
-            log_mode: How the output should be printed. Options are "standard" (default)
-              and "compact".
-            verbose: Print additional information.
-            ignore_warnings: Ignore warnings when checking the file, only return errors.
-            skip_spellcheck: Skip the spellcheck in rules and functions that utilise spell
-              checking.
         """
         try:
             fp = FileParser()
-            file_content = fp.parse_file_header(file_path, verbose=verbose)
+            file_content = fp.parse_file_header(self.file_path, verbose=self.verbose)
         except Exception as err:
-            if log_mode == "compact":
-                print(f"{file_path} | ABORTED | FATAL | Cannot parse input file")
+            if self.log_mode == "compact":
+                print(f"{self.file_path} | ABORTED | FATAL | Cannot parse input file")
                 sys.exit(1)
             else:
                 raise Exception(err)
@@ -604,27 +532,25 @@ def check_file(
             )
         )
         if (
-            template == "auto"
-            and specs == None
-            and (is_ncas_file or file_path.split("/")[-1].startswith("ncas-"))
+            self.template == "auto"
+            and self.specs == []
+            and (is_ncas_file or self.file_path.split("/")[-1].startswith("ncas-"))
         ):
-            template, specs = self._get_ncas_specs(
-                file_path, file_content, log_mode=log_mode, verbose=verbose
-            )
+            self.template, self.specs = self._get_ncas_specs(file_content)
 
-        if template == "off":
-            tmpl = template
+        if self.template == "off":
+            tmpl = self.template
             tmpl_input = "OFF"
         else:
             tm = TemplateManager(
-                auto_cache=auto_cache, verbose=verbose, log_mode=log_mode
+                auto_cache=self.auto_cache, verbose=self.verbose, log_mode=self.log_mode
             )
-            tmpl = tm.get(file_path, template=template)
+            tmpl = tm.get(self.file_path, template=self.template)
             tmpl_input = tmpl.inpt
 
-        self._update_check_context(file_path, template)
+        self._update_check_context()
 
-        if verbose:
+        if self.verbose:
             if tmpl == "off":
                 print("\n--- NOT USING Template CHECK!")
             else:
@@ -632,24 +558,15 @@ def check_file(
 
             print("\n--- Datafile dictionary:\n", file_content.to_dict())
 
-        if log_mode == "compact":
-            print(f"{file_path} | {tmpl_input} | ", end="")
-        else:
+        if self.log_mode == "compact":
+            print(f"{self.file_path} | {tmpl_input} | ", end="")
+        elif self.log_mode == "standard":
             print(
-                f"\nRunning with:\n\tTemplate: {tmpl_input}\n\tSpec Files: {specs}\n\tDatafile: {file_content.inpt}"
+                f"\nRunning with:\n\tTemplate: {tmpl_input}\n\tSpec Files: {self.specs}\n\tDatafile: {file_content.inpt}"
             )
 
-        self._check_file(
-            file_content,
-            template=tmpl,
-            mappings=mappings,
-            extra_rules=extra_rules,
-            specs=specs,
-            ignore_attrs=ignore_attrs,
-            log_mode=log_mode,
-            ignore_warnings=ignore_warnings,
-            skip_spellcheck=skip_spellcheck,
-        )
+        self._check_file(file_content, template=tmpl)
+        self._print_output()
 
 
 class TemplateManager:
@@ -800,42 +717,40 @@ def parse_file_header(
         ext = extension(file_path)
 
         if ext in ("nc", "cdl"):
-            reader = cdl
+            reader = cdl.CDLParser(file_path, verbose)
         elif ext in ("pp"):
-            reader = pp
-        elif ext in ("txt"):
-            reader = badc_csv
+            reader = pp.PPHeader(file_path, verbose)
         elif ext in ("yml"):
-            reader = yml
+            reader = yml.YAMLFile(file_path, verbose)
+        elif ext in ("txt"):
+            reader = badc_csv.BADCCSVHeader(file_path, verbose)
         elif ext.lower() in IMAGE_EXTENSIONS:
-            reader = image
+            reader = image.ImageParser(file_path, verbose)
         else:
             raise Exception(f"No known reader for file with extension: {ext}")
 
-        content = reader.read(file_path, verbose=verbose)
+        reader.read()
 
         if auto_cache:
             base = os.path.splitext(os.path.basename(file_path))[0]
             output_path = os.path.join(
                 conf["settings"]["default_template_cache_dir"], base
             )
-
-            if reader == cdl:
+            if isinstance(reader, cdl.CDLParser):
                 # Special case for NetCDF files using CDL
                 with open(f"{output_path}.cdl", "w") as writer:
-                    writer.write(content.cdl)
+                    writer.write(reader.cdl)
             else:
                 # All others use YAML
                 with open(f"{output_path}.yml", "w") as writer:
                     yaml.dump(
-                        content.to_dict(),
+                        reader.to_dict(),
                         writer,
                         Dumper=yaml.SafeDumper,
                         default_flow_style=False,
                         sort_keys=False,
                     )
-
-        return content
+        return reader
 
 
 def check_file(file_path: str, **kwargs) -> None:
@@ -848,5 +763,5 @@ def check_file(file_path: str, **kwargs) -> None:
         **kwargs: Keyword arguments to pass to the Checker class and
           Checker.check_file function.
     """
-    ch = Checker(**kwargs)
-    ch.check_file(file_path, **kwargs)
+    ch = Checker(file_path, **kwargs)
+    ch.check_file()
diff --git a/checksit/cli.py b/checksit/cli.py
index 06d09dec..22ee1e30 100644
--- a/checksit/cli.py
+++ b/checksit/cli.py
@@ -81,8 +81,8 @@ def check_files(
         ignore_all_variables: Not implemented yet.
         ignore_all_variable_attrs: Not implemented yet.
         auto_cache: Store the file in the template cache for future use as a template.
-        log_mode: How the output should be printed. Options are "standard" (default)
-          and "compact".
+        log_mode: How the output should be printed. Options are "standard" (default),
+          "compact" and "json".
         verbose: Print additional information to the console.
         template: Template to use for checking. Options are "auto" (default), "off", or
           `<template file>`. File location is relative to the top level of the checksit
@@ -187,8 +187,8 @@ def check(
         ignore_all_variables: Not implemented yet.
         ignore_all_variable_attrs: Not implemented yet.
         auto_cache: Store the file in the template cache for future use as a template.
-        log_mode: How the output should be printed. Options are "standard" (default)
-          and "compact".
+        log_mode: How the output should be printed. Options are "standard" (default),
+          "compact" and "json".
         verbose: Print additional information to the console.
         template: Template to use for checking. Options are "auto" (default), "off", or
           `<template file>`. File location is relative to the top level of the checksit
diff --git a/checksit/readers/badc_csv.py b/checksit/readers/badc_csv.py
index 332e73ef..d08fcce5 100644
--- a/checksit/readers/badc_csv.py
+++ b/checksit/readers/badc_csv.py
@@ -1,6 +1,8 @@
 #https://github.com/cedadev/badc-csv/blob/main/badctextfile.py
 from .badctextfile import BADCTextFile
-
+from .base import BaseReader
+from typing import List, Dict
+"""
 req_dicts = "dimensions", "variables", "global_attributes"
 
 
@@ -21,5 +23,27 @@ def read(fpath: str, verbose: bool = False) -> BADCCSVHeader:
     d = {"global_attributes": dict(bm.globalRecords)}
          # "variables": bm.varRecords}
     return BADCCSVHeader(fpath, d)
-
-
+"""
+class BADCCSVHeader(BaseReader):
+    def __init__(
+        self,
+        inpt: str,
+        verbose: bool = False,
+    ) -> None:
+        """Initialise the BADCCSVHeader.
+
+        Args:
+            inpt: The input file path.
+            verbose: Print verbose output during parsing
+        """
+        self.inpt = inpt
+        self.verbose = verbose
+        self.fmt_errors: List[str] = []
+        self.global_attrs: Dict[str, str] = {}
+        self.dimensions: Dict[str, str] = {}
+        self.variables: Dict[str, Dict[str, str]] = {}
+
+    def read(self) -> None:
+        """Read BADC CSV file"""
+        content = BADCTextFile(open(self.inpt))._metadata
+        self.global_attrs = dict(content.globalRecords)
diff --git a/checksit/readers/base.py b/checksit/readers/base.py
new file mode 100644
index 00000000..99dacc0b
--- /dev/null
+++ b/checksit/readers/base.py
@@ -0,0 +1,28 @@
+from abc import ABC, abstractmethod
+from typing import List, Dict, Union
+
+class BaseReader(ABC):
+    inpt: str
+    verbose: bool
+    fmt_errors: List[str]
+    global_attrs: Dict[str, str]
+    dimensions: Dict[str, str]
+    variables: Dict[str, Dict[str, str]]
+
+    @abstractmethod
+    def read(self) -> None:
+        """Read file"""
+        pass
+
+    def to_dict(self) -> Dict[str, Union[Dict[str, str], Dict[str, Dict[str, str]], str]]:
+        """Convert parsed data into dict
+
+        Returns:
+            dictionary mess
+        """
+        return {
+            "dimensions": self.dimensions,
+            "variables": self.variables,
+            "global_attributes": self.global_attrs,
+            "inpt": self.inpt,
+        }
diff --git a/checksit/readers/cdl.py b/checksit/readers/cdl.py
index f3c75b4e..f59b253f 100644
--- a/checksit/readers/cdl.py
+++ b/checksit/readers/cdl.py
@@ -5,9 +5,10 @@
 import yaml
 import subprocess as sp
 import sys
-from typing import Tuple, List, Dict, Union
+from typing import Tuple, List, Dict
 
 from ..cvs import vocabs, vocabs_prefix
+from .base import BaseReader
 
 
 def get_output(cmd: str) -> str:
@@ -23,7 +24,7 @@ def get_output(cmd: str) -> str:
     return subp.stdout.read().decode("utf-8")
 
 
-class CDLParser:
+class CDLParser(BaseReader):
     """Parse a CDL file or netCDF file into dictionaries.
 
     Extract information from netCDF files or CDL files into a dictionaries for
@@ -47,7 +48,7 @@ def __init__(
         inpt: str,
         verbose: bool = False,
     ) -> None:
-        """Initialise the CDLParser and parse the input file.
+        """Initialise the CDLParser.
 
         Args:
             inpt: The input file path or CDL content.
@@ -55,24 +56,27 @@ def __init__(
         """
         self.inpt = inpt
         self.verbose = verbose
-        self.fmt_errors = []
-        self._parse(inpt)
-        self._check_format()
-
-    def _parse(self, inpt: str) -> None:
+        self.fmt_errors: List[str] = []
+        self.global_attrs: Dict[str, str] = {}
+        self.dimensions: Dict[str, str] = {}
+        self.variables: Dict[str, Dict[str, str]] = {}
+        #self.read()
+        #self._check_format()
+
+    def read(self) -> None:
         """Parse the input file or CDL content into dictionaries.
 
         Args:
             inpt: The input file path or CDL content.
         """
         if self.verbose:
-            print(f"[INFO] Parsing input: {inpt[:100]}...")
-        if inpt.endswith(".nc"):
-            self.cdl = get_output(f"ncdump -h {inpt}")
-        elif inpt.endswith(".cdl"):
-            self.cdl = open(inpt).read()
+            print(f"[INFO] Parsing input: {self.inpt[:100]}...")
+        if self.inpt.endswith(".nc"):
+            self.cdl = get_output(f"ncdump -h {self.inpt}")
+        elif self.inpt.endswith(".cdl"):
+            self.cdl = open(self.inpt).read()
         else:
-            self.cdl = inpt
+            self.cdl = self.inpt
 
         cdl_lines: List[str] = self.cdl.strip().split("\n")
 
@@ -86,7 +90,7 @@ def _parse(self, inpt: str) -> None:
         for s in self.CDL_SPLITTERS:
             if s not in cdl_lines:
                 print(
-                    f"Please check your command - invalid file or CDL contents provided: '{inpt[:100]}...'"
+                    f"Please check your command - invalid file or CDL contents provided: '{self.inpt[:100]}...'"
                 )
                 sys.exit(1)
 
@@ -343,30 +347,30 @@ def to_yaml(self) -> str:
             sort_keys=False,
         )
 
-    def to_dict(self) -> Dict[str, Union[Dict[str, str], Dict[str, Dict[str, str]], str, List[str]]]:
-        """Return the parsed CDL content as a dictionary.
-
-        Returns:
-            A dictionary of the parsed CDL content, with keys "dimensions",
-              "variables", "global_attributes" and "inpt", where "inpt" is the input
-              file path or CDL content.
-        """
-        return {
-            "dimensions": self.dimensions,
-            "variables": self.variables,
-            "global_attributes": self.global_attrs,
-            "inpt": self.inpt,
-        }
-
-
-def read(fpath: str, verbose: bool = False) -> CDLParser:
-    """Read a CDL file or netCDF file and parse it into a CDLParser object.
-
-    Args:
-        fpath: The file path to read.
-        verbose: Print verbose output during parsing.
-
-    Returns:
-        A CDLParser object containing the parsed CDL content.
-    """
-    return CDLParser(fpath, verbose=verbose)
+#    def to_dict(self) -> Dict[str, Union[Dict[str, str], Dict[str, Dict[str, str]], str, List[str]]]:
+#        """Return the parsed CDL content as a dictionary.
+#
+#        Returns:
+#            A dictionary of the parsed CDL content, with keys "dimensions",
+#              "variables", "global_attributes" and "inpt", where "inpt" is the input
+#              file path or CDL content.
+#        """
+#        return {
+#            "dimensions": self.dimensions,
+#            "variables": self.variables,
+#            "global_attributes": self.global_attrs,
+#            "inpt": self.inpt,
+#        }
+
+
+#def read(fpath: str, verbose: bool = False) -> CDLParser:
+#    """Read a CDL file or netCDF file and parse it into a CDLParser object.
+#
+#    Args:
+#        fpath: The file path to read.
+#        verbose: Print verbose output during parsing.
+#
+#    Returns:
+#        A CDLParser object containing the parsed CDL content.
+#    """
+#    return CDLParser(fpath, verbose=verbose)
diff --git a/checksit/readers/image.py b/checksit/readers/image.py
index 2d7fd733..c74a09bb 100644
--- a/checksit/readers/image.py
+++ b/checksit/readers/image.py
@@ -2,7 +2,8 @@
 """
 import subprocess as sp
 import yaml
-from typing import Tuple, Dict, Union
+from typing import Tuple, Dict
+from .base import BaseReader
 
 def get_output(cmd: str) -> Tuple[str, str]:
     """Get the output of a shell command.
@@ -17,7 +18,7 @@ def get_output(cmd: str) -> Tuple[str, str]:
     return subp.stdout.read().decode("charmap"), subp.stderr.read().decode("charmap")
 
 
-class ImageParser:
+class ImageParser(BaseReader):
     """Parse an image file into dictionaries.
 
     Extract information from an image file into a dictionary for tags, labelled as
@@ -38,7 +39,7 @@ def __init__(
         inpt: str,
         verbose: bool = False
     ) -> None:
-        """Initialise the ImageParser and parse the input file.
+        """Initialise the ImageParser.
 
         Args:
             inpt: The input file path.
@@ -46,20 +47,19 @@ def __init__(
         """
         self.inpt = inpt
         self.verbose = verbose
-        self.base_exiftool_arguments = ["exiftool", "-G1", "-j", "-c", "%+.6f"]
+        self._base_exiftool_arguments = ["exiftool", "-G1", "-j", "-c", "%+.6f"]
+        self.global_attrs: Dict[str, str] = {}
+        self.dimensions: Dict[str, str] = {}
+        self.variables: Dict[str, Dict[str, str]] = {}
         self._find_exiftool()
-        self._parse(inpt)
+        #self.read()
 
-    def _parse(self, inpt: str) -> None:
-        """Parse the input file using exiftool.
-
-        Args:
-            inpt: The input file path.
-        """
+    def read(self) -> None:
+        """Parse the input file using exiftool."""
         if self.verbose:
-            print(f"[INFO] Parsing input: {inpt[:100]}...")
+            print(f"[INFO] Parsing input: {self.inpt[:100]}...")
         self.global_attrs = {}
-        exiftool_arguments = self.base_exiftool_arguments + [inpt]
+        exiftool_arguments = self._base_exiftool_arguments + [self.inpt]
         exiftool_return_string = sp.check_output(exiftool_arguments)
         raw_global_attrs = yaml.load(exiftool_return_string, Loader=yaml.SafeLoader)[0]
         for tag_name in raw_global_attrs.keys():
@@ -100,24 +100,24 @@ def _attrs_dict(self, content_lines):
             attr_dict[key] = value
         return attr_dict
 
-    def to_dict(self) -> Dict[str, Union[str, Dict[str, str]]]:
-        """Convert the ImageParser object data to a dictionary.
-
-        Returns:
-            Dictionary containing metadata tags and values as "global_attributes", and
-              the input file path as "inpt".
-        """
-        return {"global_attributes": self.global_attrs, "inpt": self.inpt}
-
-
-def read(fpath: str, verbose: bool = False) -> ImageParser:
-    """Read an image file and return an ImageParser object.
-
-    Args:
-        fpath: The path to the image file.
-        verbose: Print verbose output during parsing.
-
-    Returns:
-        An ImageParser object containing the metadata tags and values.
-    """
-    return ImageParser(fpath, verbose=verbose)
+#    def to_dict(self) -> Dict[str, Union[str, Dict[str, str]]]:
+#        """Convert the ImageParser object data to a dictionary.
+#
+#        Returns:
+#            Dictionary containing metadata tags and values as "global_attributes", and
+#              the input file path as "inpt".
+#        """
+#        return {"global_attributes": self.global_attrs, "inpt": self.inpt}
+
+
+#def read(fpath: str, verbose: bool = False) -> ImageParser:
+#    """Read an image file and return an ImageParser object.
+#
+#    Args:
+#        fpath: The path to the image file.
+#        verbose: Print verbose output during parsing.
+#
+#    Returns:
+#        An ImageParser object containing the metadata tags and values.
+#    """
+#    return ImageParser(fpath, verbose=verbose)
diff --git a/checksit/readers/pp.py b/checksit/readers/pp.py
index 7c684a0e..eabbc148 100644
--- a/checksit/readers/pp.py
+++ b/checksit/readers/pp.py
@@ -1,6 +1,8 @@
-import sys
 import cf
+from .base import BaseReader
+from typing import List, Dict
 
+"""
 req_dicts = "dimensions", "variables", "global_attributes"
 
 class PPHeader:
@@ -26,5 +28,42 @@ def read(fpath: str, verbose: bool = False) -> PPHeader:
         d["variables"][sn] = {"shape": sh}
 
     return PPHeader(fpath, d)
+"""
 
+class PPHeader(BaseReader):
+    def __init__(
+        self,
+        inpt: str,
+        verbose: bool = False,
+    ) -> None:
+        """Initialise the PPHeader.
+
+        Args:
+            inpt: The input file path.
+            verbose: Print verbose output during parsing
+        """
+        self.inpt = inpt
+        self.verbose = verbose
+        self.fmt_errors: List[str] = []
+        self.global_attrs: Dict[str, str] = {}
+        self.dimensions: Dict[str, str] = {}
+        self.variables: Dict[str, Dict[str, str]] = {}
+
+    def read(self) -> None:
+        """Read YAML file"""
+        fieldlist = cf.read(self.inpt)
+        content = {"variables": {}}
+
+        for field in fieldlist:
+            sn = field.standard_name
+            sh = list(field.shape)
+
+            content["variables"][sn] = {"shape": sh}
+
+        if "global_attributes" in content:
+            self.global_attrs = content["global_attributes"]
+        if "dimensions" in content:
+            self.dimensions = content["dimensions"]
+        if "variables" in content:
+            self.variables = content["variables"]
 
diff --git a/checksit/readers/yml.py b/checksit/readers/yml.py
index fe4b60f5..2eab70d0 100644
--- a/checksit/readers/yml.py
+++ b/checksit/readers/yml.py
@@ -1,5 +1,7 @@
 import yaml
-
+from typing import List, Dict
+from .base import BaseReader
+"""
 req_dicts = "dimensions", "variables", "global_attributes"
 
 class YAMLFile:
@@ -17,5 +19,35 @@ def to_dict(self):
 def read(fpath: str, verbose: bool = False) -> YAMLFile:
     d = yaml.load(open(fpath), Loader=yaml.SafeLoader)
     return YAMLFile(fpath, d)
+"""
+
+class YAMLFile(BaseReader):
+    def __init__(
+        self,
+        inpt: str,
+        verbose: bool = False,
+    ) -> None:
+        """Initialise the YAMLParser.
+
+        Args:
+            inpt: The input file path.
+            verbose: Print verbose output during parsing
+        """
+        self.inpt = inpt
+        self.verbose = verbose
+        self.fmt_errors: List[str] = []
+        self.global_attrs: Dict[str, str] = {}
+        self.dimensions: Dict[str, str] = {}
+        self.variables: Dict[str, Dict[str, str]] = {}
+
+    def read(self) -> None:
+        """Read YAML file"""
+        content = yaml.load(open(self.inpt), Loader=yaml.SafeLoader)
+        if "global_attributes" in content:
+            self.global_attrs = content["global_attributes"]
+        if "dimensions" in content:
+            self.dimensions = content["dimensions"]
+        if "variables" in content:
+            self.variables = content["variables"]
 
 
diff --git a/tests/test_readers.py b/tests/test_readers.py
index a8975c8e..2846be72 100644
--- a/tests/test_readers.py
+++ b/tests/test_readers.py
@@ -1,7 +1,8 @@
 import os
 import pytest
 
-from checksit.readers.cdl import read as read_cdl
+#from checksit.readers.cdl import read as read_cdl
+from checksit.readers.cdl import CDLParser
 
 from .common import TESTDATA_DIR
 
@@ -15,7 +16,8 @@ def check(file_path, mappings=None, rules=None, ignore_attrs=None, ignore_all_gl
 
 def test_cdl_reader_multiline_parser_1():
     cci_file = os.path.join(TESTDATA_DIR, "esacci/ESACCI-GHG-L2-CH4-CO-TROPOMI-WFMD-20171110-fv2.cdl")
-    resp = read_cdl(cci_file)
+    resp = CDLParser(cci_file)
+    resp.read()
 
     d = resp.to_dict()
     assert d["variables"]["pressure_levels"]["comment"] == \
@@ -31,14 +33,16 @@ def test_cdl_reader_multiline_parser_1():
 @pytest.mark.xfail(reason="File contains badly defined number attributes in strings - so let it fail for now.")
 def test_cdl_reader_multiline_parser_2():
     cci_file = os.path.join(TESTDATA_DIR, "esacci/ESACCI-GHG-L2-CO2-GOSAT2-SRFP-20191231-fv2.cdl")
-    resp = read_cdl(cci_file)
+    resp = CDLParser(cci_file)
+    resp.read()
 
     d = resp.to_dict()
 
 
 def test_cdl_reader_netcdf():
     ncfile = os.path.join(TESTDATA_DIR, "netcdf/test_netcdf.nc")
-    resp = read_cdl(ncfile)
+    resp = CDLParser(ncfile)
+    resp.read()
 
     d = resp.to_dict()
     assert sorted(d.keys()) == sorted(["global_attributes", "dimensions", "variables", "inpt"])