diff --git a/hepdata/modules/records/utils/analyses.py b/hepdata/modules/records/utils/analyses.py
index 188949e0e..7aba654af 100644
--- a/hepdata/modules/records/utils/analyses.py
+++ b/hepdata/modules/records/utils/analyses.py
@@ -23,11 +23,14 @@
 # as an Intergovernmental Organization or submit itself to any jurisdiction.
 
 import logging
+import os
 
 from celery import shared_task
 from flask import current_app
 from invenio_db import db
 import requests
+import json
+import jsonschema
 
 from hepdata.ext.opensearch.api import index_record_ids
 from hepdata.modules.submission.api import get_latest_hepsubmission, is_resource_added_to_submission
@@ -40,6 +43,10 @@
 logging.basicConfig()
 log = logging.getLogger(__name__)
 
+def get_analyses_schema():
+    schema_path = os.path.join("hepdata", "templates", "analyses_schema.json")
+    with open(schema_path) as f:
+        return json.load(f)
 
 @shared_task
 def update_analyses(endpoint=None):
@@ -50,6 +57,8 @@ def update_analyses(endpoint=None):
 
     :param endpoint: either "rivet" or "MadAnalysis" or "SModelS" or "CheckMATE" or "HackAnalysis" or "Combine" or None (default) for all
     """
+    analyses_schema = get_analyses_schema()
+
     endpoints = current_app.config["ANALYSES_ENDPOINTS"]
     for analysis_endpoint in endpoints:
 
@@ -64,62 +73,133 @@ def update_analyses(endpoint=None):
 
             if response and response.status_code == 200:
 
-                analyses = response.json()
-
                 analysis_resources = DataResource.query.filter_by(file_type=analysis_endpoint).all()
 
-                # Check for missing analyses.
-                for record in analyses:
-                    submission = get_latest_hepsubmission(inspire_id=record, overall_status='finished')
-
-                    if submission:
-                        num_new_resources = 0
-
-                        for analysis in analyses[record]:
-                            _resource_url = endpoints[analysis_endpoint]["url_template"].format(analysis)
-
-                            if not is_resource_added_to_submission(submission.publication_recid, submission.version,
-                                                                   _resource_url):
-
-                                log.info('Adding {} analysis to ins{} with URL {}'.format(
-                                    analysis_endpoint, record, _resource_url)
-                                )
-                                new_resource = DataResource(
-                                    file_location=_resource_url,
-                                    file_type=analysis_endpoint)
-
-                                if "description" in endpoints[analysis_endpoint]:
-                                    new_resource.file_description = str(endpoints[analysis_endpoint]["description"])
-
-                                if "license" in endpoints[analysis_endpoint]:
-                                    resource_license = get_license(endpoints[analysis_endpoint]["license"])
-                                    new_resource.file_license = resource_license.id
-
-                                submission.resources.append(new_resource)
-                                num_new_resources += 1
-
-                            else:
-
-                                # Remove resources from 'analysis_resources' list.
-                                resources = list(filter(lambda a: a.file_location == _resource_url, analysis_resources))
-                                for resource in resources:
-                                    analysis_resources.remove(resource)
-
-                        if num_new_resources:
-
-                            try:
-                                db.session.add(submission)
-                                db.session.commit()
-                                latest_submission = get_latest_hepsubmission(inspire_id=record)
-                                if submission.version == latest_submission.version:
-                                    index_record_ids([submission.publication_recid])
-                            except Exception as e:
-                                db.session.rollback()
-                                log.error(e)
-
-                    else:
-                        log.debug("An analysis is available in {0} but with no equivalent in HEPData (ins{1}).".format(
-                            analysis_endpoint, record))
+                r_json = response.json()
+                try:
+                    jsonschema.validate(instance=r_json, schema=analyses_schema)
+                    new_json = True
+                except jsonschema.ValidationError:
+                    new_json = False
+
+                if new_json:
+
+                    # Check for missing analyses.
+                    for ana in r_json["analyses"]:
+                        inspire_id = ana["inspire_id"]
+                        submission = get_latest_hepsubmission(inspire_id=str(inspire_id), overall_status='finished') # TODO: make inspire_id an int
+
+                        if submission:
+                            num_new_resources = 0
+
+                            for implementation in ana["implementations"]:
+                                ana_name = implementation["name"]
+                                ana_path = implementation["path"] if "path" in implementation else ""
+                                _resource_url = r_json["url_templates"]["main_url"]
+                                prev_url = None
+                                n_tries, max_tries = 0, 10
+                                while _resource_url!=prev_url and n_tries<max_tries:
+                                    prev_url = _resource_url
+                                    _resource_url = _resource_url.format(name=ana_name, path=ana_path)
+                                    n_tries += 1
+
+                                if not is_resource_added_to_submission(submission.publication_recid, submission.version,
+                                                                    _resource_url):
+
+                                    log.info('Adding {} analysis to ins{} with URL {}'.format(
+                                        analysis_endpoint, inspire_id, _resource_url)
+                                    )
+                                    new_resource = DataResource(
+                                        file_location=_resource_url,
+                                        file_type=analysis_endpoint,
+                                        file_description=r_json["implementations_description"]
+                                    )
+
+                                    if "license" in r_json:
+                                        resource_license = get_license(r_json["license"])
+                                        new_resource.file_license = resource_license.id
+
+                                    submission.resources.append(new_resource)
+                                    num_new_resources += 1
+
+                                else:
+
+                                    # Remove resources from 'analysis_resources' list.
+                                    resources = list(filter(lambda a: a.file_location == _resource_url, analysis_resources))
+                                    for resource in resources:
+                                        analysis_resources.remove(resource)
+
+                            if num_new_resources:
+
+                                try:
+                                    db.session.add(submission)
+                                    db.session.commit()
+                                    latest_submission = get_latest_hepsubmission(inspire_id=inspire_id)
+                                    if submission.version == latest_submission.version:
+                                        index_record_ids([submission.publication_recid])
+                                except Exception as e:
+                                    db.session.rollback()
+                                    log.error(e)
+
+                        else:
+                            log.debug("An analysis is available in {0} but with no equivalent in HEPData (ins{1}).".format(
+                                analysis_endpoint, inspire_id))
+
+                else: # old JSON file
+                    analyses = r_json
+
+                    # Check for missing analyses.
+                    for record in analyses:
+                        submission = get_latest_hepsubmission(inspire_id=record, overall_status='finished')
+
+                        if submission:
+                            num_new_resources = 0
+
+                            for analysis in analyses[record]:
+                                _resource_url = endpoints[analysis_endpoint]["url_template"].format(analysis)
+
+                                if not is_resource_added_to_submission(submission.publication_recid, submission.version,
+                                                                    _resource_url):
+
+                                    log.info('Adding {} analysis to ins{} with URL {}'.format(
+                                        analysis_endpoint, record, _resource_url)
+                                    )
+                                    new_resource = DataResource(
+                                        file_location=_resource_url,
+                                        file_type=analysis_endpoint)
+
+                                    if "description" in endpoints[analysis_endpoint]:
+                                        new_resource.file_description = str(endpoints[analysis_endpoint]["description"])
+
+                                    if "license" in endpoints[analysis_endpoint]:
+                                        resource_license = get_license(endpoints[analysis_endpoint]["license"])
+                                        new_resource.file_license = resource_license.id
+
+                                    submission.resources.append(new_resource)
+                                    num_new_resources += 1
+
+                                else:
+
+                                    # Remove resources from 'analysis_resources' list.
+                                    resources = list(filter(lambda a: a.file_location == _resource_url, analysis_resources))
+                                    for resource in resources:
+                                        analysis_resources.remove(resource)
+
+                            if num_new_resources:
+
+                                try:
+                                    db.session.add(submission)
+                                    db.session.commit()
+                                    latest_submission = get_latest_hepsubmission(inspire_id=record)
+                                    if submission.version == latest_submission.version:
+                                        index_record_ids([submission.publication_recid])
+                                except Exception as e:
+                                    db.session.rollback()
+                                    log.error(e)
+
+                        else:
+                            log.debug("An analysis is available in {0} but with no equivalent in HEPData (ins{1}).".format(
+                                analysis_endpoint, record))
 
                 if analysis_resources:
                     # Extra resources that were not found in the analyses JSON file.
@@ -154,10 +234,18 @@ def update_analyses(endpoint=None):
                 if "subscribe_user_id" in endpoints[analysis_endpoint]:
                     user = get_user_from_id(endpoints[analysis_endpoint]["subscribe_user_id"])
                     if user:
-                        for record in analyses:
-                            submission = get_latest_hepsubmission(inspire_id=record, overall_status='finished')
-                            if submission and not is_current_user_subscribed_to_record(submission.publication_recid, user):
-                                subscribe(submission.publication_recid, user)
+                        # Check for missing analyses.
+                        if new_json:
+                            for ana in r_json["analyses"]:
+                                submission = get_latest_hepsubmission(inspire_id=str(ana["inspire_id"]), overall_status='finished')
+                                if submission and not is_current_user_subscribed_to_record(submission.publication_recid, user):
+                                    subscribe(submission.publication_recid, user)
+
+                        else: # old JSON file
+                            for record in analyses:
+                                submission = get_latest_hepsubmission(inspire_id=record, overall_status='finished')
+                                if submission and not is_current_user_subscribed_to_record(submission.publication_recid, user):
+                                    subscribe(submission.publication_recid, user)
 
         else:
             log.debug("No endpoint url configured for {0}".format(analysis_endpoint))
diff --git a/hepdata/templates/analyses_schema.json b/hepdata/templates/analyses_schema.json
new file mode 100644
index 000000000..4a6ff2926
--- /dev/null
+++ b/hepdata/templates/analyses_schema.json
@@ -0,0 +1,141 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://hepdata.net/analyses/schemas/1.0.0/analyses_schema.json",
+  "title": "HEPData analysis tool schema",
+  "description": "A JSON schema for tracking implementations of HEPData analyses in different tools",
+  "type": "object",
+  "required": ["schema_version", "tool", "version", "date_created", "implementations_description", "url_templates", "analyses"],
+
+  "properties": {
+    "schema_version": {
+      "description": "The version of the JSON schema applying to this file",
+      "const": "1.0.0"
+    },
+
+    "tool": {
+      "description": "The name of the tool used to implement the analyses",
+      "type": "string"
+    },
+
+    "version": {
+      "description": "The version of the tool used to implement the analyses",
+      "type": "string"
+    },
+
+    "date_created": {
+      "description": "The date at which the JSON file was created, formatted as RFC 3339, section 5.6 (https://json-schema.org/understanding-json-schema/reference/type#dates-and-times), e.g. 2018-11-13T20:20:39+00:00",
+      "type": "string",
+      "format": "date-time"
+    },
+
+    "implementations_description": {
+      "description": "The type of information provided for the analyses by the tool",
+      "type": "string"
+    },
+
+    "url_templates": {
+      "description": "Templates for URLs to the main repository and important other pages",
+      "type": "object",
+      "required": ["main_url"],
+
+      "properties": {
+        "main_url": {
+          "description": "The URL template for the main repository. Should contain e.g. a {name} placeholder for the analysis name.",
+          "type": "string"
+        },
+        "val_url": {
+          "description": "The URL template for the validation page. Should contain e.g. a {name} placeholder for the analysis name.",
+          "type": "string"
+        }
+      }
+    },
+
+    "analyses": {
+      "description": "The analyses implemented in the tool",
+      "type": "array",
+      "items": {
+        "type": "object",
+        "$ref": "#/$defs/Analysis",
+        "minItems": 1,
+        "uniqueItems": true
+      }
+    },
+
+    "implementations_license": {
+      "description": "The license for the implementations of the analyses in the tool. Taken to be CC0 if not specified.",
+      "type": "object",
+      "required": ["name", "url"],
+      "additionalProperties": false,
+
+      "properties": {
+        "name": {
+          "description": "The name of the license",
+          "type": "string",
+          "maxLength": 256
+        },
+        "url": {
+          "description": "The URL to the license",
+          "type": "string",
+          "maxLength": 256
+        },
+        "description": {
+          "description": "A description of the license",
+          "type": "string"
+        }
+      }
+    }
+  },
+
+  "$defs": {
+
+    "Analysis": {
+      "description": "An analysis, identified by the INSPIRE ID, implemented at least once in a tool",
+      "type": "object",
+      "required": ["inspire_id", "implementations"],
+    
+      "properties": {
+        "inspire_id": {
+          "description": "The INSPIRE ID of the analysis",
+          "type": "number"
+        },
+        "implementations":{
+          "description": "The implementations of the analysis in the tool",
+          "type": "array",
+          "item": {
+            "type": "object",
+            "$ref": "#/$defs/Implementation",
+            "minItems": 1,
+            "uniqueItems": true
+          }
+        },
+        "signature_type": {
+          "description": "The signature of the analysis, e.g. 'prompt', 'displaced'",
+          "type": "string"
+        },
+        "pretty_name": {
+          "description": "A pretty name for the analysis",
+          "type": "string"
+        }
+      }
+    },
+
+    "Implementation": {
+      "description": "An implementation of an analysis in a tool, giving the internal name to retrieve information",
+      "type": "object",
+      "required": ["name"],
+    
+      "properties": {
+        "name": {
+          "description": "Internal name of the implementation",
+          "type": "string"
+        },
+        "path": {
+          "description": "The path to the implementation in the tool",
+          "type": "string"
+        }
+      }
+    }
+
+  }
+
+}
diff --git a/hepdata/templates/readme.md b/hepdata/templates/readme.md
new file mode 100644
index 000000000..f8362ea63
--- /dev/null
+++ b/hepdata/templates/readme.md
@@ -0,0 +1,111 @@
+# About the analyses JSON schema
+
+This readme details a JSON schema which is used by reinterpretation tools to communicate to HEPData which analyses are implemented in that tool and where to find the implementations.
+
+## Goals
+- **Self-descriptiveness**: the JSON format includes information about the tool and tool version it's valid for as well as basic information of the analyses implemented in the tool.
+  It also allows tools to include very rough human-readable information instead of just bare identifiers.
+- **Standardisation**: a common standard for everyone ensures easy exchange and findability of information.
+- **Future-proofness**: the standard aims to foresee future needs such that it doesn't require frequent updates.
+- **Redundancy reduction**: the JSON format allows to codify URLs such that the URL stem doesn't have to be repeated.
+  This makes it more compact, better human-readable and better maintainable.
+
+## The standard
+
+### Required fields
+The following fields are required by the analyses JSON standard:
+- **schema_version** (`const`): the version of the analyses JSON schema applying the the file.
+  Currently 1.0.0.
+- **tool** (`string`): the name of the tool used to implement the analyses.
+- **version** (`string`): the version of the tool used to implement the analyses.
+- **date_created** (`string` in `date-time` format): the date at which the JSON file was created, formatted as [RFC 3339, section 5.6](https://json-schema.org/understanding-json-schema/reference/type#dates-and-times), e.g. "2018-11-13T20:20:39+00:00".
+- **implementations_description** (`string`): the type of information provided for the analyses by the tool.
+  This information is used to provide text describing links to the analysis implementation on HEPData and INSPIRE.
+- **url_templates** (`dict`): a dictionary of templates for URLs to the main tool repository and important other pages.
+  
+  It has to include the following fields:
+  - **main_url** (`string`): the URL template for the main repository.
+    Should contain e.g. a "{name}" placeholder for the analysis name.
+- **analyses** (`array`): an array of analyses implemented in the tool.
+  All entries have to be unique.
+  Needs at least one entry.
+  Each array item has to have the following fields:
+  - **inspire_id** (`number`): the INSPIRE ID of the analysis.
+  - **implementations** (`array`): an array of the various implementations of the analysis in the tool.
+    All entries have to be unique.
+    Needs at least one entry.
+    
+    Each array item has to have the following fields:
+    - **name** (`string`): the internal name of the implementation used to retrieve information.
+
+### Additional standardised fields
+The following fields are included in the standard but not required:
+
+- **url_templates** (`dict`): the URL templates dict can also have the following fields:
+  - **val_url** (`string`): the URL template for the validation page.
+    Should contain e.g. a `{name}` placeholder for the analysis name.
+- **analyses** (`array`): the analyses array can also have the following fields:
+  - **signature_type** (`string`): the signature of the analysis, e.g. 'prompt', 'displaced'.
+  - **pretty_name** (`string`): a pretty name for the analysis.
+  - **implementations** (`array`): the implementations array can also have the following fields:
+    - **path** (`string`): the path to the implementation in the tool.
+- **implementations_license** (`dict`): a dictionary describing the license for the implementations of the analyses in the tool.
+  Taken to be CC0 if not specified.
+  
+  It *has to* include the following fields:
+  - **name** (`string`): the name of the license.
+    The maximum length for this field is 256 characters.
+  - **url** (`string`): the URL to the license.
+  The maximum length for this field is 256 characters.
+  
+  It *can* include the following fields:
+  - **description** (`string`): a description of the license
+  
+  No other fields are allowed.
+
+
+### Additional unknown fields
+Apart from the fields mentioned above, the standard allows for any number of additional fields.
+These are however not standardised are not being being checked by the schema.
+
+
+## Examples
+A minimal example for an analyses JSON adhering to the standard looks like this:
+```JSON
+{
+  "schema_version" : "1.0.0",
+  "tool": "SModelS",
+  "version": "3.0.0",
+  "date_created": "2018-11-13T20:20:39+00:00",
+  "implementations_description": "SModelS analysis",
+  "url_templates": {
+    "main_url": "https://github.com/SModelS/smodels-database-release/tree/main/{name}"
+  },
+  "analyses" : [
+    {
+      "inspire_id": 1795076,
+      "implementations": [
+        {
+          "name" : "ATLAS-EXOT-2018-48",
+        }
+      ]
+    }
+  ]
+}
+```
+See [here](../../tests/test_data/analyses_example.json) for a more elaborate example.
+
+## Testing an implementation
+
+Whether an analyses JSON file adheres to the standard defined here, can be with python checked as follows:
+```python
+import json
+import jsonschema
+
+with open("analyses_schema.json") as f:
+  schema = json.load(f)
+with open("analyses_example.json") as f:
+  test = json.load(f)
+
+jsonschema.validate(instance=test, schema=schema)
+```
\ No newline at end of file
diff --git a/tests/analyses_schema_test.py b/tests/analyses_schema_test.py
new file mode 100644
index 000000000..3fd48c82c
--- /dev/null
+++ b/tests/analyses_schema_test.py
@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+#
+# This file is part of HEPData.
+# Copyright (C) 2016 CERN.
+#
+# HEPData is free software; you can redistribute it
+# and/or modify it under the terms of the GNU General Public License as
+# published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version.
+#
+# HEPData is distributed in the hope that it will be
+# useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with HEPData; if not, write to the
+# Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+# MA 02111-1307, USA.
+#
+# In applying this license, CERN does not
+# waive the privileges and immunities granted to it by virtue of its status
+# as an Intergovernmental Organization or submit itself to any jurisdiction.
+import json
+import jsonschema
+import os
+
+from hepdata.modules.records.utils.analyses import get_analyses_schema
+
+def test_analysis_json_schema():
+  base_dir = os.path.dirname(os.path.realpath(__file__))
+  test_file_name = os.path.join(base_dir, "test_data", "analyses_example.json")
+
+  schema = get_analyses_schema()
+  with open(test_file_name) as f:
+    test = json.load(f)
+
+  jsonschema.validate(instance=test, schema=schema)
+
+if __name__ == "__main__":
+  test_analysis_json_schema()
diff --git a/tests/test_data/analyses_example.json b/tests/test_data/analyses_example.json
new file mode 100644
index 000000000..b9ab8ed80
--- /dev/null
+++ b/tests/test_data/analyses_example.json
@@ -0,0 +1,40 @@
+{
+  "schema_version" : "1.0.0",
+  "tool": "SModelS",
+  "version": "3.0.0",
+  "date_created": "2018-11-13T20:20:39+00:00",
+  "implementations_description": "SModelS analysis",
+  "url_templates": {
+      "main_url": "https://github.com/SModelS/smodels-database-release/tree/main/{path}",
+      "val_url": "https://smodels.github.io/docs/Validation#{name}_ul"
+  },
+  "analyses" : [
+    {
+      "inspire_id": 1795075,
+      "implementations": [
+        {
+          "name" : "ATLAS-EXOT-2018-47"
+        }
+      ]
+    },
+    {
+      "inspire_id": 1795076,
+      "signature_type": "prompt",
+      "pretty_name": "di-top resonance",
+      "implementations": [
+        {
+          "name" : "ATLAS-EXOT-2018-48",
+          "path": "13TeV/ATLAS/{name}/"
+        },
+        {
+          "name" : "ATLAS-EXOT-2018-48b",
+          "path": "13TeV/ATLAS/{name}/"
+        }
+      ]
+    }
+  ],
+  "implementations_license": {
+    "name": "cc-by-4.0",
+    "url": "https://creativecommons.org/licenses/by/4.0"
+  }
+}
\ No newline at end of file