diff --git a/docs/assets/images/img-list-english-colors.png b/docs/assets/images/img-list-english-colors.png
new file mode 100644
index 000000000..0c1d49833
Binary files /dev/null and b/docs/assets/images/img-list-english-colors.png differ
diff --git a/docs/assets/images/img-list-english-example.png b/docs/assets/images/img-list-english-example.png
index a6ad2d6d7..9a5d3f1d0 100644
Binary files a/docs/assets/images/img-list-english-example.png and b/docs/assets/images/img-list-english-example.png differ
diff --git a/docs/assets/images/img-list-german-colors.png b/docs/assets/images/img-list-german-colors.png
new file mode 100644
index 000000000..325f19c42
Binary files /dev/null and b/docs/assets/images/img-list-german-colors.png differ
diff --git a/docs/assets/images/img-list-german-example.png b/docs/assets/images/img-list-german-example.png
index fc1d7d131..fd0091f45 100644
Binary files a/docs/assets/images/img-list-german-example.png and b/docs/assets/images/img-list-german-example.png differ
diff --git a/docs/assets/templates/description_en.xlsx b/docs/assets/templates/description_en.xlsx
deleted file mode 100644
index 09e624ed6..000000000
Binary files a/docs/assets/templates/description_en.xlsx and /dev/null differ
diff --git a/docs/assets/templates/lists/de.xlsx b/docs/assets/templates/lists/de.xlsx
new file mode 100644
index 000000000..aa5f90804
Binary files /dev/null and b/docs/assets/templates/lists/de.xlsx differ
diff --git a/docs/assets/templates/lists/en.xlsx b/docs/assets/templates/lists/en.xlsx
new file mode 100644
index 000000000..86da56ca2
Binary files /dev/null and b/docs/assets/templates/lists/en.xlsx differ
diff --git a/docs/dsp-tools-create.md b/docs/dsp-tools-create.md
index 6748a7e78..d6270eead 100644
--- a/docs/dsp-tools-create.md
+++ b/docs/dsp-tools-create.md
@@ -14,6 +14,8 @@ This documentation is divided into two parts:
  - Overview of the project description file (this page)
  - The "ontologies" section [explained in detail](./dsp-tools-create-ontologies.md)
 
+
+
 ## A short overview
 
 A complete project definition looks like this:
@@ -51,6 +53,8 @@ A complete project definition looks like this:
 }
 ```
 
+
+
 ### "prefixes" object
 
 (optional)
@@ -75,6 +79,8 @@ It is not necessary to define prefixes for the ontologies that are defined in th
 file can be referenced by their name. See [this section](./dsp-tools-create-ontologies.md#referencing-ontologies) for
 more information about referencing ontologies.
 
+
+
 ### "$schema" object
 
 (required)
@@ -83,6 +89,8 @@ The `$schema` object refers to the JSON schema for DSP data model definitions an
 
 `"$schema": "https://raw.githubusercontent.com/dasch-swiss/dsp-tools/main/knora/dsplib/schemas/ontology.json"`
 
+
+
 ### "project" object
 
 (required)
@@ -137,10 +145,14 @@ A simple example definition of the `project` object looks like this:
 }
 ```
 
+
+
 ## "project" object in detail
 
 In the following section all fields of the `project` object are explained in detail.
 
+
+
 ### Shortcode
 
 (required)
@@ -149,6 +161,8 @@ In the following section all fields of the `project` object are explained in det
 
 The shortcode has to be unique and is represented by a 4 digit hexadecimal string. The shortcode has to be provided by the DaSCH.
 
+
+
 ### Shortname
 
 (required)
@@ -158,6 +172,8 @@ The shortcode has to be unique and is represented by a 4 digit hexadecimal strin
 The shortname has to be unique. It should be in the form of a [xsd:NCNAME](https://www.w3.org/TR/xmlschema11-2/#NCName). This means a
 string without blanks or special characters but `-` and `_` are allowed (although not as first character).
 
+
+
 ### Longname
 
 (required)
@@ -166,6 +182,8 @@ string without blanks or special characters but `-` and `_` are allowed (althoug
 
 The longname is a string that provides the full name of the project.
 
+
+
 ### Descriptions
 
 (required)
@@ -175,6 +193,8 @@ The longname is a string that provides the full name of the project.
 The description is represented as a collection of strings with language tags (currently "en", "de", "fr", "it", and "rm" are
 supported). It is the description of the project.
 
+
+
 ### Keywords
 
 (required)
@@ -183,174 +203,246 @@ supported). It is the description of the project.
 
 Keywords are represented as an array of strings and are used to describe and/or tag the project.
 
+
+
 ### Lists
 
 (optional)
 
 `"lists": [<list-definition>,<list-definition>,...]`
 
-Lists can be used to provide controlled vocabularies and can be "flat" or "hierarchical". One advantage of the use of
+Lists can be used to provide controlled vocabularies. They can be flat or hierarchical. One advantage of the use of
 hierarchical lists is that it allows a user to sub-categorize objects. This helps in the formulation of specific search
 requests. If there is a list node "Vocal music" and sub-nodes "Song" and "Opera", a search for "Vocal Music" would
 return objects classified as "Song" and "Opera". But a search for "Song" would only return objects classified as "Song".
+ 
+The "lists" section is an array of list definitions. A list definition has one root node whose name is used to identify 
+the list. The children of the root node are the list nodes. If the list is hierarchical, the list nodes can have
+children, and these children can again have children etc.
 
-In dsp-tools the structure of a list is mapped using JSON. Only a single root node is allowed which also contains the
-name of the list. Inside the root node any number of child nodes and sub-nodes of child nodes are allowed.
-
-A resource can be assigned to a list node within its properties. For example, a resource of type "Musical work" with the
-title "La Traviata" would have a property like "hasMusicGenre" with the value "Grand opera". Within DSP, each property
-has a cardinality. Sometimes, a taxonomy allows an object to belong to multiple categories. In these cases, a
-cardinality greater than 1 has to be used.
+When a list is defined for a project, its values can be referenced in resources within a list property, e.g. a property with 
+[object "ListValue"](./dsp-tools-create-ontologies.md#listvalue).
 
 A node of a list may have the following elements:
 
-- _name_: Name of the node as string. It is mandatory and has to be unique within the list.
-- _labels_: Label with language tags in the form `{ "<lang>": "<label>", "<lang>": "<label>", ... }`. The `labels`
-  element is mandatory. It needs to specify at least one language. Currently, "de", "en", "fr", "it", and "rm" are supported.
-- _comments_: Comment with language tags in the form `{ "<lang>": "<comment>", "<lang>": "<comment>", ... }`.
-  Currently, "de", "en", "fr", "it", and "rm" are supported. The `comments` element is mandatory for the root node of the list.
-  For all other nodes, it is optional. If not used, the element should be omitted.
-- _nodes_: Array of sub-nodes. The `nodes` element is optional and can be omitted in case of a flat list.
+- `name` (mandatory): Name of the node. Has to be unique within the entire "lists" section.
+- `labels` (mandatory): Label with language tags in the form `{"<lang>": "<label>", "<lang>": "<label>", ... }`. 
+  At least one language needs to be specified. Currently, "de", "en", "fr", "it", and "rm" are supported.
+- `comments` (mandatory for root node, optional for all other nodes): Comment with language tags in the form 
+  `{"<lang>": "<comment>", "<lang>": "<comment>", ... }`. Currently, "de", "en", "fr", "it", and "rm" are supported. 
+- `nodes` (optional): Array of sub-nodes.
 
-Example of a list:
+Example of a "lists" section:
 
 ```json
 {
-  "lists": [
-    {
-      "name": "my_list",
-      "labels": {
-        "en": "Disciplines of the Humanities"
-      },
-      "comments": {
-        "en": "This is just an example.",
-        "fr": "C'est un example."
-      },
-      "nodes": [
+    "lists": [
         {
-          "name": "node_1_1",
-          "labels": {
-            "en": "Performing arts"
-          },
-          "comments": {
-            "en": "Arts that are events",
-            "de": "Künste mit performativem Character"
-          },
-          "nodes": [
-            {
-              "name": "node_2_2",
-              "labels": {
-                "en": "Music"
-              },
-              "nodes": [
-                {
-                  "name": "node_3_3",
-                  "labels": {
-                    "en": "Chamber music"
-                  }
-                },
+            "name": "colors",
+            "labels": {
+                "de": "Farben",
+                "en": "Colors"
+            },
+            "comments": {
+                "de": "Eine Liste mit einigen Farben",
+                "en": "A list with some colors"
+            },
+            "nodes": [
                 {
-                  "name": "node_4_3",
-                  "labels": {
-                    "en": "Church music"
-                  }
+                    "name": "red",
+                    "labels": {
+                        "de": "rot",
+                        "en": "red"
+                    }
                 },
                 {
-                  "name": "node_5_3",
-                  "labels": {
-                    "en": "Conducting"
-                  },
-                  "nodes": [
-                    {
-                      "name": "node_6_4",
-                      "labels": {
-                        "en": "Choirs"
-                      }
-                    },
-                    {
-                      "name": "node_7_4",
-                      "labels": {
-                        "en": "Orchestras"
-                      }
+                    "name": "yellow",
+                    "labels": {
+                        "de": "gelb",
+                        "en": "yellow"
                     }
-                  ]
                 },
                 {
-                  "name": "node_8_3",
-                  "labels": {
-                    "en": "Music history"
-                  }
+                    "name": "blue",
+                    "labels": {
+                        "de": "blau",
+                        "en": "blue"
+                    }
                 },
                 {
-                  "name": "node_9_3",
-                  "labels": {
-                    "en": "Musictheory"
-                  }
-                },
+                    "name": "green",
+                    "labels": {
+                        "de": "grün",
+                        "en": "green"
+                    }
+                }
+            ]
+        },
+        {
+            "name": "category",
+            "labels": {
+                "de": "Kategorie",
+                "en": "category"
+            },
+            "comments": {
+                "de": "Eine Liste mit Kategorien",
+                "en": "A list with categories"
+            },
+            "nodes": [
                 {
-                  "name": "node_10_3",
-                  "labels": {
-                    "en": "Musicology"
-                  }
+                    "name": "artwork",
+                    "labels": {
+                        "de": "Kunstwerk",
+                        "en": "artwork"
+                    }
                 },
                 {
-                  "name": "node_11_3",
-                  "labels": {
-                    "en": "Jazz"
-                  }
+                    "name": "vehicles",
+                    "labels": {
+                        "de": "Fahrzeuge",
+                        "en": "vehicles"
+                    }
                 },
                 {
-                  "name": "node_12_3",
-                  "labels": {
-                    "en": "Pop/Rock/Blues"
-                  }
+                    "name": "nature",
+                    "labels": {
+                        "de": "Natur",
+                        "en": "nature"
+                    },
+                    "nodes": [
+                        {
+                            "name": "humanes",
+                            "labels": {
+                                "de": "Menschen",
+                                "en": "Humanes"
+                            }
+                        },
+                        {
+                            "name": "animals",
+                            "labels": {
+                                "de": "Tiere",
+                                "en": "Animals"
+                            },
+                            "nodes": [
+                                {
+                                    "name": "mammals",
+                                    "labels": {
+                                        "de": "Säugetiere",
+                                        "en": "Mammals"
+                                    }
+                                },
+                                {
+                                    "name": "insects",
+                                    "labels": {
+                                        "de": "Insekten",
+                                        "en": "Insects"
+                                    }
+                                },
+                                {
+                                    "name": "birds",
+                                    "labels": {
+                                        "de": "Vögel",
+                                        "en": "Birds"
+                                    }
+                                },
+                                {
+                                    "name": "amphibians",
+                                    "labels": {
+                                        "de": "Ambhibien",
+                                        "en": "Amphibians"
+                                    }
+                                },
+                                {
+                                    "name": "reptiles",
+                                    "labels": {
+                                        "de": "Reptilien",
+                                        "en": "Reptiles"
+                                    }
+                                }
+                            ]
+                        },
+                        {
+                            "name": "plantes",
+                            "labels": {
+                                "de": "Pflanzen",
+                                "en": "Plantes"
+                            }
+                        },
+                        {
+                            "name": "weather",
+                            "labels": {
+                                "de": "Wetter",
+                                "en": "Weather"
+                            }
+                        },
+                        {
+                            "name": "physics",
+                            "labels": {
+                                "de": "Physik",
+                                "en": "Physics"
+                            }
+                        }
+                    ]
                 }
-              ]
-            }
-          ]
-        },
-        {
-          ...
-        },
-        {
-          ...
+            ]
         }
-      ]
-    }
-  ]
+    ]
 }
 ```
 
+
+
 #### Lists from Excel
 
-A list can be directly imported from one or several Excel files. The folder with the Excel file(s) can then directly 
-be referenced inside the list definition by defining it as new list node:
+Instead of being described in JSON, a list can be imported from one or several Excel files. In this case, the 
+`nodes` element of the root node consists of {"folder": "<path-to-folder-containing-the-excel-files>"}. In the above 
+example, the list "colors" could be imported as follows:
 
 ```json
 {
-  "name": "List-from-excel",
-  "labels": {
-    "en": "List from an Excel file",
-    "de": "Liste von einer Excel-Datei"
-  },
-  "comments": {
-    "en": "This is just an example.",
-    "fr": "C'est un example."
-  },
-  "nodes": {
-    "folder": "excel-lists"
-  }
+    "lists": [
+        {
+            "name": "colors",
+            "labels": {
+                "de": "Farben",
+                "en": "Colors"
+            },
+            "comments": {
+                "de": "Eine Liste mit einigen Farben",
+                "en": "A list with some colors"
+            },
+            "nodes": {
+                "folder": "path-to-folder"
+            }
+        },
+        {
+            "name": "category",
+            "labels": {
+                "de": "Kategorie",
+                "en": "category"
+            },
+            "comments": {
+                "de": "Eine Liste mit Kategorien",
+                "en": "A list with categories"
+            },
+            "nodes": [
+                ...
+            ]
+        }
+    ]
 }
 ```
 
-The `nodes` section has to contain the field:
+To do so, it would be necessary to place the following two files into the folder "path-to-folder":
+![Colors_en](./assets/images/img-list-english-colors.png)
+![Farben_de](./assets/images/img-list-german-colors.png)
 
-- _folder_: Path to the folder containing the Excel files
+The expected format of the Excel files is documented 
+[here](./dsp-tools-excel.md#create-the-lists-section-of-a-json-project-file-from-excel-files). The only difference to 
+the explanations there is that column A of the Excel worksheet is not interpreted as list name (root node), but as 
+node name of the first children level below the root node.
 
-Further information about the expected format of the Excel lists and details to this functionality can be found
-[here](./dsp-tools-excel.md#create-a-list-from-one-or-several-excel-files).
 
-The `lists` element is optional. If not used, it should be omitted.
 
 ### Groups
 
@@ -387,6 +479,8 @@ Example:
 }
 ```
 
+
+
 ### Users
 
 (optional)
@@ -440,6 +534,8 @@ Example:
 
 The `users` element is optional. If not used, it should be omitted.
 
+
+
 ### Ontologies
 
 (required)
@@ -456,7 +552,9 @@ ontologies. It requires the following fields:
 
 The `ontologies` section is [documented here](./dsp-tools-create-ontologies.md)
 
-## Fully fleshed out example ontology
+
+
+## Fully fleshed out example of a JSON project file
 
 Finally, here is a complete example of an ontology definition:
 
diff --git a/docs/dsp-tools-excel.md b/docs/dsp-tools-excel.md
index 8f8c7c5e3..0bb349273 100644
--- a/docs/dsp-tools-excel.md
+++ b/docs/dsp-tools-excel.md
@@ -9,11 +9,12 @@ create a list from an Excel file.
 
 
 
-## Create the resources for a data model from an Excel file
+## JSON project file: "resources" section from Excel file
 
 With dsp-tools, the `resources` section used in a data model (JSON) can be created from an Excel file. The command for 
-this is documented [here](./dsp-tools-usage.md#create-resources-from-an-excel-file). Only `XLSX` files are allowed. 
-The `resources` section can be inserted into the ontology file and then be uploaded onto a DSP server.
+this is documented [here](./dsp-tools-usage.md#create-the-resources-section-of-a-json-project-file-from-an-excel-file). 
+Only `XLSX` files are allowed. The `resources` section can be inserted into the ontology file and then be uploaded onto 
+a DSP server.
 
 **An Excel file template can be found [here](assets/templates/resources_template.xlsx). It is recommended to work from 
 the template.**
@@ -50,12 +51,12 @@ For further information about resources, see [here](./dsp-tools-create-ontologie
 
 
 
-## Create the properties for a data model from an Excel file
+## JSON project file: "properties" section from Excel file
 
 With dsp-tools, the `properties` section used in a data model (JSON) can be created from an Excel file. The command for 
-this is documented [here](./dsp-tools-usage.md#create-properties-from-an-excel-file). Only the first worksheet of the 
-Excel file is considered and only XLSX files are allowed. The `properties` section can be inserted into the ontology 
-file and then be uploaded onto a DSP server.
+this is documented [here](./dsp-tools-usage.md#create-the-properties-section-of-a-json-project-file-from-an-excel-file). 
+Only the first worksheet of the Excel file is considered and only XLSX files are allowed. The `properties` section can 
+be inserted into the ontology file and then be uploaded onto a DSP server.
 
 **An Excel file template can be found [here](assets/templates/properties_template.xlsx). It is recommended to work 
 from the template.**
@@ -83,91 +84,116 @@ For further information about properties, see [here](./dsp-tools-create-ontologi
 
 
 
-## Create a list from one or several Excel files
+## JSON project file: "lists" section from Excel file(s)
 
-With dsp-tools, a JSON list can be created from one or several Excel files. The command for this is documented 
-[here](./dsp-tools-usage.md#create-a-json-list-file-from-one-or-several-excel-files). The list can then be inserted 
-into a JSON ontology and uploaded to a DSP server. It is possible to create multilingual lists. In this case, a separate 
-Excel file has to be created for each language. The data must be in the first worksheet of each Excel file. 
-It is important that all the Excel lists have the same structure. So, the translation of a label in one Excel 
-sheet has to be in the exact same cell than the original was in the other Excel sheet (i.e. same cell index).
+With dsp-tools, the "lists" section of a JSON project file can be created from one or several Excel files. The lists can 
+then be inserted into a JSON project file and uploaded to a DSP server. The command for this is documented 
+[here](./dsp-tools-usage.md#create-the-lists-section-of-a-json-project-file-from-excel-files). 
 
-**It is recommended to work from the following templates:  
-[description_en.xlsx](assets/templates/description_en.xlsx): The English list "description"  
-[Beschreibung_de.xlsx](assets/templates/Beschreibung_de.xlsx): Its German counterpart "Beschreibung"**
+The following example shows how to create the "lists" section from the two Excel files `de.xlsx` and `en.xlsx` which are located
+in a directory called `listfolder`:
+
+```bash
+dsp-tools excel2lists listfolder lists.json
+```
 
 The Excel sheets must have the following structure:
 ![img-list-english-example.png](assets/images/img-list-english-example.png)
 ![img-list-german-example.png](assets/images/img-list-german-example.png)
 
-Only Excel files with file extension `.xlsx` are considered. All Excel files have to be located in the same directory. 
-When calling the `excel` command, this folder is provided as an argument to the call. The language of the labels has 
-to be provided in the Excel file's file name after an underline and before the file extension, e.g. 
-`Beschreibung_de.xlsx` would be considered a list with German (`de`) labels, `description_en.xlsx` a list with 
-English (`en`) labels. The language has to be one of {de, en, fr, it, rm}.
-
-The following example shows how to create a JSON list from two Excel files which are in a directory called `listfolder`. 
-The output is written to the file `list.json`.
-
-```bash
-dsp-tools excel listfolder list.json
-```
+Some notes:
 
-The two Excel files `Beschreibung_de.xlsx` and `description_en.xlsx` are located in a folder called `listfolder`.
+- The data must be in the first worksheet of each Excel file.
+- It is important that all Excel files have the same structure. So, the translation of a label in the second Excel 
+  file has to be in the exact same cell as the one in the first Excel file.
+- Only Excel files with file extension `.xlsx` are considered. 
+- The file name must consist of the language label, e.g. `de.xlsx` / `en.xlsx`. 
+- The language has to be one of {de, en, fr, it, rm}.
+- As node name, a simplified version of the English label is taken. If English is not available, one of the other 
+  languages is taken.
+- If there are two nodes with the same name, an incrementing number is appended to the name.
+- After the creation of the list, a validation against the JSON schema for lists is performed. An error message is 
+  printed out if the list is not valid.
 
-```
-listfolder
-    |__ Beschreibung_de.xlsx
-    |__ description_en.xlsx
-```
+**It is recommended to work from the following templates:  
+[en.xlsx](assets/templates/lists/en.xlsx): File with the English labels  
+[de.xlsx](assets/templates/lists/de.xlsx): File with the German labels**
 
-For each list node, the labels are read from the Excel files. The language code, provided in the file name, is then 
-used for the labels. As node name, a simplified version of the English label is taken if English is one of the 
-available languages. If English is not available, one of the other languages is chosen (which one depends on the 
-representation of the file order). If there are two node names with the same name, an incrementing number is appended to
-the `name`.
+The output of the above command, with the template files, is:
 
 ```JSON
 {
-  "name": "description",
-  "labels": {
-    "de": "Beschreibung",
-    "en": "description"
-  },
-  "nodes": [
-    {
-      "name": "first-sublist",
-      "labels": {
-        "de": "erste Unterliste",
-        "en": "first sublist"
-      },
-      "nodes": [
+    "lists": [
+        {
+            "name": "colors",
+            "labels": {
+                "de": "Farben",
+                "en": "colors"
+            },
+            "comments": {
+                "de": "Farben",
+                "en": "colors"
+            },
+            "nodes": [
+                {
+                    "name": "red",
+                    "labels": {
+                        "de": "rot",
+                        "en": "red"
+                    }
+                },
+                ...
+            ]
+        },
         {
-          "name": "first-subnode",
-          "labels": {
-            "de": "erster Listenknoten",
-            "en": "first subnode"
-          },
-          "nodes": [
-            {
-              ...
-            }
-          ]
+            "name": "category",
+            "labels": {
+                "de": "Kategorie",
+                "en": "category"
+            },
+            "comments": {
+                "de": "Kategorie",
+                "en": "category"
+            },
+            "nodes": [
+                {
+                    "name": "artwork",
+                    "labels": {
+                        "de": "Kunstwerk",
+                        "en": "artwork"
+                    }
+                },
+                ...
+            ]
         },
-        ...
-      ]
-    }
-  ]
+        {
+            "name": "faculties-of-the-university-of-basel",
+            "labels": {
+                "de": "Fakultäten der Universität Basel",
+                "en": "Faculties of the University of Basel"
+            },
+            "comments": {
+                "de": "Fakultäten der Universität Basel",
+                "en": "Faculties of the University of Basel"
+            },
+            "nodes": [
+                {
+                    "name": "faculty-of-science",
+                    "labels": {
+                        "de": "Philosophisch-Naturwissenschaftliche Fakultät",
+                        "en": "Faculty of Science"
+                    }
+                },
+                ...
+            ]
+        }
+    ]
 }
 ```
 
-After the creation of the list, a validation against the JSON schema for lists is performed. An error message is 
-printed out if the list is not valid. Furthermore, it is checked that no two nodes are the same.
-
-
 
 
-## Create a DSP-conform XML file from an Excel/CSV file
+## XML data file from Excel/CSV file
 
 There are two use cases for a transformation from Excel/CSV to XML: 
 
diff --git a/docs/dsp-tools-usage.md b/docs/dsp-tools-usage.md
index 2342c4255..44d9b4f92 100644
--- a/docs/dsp-tools-usage.md
+++ b/docs/dsp-tools-usage.md
@@ -117,35 +117,21 @@ to use this file to replace internal IDs in an existing XML file to reference ex
 
 
 
-## Create a JSON list file from one or several Excel files
+## Create the "lists" section of a JSON project file from Excel files
 
 ```bash
-dsp-tools excel [option] folder_with_excel_files output_file.json
+dsp-tools excel2lists folder output.json
 ```
 
-The following option is available:
-
-- `-l` | `--listname` _listname_: name to be used for the list (filename before last occurrence of `_` is used if
-  omitted)
-
-The command is used to create a JSON list file from one or several Excel files. It is possible to create multilingual
-lists. Therefore, an Excel file for each language has to be provided. The data has to be in the first worksheet of the
-Excel file and all Excel files have to be in the same directory. When calling the `excel` command, this directory has to
-be provided as an argument to the call.
-
-The following example shows how to create a JSON list from Excel files in a directory called `lists`.
-
-```bash
-dsp-tools excel lists list.json
-```
-
-The expected Excel format is [documented here](./dsp-tools-create.md#lists-from-excel). More information about the usage 
-of this command can be found [here](./dsp-tools-excel.md#create-a-list-from-one-or-several-excel-files).
+Arguments:
+ - `folder` (optional, default: "lists"): folder with the Excel file(s)
+ - `output.json` (optional, default: "lists.json"): Output file
 
+The expected Excel format is [documented here](./dsp-tools-excel.md#create-the-lists-section-of-a-json-project-file-from-excel-files).
 
 
 
-## Create resources from an Excel file
+## Create the "resources" section of a JSON project file from an Excel file
 
 ```bash
 dsp-tools excel2resources excel_file.xlsx output_file.json
@@ -167,7 +153,7 @@ found [here](./dsp-tools-excel.md#create-the-resources-for-a-data-model-from-an-
 
 
 
-## Create properties from an Excel file
+## Create the "properties" section of a JSON project file from an Excel file
 
 ```bash
 dsp-tools excel2properties excel_file.xlsx output_file.json
diff --git a/docs/index.md b/docs/index.md
index 1f1aff338..94d0ab143 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -18,17 +18,17 @@ dsp-tools helps you with the following tasks:
   on a DSP server from a JSON file.
 - [`dsp-tools get`](./dsp-tools-usage.md#get-a-project-from-a-dsp-server) reads a project with its data model(s) from 
   a DSP server and writes it into a JSON file.
-- [`dsp-tools xmlupload`](./dsp-tools-usage.md#upload-data-to-a-dsp-server) uploads data from a provided XML file (bulk
+- [`dsp-tools xmlupload`](./dsp-tools-usage.md#upload-data-to-a-dsp-server) uploads data from an XML file (bulk
   data import) and writes the mapping from internal IDs to IRIs into a local file.
-- [`dsp-tools excel`](./dsp-tools-usage.md#create-a-json-list-file-from-one-or-several-excel-files)
-  creates a JSON or XML file from one or several Excel files. The created data can either be integrated into an ontology
-  or be uploaded directly to a DSP server with `dsp-tools create`.
-- [`dsp-tools excel2resources`](./dsp-tools-usage.md#create-resources-from-an-excel-file)
-  creates the ontology's resource section from an Excel file. The resulting section can be integrated into an ontology
-  and then be uploaded to a DSP server with `dsp-tools create`.
-- [`dsp-tools excel2properties`](./dsp-tools-usage.md#create-properties-from-an-excel-file)
-  creates the ontology's properties section from an Excel file. The resulting section can be integrated into an ontology
-  and then be uploaded to a DSP server with `dsp-tools create`.
+- [`dsp-tools excel`](./dsp-tools-usage.md#create-the-lists-section-of-a-json-project-file-from-excel-files)
+  creates the "lists" section of a JSON project file from one or several Excel files. The resulting section can be 
+  integrated into a JSON project file and then be uploaded to a DSP server with `dsp-tools create`.
+- [`dsp-tools excel2resources`](./dsp-tools-usage.md#create-the-resources-section-of-a-json-project-file-from-an-excel-file)
+  creates the "resources" section of a JSON project file from an Excel file. The resulting section can be integrated 
+  into a JSON project file and then be uploaded to a DSP server with `dsp-tools create`.
+- [`dsp-tools excel2properties`](./dsp-tools-usage.md#create-the-properties-section-of-a-json-project-file-from-an-excel-file)
+  creates the "properties" section of a JSON project file from an Excel file. The resulting section can be integrated 
+  into a JSON project file and then be uploaded to a DSP server with `dsp-tools create`.
 - [`dsp-tools id2iri`](./dsp-tools-usage.md#replace-internal-ids-with-iris-in-xml-file)
   takes an XML file for bulk data import and replaces referenced internal IDs with IRIs. The mapping has to be provided
   with a JSON file.
diff --git a/knora/dsp_tools.py b/knora/dsp_tools.py
index 98d0ce45a..0dc7c5b8b 100644
--- a/knora/dsp_tools.py
+++ b/knora/dsp_tools.py
@@ -6,7 +6,7 @@
 import sys
 from importlib.metadata import version
 
-from knora.dsplib.utils.excel_to_json_lists import list_excel2json, validate_list_with_schema
+from knora.dsplib.utils.excel_to_json_lists import list_excel2json, validate_lists_section_with_schema
 from knora.dsplib.utils.excel_to_json_properties import properties_excel2json
 from knora.dsplib.utils.excel_to_json_resources import resources_excel2json
 from knora.dsplib.utils.id_to_iri import id_to_iri
@@ -89,19 +89,15 @@ def program(user_args: list[str]) -> None:
 
     # excel
     parser_excel_lists = subparsers.add_parser(
-        'excel',
-        help='Create a JSON list from one or multiple Excel files. The JSON list can be integrated into a JSON '
-             'ontology. If the list should contain multiple languages, an Excel file has to be used for each language. '
-             'The filenames should contain the language as label, p.ex. liste_de.xlsx, list_en.xlsx. The language is '
-             'then taken from the filename. Only files with extension .xlsx are considered.'
+        'excel2lists',
+        help='Create the "lists" section of a JSON project file from one or multiple Excel files. If the list should '
+             'contain multiple languages, a separate file has to be used for each language. The file names must '
+             'consist of the language label, e.g. "de.xlsx", "en.xlsx". Only files with extension .xlsx are considered.'
     )
-    parser_excel_lists.set_defaults(action='excel')
-    parser_excel_lists.add_argument('-l', '--listname', type=str,
-                                    help='Name of the list to be created (filename is taken if omitted)', default=None)
-    parser_excel_lists.add_argument('excelfolder', help='Path to the folder containing the Excel file(s)',
-                                    default='lists')
-    parser_excel_lists.add_argument('outfile', help='Path to the output JSON file containing the list data',
-                                    default='list.json')
+    parser_excel_lists.set_defaults(action='excel2lists')
+    parser_excel_lists.add_argument('excelfolder', help='Path to the folder containing the Excel file(s)')
+    parser_excel_lists.add_argument('outfile', help='Path to the output JSON file containing the "lists" section',
+                                    default='lists.json')
 
     # excel2resources
     parser_excel_resources = subparsers.add_parser('excel2resources', help='Create a JSON file from an Excel file '
@@ -151,7 +147,7 @@ def program(user_args: list[str]) -> None:
     if args.action == 'create':
         if args.lists_only:
             if args.validate_only:
-                validate_list_with_schema(args.datamodelfile)
+                validate_lists_section_with_schema(path_to_json_project_file=args.datamodelfile)
             else:
                 create_lists(input_file=args.datamodelfile,
                              server=args.server,
@@ -189,9 +185,8 @@ def program(user_args: list[str]) -> None:
                        sipi=args.sipi,
                        verbose=args.verbose,
                        incremental=args.incremental)
-    elif args.action == 'excel':
-        list_excel2json(listname=args.listname,
-                        excelfolder=args.excelfolder,
+    elif args.action == 'excel2lists':
+        list_excel2json(excelfolder=args.excelfolder,
                         outfile=args.outfile)
     elif args.action == 'excel2resources':
         resources_excel2json(excelfile=args.excelfile,
diff --git a/knora/dsplib/schemas/lists-only.json b/knora/dsplib/schemas/lists-only.json
index c969a2ca0..f0987f617 100644
--- a/knora/dsplib/schemas/lists-only.json
+++ b/knora/dsplib/schemas/lists-only.json
@@ -1,6 +1,6 @@
 {
     "$schema": "http://json-schema.org/draft-07/schema#",
-    "$id": "https://dasch.swiss/schema/lists.json",
+    "$id": "https://dasch.swiss/schema/lists-only.json",
     "title": "JSON schema for DSP lists",
     "description": "JSON schema for the lists section used in DSP ontologies",
     "definitions": {
@@ -98,38 +98,42 @@
     },
     "type": "object",
     "properties": {
-        "name": {
-            "type": "string"
-        },
-        "labels": {
-            "$ref": "#/definitions/label"
-        },
-        "comments": {
-            "$ref": "#/definitions/comment"
-        },
-        "nodes": {
-            "oneOf": [
-                {
-                    "type": "array",
-                    "items": {
-                        "$ref": "#/definitions/node"
+        "lists": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "properties": {
+                    "name": {
+                        "type": "string"
+                    },
+                    "labels": {
+                        "$ref": "#/definitions/label"
+                    },
+                    "comments": {
+                        "$ref": "#/definitions/comment"
+                    },
+                    "nodes": {
+                        "oneOf": [
+                            {
+                                "type": "array",
+                                "items": {
+                                    "$ref": "#/definitions/node"
+                                }
+                            },
+                            {
+                                "type": "object",
+                                "$ref": "#/definitions/excelfileref"
+                            },
+                            {
+                                "type": "object",
+                                "$ref": "#/definitions/excelfolderref"
+                            }
+                        ]
                     }
                 },
-                {
-                    "type": "object",
-                    "$ref": "#/definitions/excelfileref"
-                },
-                {
-                    "type": "object",
-                    "$ref": "#/definitions/excelfolderref"
-                }
-            ]
+                "required": ["name", "labels", "comments", "nodes"],
+                "additionalProperties": false
+            }
         }
-    },
-    "required": [
-        "name",
-        "nodes",
-        "labels"
-    ],
-    "additionalProperties": false
+    }
 }
diff --git a/knora/dsplib/utils/excel_to_json_lists.py b/knora/dsplib/utils/excel_to_json_lists.py
index d82528da5..998731624 100644
--- a/knora/dsplib/utils/excel_to_json_lists.py
+++ b/knora/dsplib/utils/excel_to_json_lists.py
@@ -10,6 +10,8 @@
 from openpyxl import load_workbook
 from openpyxl.cell import Cell
 from openpyxl.worksheet.worksheet import Worksheet
+import regex
+
 from knora.dsplib.models.helpers import BaseError
 
 list_of_lists_of_previous_cell_values: list[list[str]] = []
@@ -44,20 +46,21 @@ def expand_lists_from_excel(
             new_lists.append(_list)
         else:
             # this is a reference to a folder with Excel files
-            prepared_rootnode, excel_file_names = _prepare_list_creation(
-                excelfolder=_list["nodes"]["folder"],
-                listname=_list["name"],
-                comments=_list["comments"]
-            )
+            foldername = _list["nodes"]["folder"]
+            excel_file_paths = _extract_excel_file_paths(foldername)
             try:
-                finished_list = _make_json_list_from_excel(prepared_rootnode, excel_file_names, verbose=False)
-                new_lists.append(finished_list)
-                print(f"\tThe list '{_list['name']}' contains a reference to the folder '{_list['nodes']['folder']}'. "
-                      f"The Excel files therein will be temporarily expanded into the 'lists' section of your project.")
+                returned_lists_section = _make_json_lists_from_excel(excel_file_paths, verbose=False)
+                # we only need the "nodes" section of the first element of the returned "lists" section. This "nodes"
+                # section needs to replace the Excel folder reference. But the rest of the user-defined list element
+                # needs to stay intact, e.g. the labels and comments.
+                _list["nodes"] = returned_lists_section[0]["nodes"]
+                new_lists.append(_list)
+                print(f"\tThe list '{_list['name']}' contains a reference to the folder '{foldername}'. The Excel "
+                      f"files therein have been temporarily expanded into the 'lists' section of your project.")
             except BaseError as err:
-                print(f"\tWARNING: The list '{_list['name']}' contains a reference to the folder "
-                      f"'{_list['nodes']['folder']}', but a problem occurred while trying to expand the Excel files "
-                      f"therein into the 'lists' section of your project: {err.message}")
+                print(f"\tWARNING: The list '{_list['name']}' contains a reference to the folder '{foldername}', but a "
+                      f"problem occurred while trying to expand the Excel files therein into the 'lists' section of "
+                      f"your project: {err.message}")
                 overall_success = False
 
     return new_lists, overall_success
@@ -73,8 +76,8 @@ def _get_values_from_excel(
     verbose: bool = False
 ) -> tuple[int, dict[str, Any]]:
     """
-    This function calls itself recursively to go through the Excel files. It extracts the cell values and creates
-    the JSON list file.
+    This function calls itself recursively to go through the Excel files. It extracts the cell values and composes
+    the JSON list.
 
     Args:
         excelfiles: List of Excel files with the values in different languages
@@ -106,7 +109,7 @@ def _get_values_from_excel(
         # previous values
         preval.append(base_file_ws.cell(column=col-1, row=row).value.strip())
 
-    while cell.value:
+    while cell.value and regex.search(r"\p{L}", cell.value, flags=re.UNICODE):
         # check if all predecessors in row (values to the left) are consistent with the values in preval list
         for idx, val in enumerate(preval[:-1]):
             if val != base_file_ws.cell(column=idx+1, row=row).value.strip():
@@ -114,7 +117,8 @@ def _get_values_from_excel(
                                 f"{base_file_ws.cell(column=idx+1, row=row).value.strip()}")
 
         # loop through the row until the last (furthest right) value is found
-        if base_file_ws.cell(column=col+1, row=row).value:
+        next_value = base_file_ws.cell(column=col+1, row=row).value
+        if next_value and regex.search(r"\p{L}", next_value, flags=re.UNICODE):
             row, _ = _get_values_from_excel(
                 excelfiles=excelfiles,
                 base_file=base_file,
@@ -132,7 +136,7 @@ def _get_values_from_excel(
             new_check_list.append(cell.value.strip())
             list_of_lists_of_previous_cell_values.append(new_check_list)
 
-            if _contains_duplicates(list_of_lists_of_previous_cell_values):
+            if any([list_of_lists_of_previous_cell_values.count(x) > 1 for x in list_of_lists_of_previous_cell_values]):
                 raise BaseError(f"ERROR: There is at least one duplicate node in the list. Found duplicate in column "
                                 f"{cell.column}, row {cell.row}:\n'{cell.value.strip()}'")
 
@@ -141,10 +145,9 @@ def _get_values_from_excel(
             list_of_previous_node_names.append(nodename)
 
             # append a number (p.ex. node-name-2) if there are list nodes with identical names
-            if _contains_duplicates(list_of_previous_node_names):
-                n = list_of_previous_node_names.count(nodename)
-                if n > 1:
-                    nodename = nodename + "-" + str(n)
+            n = list_of_previous_node_names.count(nodename)
+            if n > 1:
+                nodename = nodename + "-" + str(n)
 
             # read label values from the other Excel files (other languages)
             labels_dict: dict[str, str] = {}
@@ -175,73 +178,62 @@ def _get_values_from_excel(
     return row - 1, parentnode
 
 
-def _make_json_list_from_excel(rootnode: dict[str, Any], excel_file_names: list[str], verbose=False) -> dict[str, Any]:
+def _make_json_lists_from_excel(excel_file_paths: list[str], verbose: bool = False) -> list[dict[str, Any]]:
     """
-    Reads Excel files and transforms them into a dict structure which can later be inserted into the "lists" array
-    of a JSON project file.
+    Reads Excel files and transforms them into a list of dictionaries that can be used as "lists" array of a JSON
+    project file.
 
     Args:
-        rootnode: The root element on top of which the dict structure is going to be built
-        excel_file_names: Excel files to be processed
+        excel_file_paths: Excel files to be processed
         verbose: verbose switch
 
     Returns:
-        The finished list as a dict
+        The finished "lists" section
     """
+    # reset the global variables
+    global list_of_previous_node_names
+    global list_of_lists_of_previous_cell_values
+    list_of_previous_node_names = []
+    list_of_lists_of_previous_cell_values = []
+
     # Define starting point in Excel file
     startrow = 1
     startcol = 1
 
-    # Check if English file is available and take it as base file. Take last one from list of Excel files if English
-    # is not available. The node names are later derived from the labels of the base file.
-    base_file: dict[str, Worksheet] = dict()
-    for filename in excel_file_names:
-        if "_en.xlsx" in os.path.basename(filename):
-            lang = "en"
-            ws = load_workbook(filename, read_only=True).worksheets[0]
-            base_file = {lang: ws}
-    if len(base_file) == 0:
-        file = excel_file_names[-1]
-        lang = os.path.splitext(file)[0].split("_")[-1]
-        ws = load_workbook(file, read_only=True).worksheets[0]
-        base_file = {lang: ws}
-
-    excelfiles: dict[str, Worksheet] = {}
-    for f in excel_file_names:
-        lang = os.path.splitext(f)[0].split("_")[-1]
-        ws = load_workbook(f, read_only=True).worksheets[0]
-        excelfiles[lang] = ws
-
-    _, finished_list = _get_values_from_excel(
-        excelfiles=excelfiles,
+    # make a dict with the language labels and the worksheets
+    lang_to_worksheet: dict[str, Worksheet] = {}
+    for filepath in excel_file_paths:
+        lang_to_worksheet[os.path.basename(filepath)[0:2]] = load_workbook(filepath, read_only=True).worksheets[0]
+
+    # take English as base file. If English is not available, take a random one.
+    base_lang = "en" if "en" in lang_to_worksheet else list(lang_to_worksheet.keys())[0]
+    base_file = {base_lang: lang_to_worksheet[base_lang]}
+
+    # construct the entire "lists" section as children of a fictive dummy parent node
+    _, _list = _get_values_from_excel(
+        excelfiles=lang_to_worksheet,
         base_file=base_file,
-        parentnode=rootnode,
+        parentnode={},
         row=startrow,
         col=startcol,
         preval=[],
         verbose=verbose
     )
 
-    return finished_list
+    # extract the children of the fictive dummy parent node
+    finished_lists: list[dict[str, Any]] = _list["nodes"]
 
+    # the "comments" section is mandatory for the root node of each list, so make a copy of "labels" and insert it at
+    # the right place
+    for i, _list in enumerate(finished_lists):
+        finished_lists[i] = {
+            "name": _list["name"],
+            "labels": _list["labels"],
+            "comments": _list["labels"],
+            "nodes": _list["nodes"]
+        }
 
-def _contains_duplicates(list_to_check: list[Any]) -> bool:
-    """
-    Checks if the given list contains any duplicate items.
-
-    Args:
-        list_to_check: A list of items to be checked for duplicates
-
-    Returns:
-        True if there is a duplicate, false otherwise
-    """
-    has_duplicates = False
-
-    for item in list_to_check:
-        if list_to_check.count(item) > 1:
-            has_duplicates = True
-
-    return has_duplicates
+    return finished_lists
 
 
 def simplify_name(value: str) -> str:
@@ -268,136 +260,81 @@ def simplify_name(value: str) -> str:
     return simplified_value
 
 
-def _make_root_node_from_args(
-    excel_file_names: list[str],
-    listname_from_args: Optional[str],
-    comments: dict[str, str]
-) -> dict[str, Any]:
+def validate_lists_section_with_schema(
+    path_to_json_project_file: Optional[str] = None,
+    lists_section: Optional[list[dict[str, Any]]] = None
+) -> bool:
     """
-    Creates the root node for the JSON list. Its name is chosen from one of the following sources:
-     1. the user input,
-     2. the English file name,
-     3. the last file name
-    The labels are created from the file names. There are no subnodes appended yet. This method creates only the root
-    node.
+    This function checks if a "lists" section of a JSON project is valid according to the schema. The "lists" section
+    can be passed as path to the JSON project file, or as Python object. Only one of the two arguments should be passed.
 
     Args:
-        excel_file_names: List of the Excel file names
-        listname_from_args: name of the list provided by the user via the command line
-        comments: Comments provided by the JSON project file
+        path_to_json_project_file: path to the JSON project file that contains the "lists" section to validate
+        lists_section: the "lists" section as Python object
 
     Returns:
-        The root node of the list as dictionary
-    """
-    labels_dict = {}
-    listname_en = ""
-
-    for filename in excel_file_names:
-        basename = os.path.basename(filename)
-        lang_specific_listname, lang_code = os.path.splitext(basename)[0].rsplit("_", 1)
-
-        if lang_code not in ["en", "de", "fr", "it", "rm"]:
-            raise BaseError(f"ERROR: Invalid language code '{lang_code}' is used. Only en, de, fr, it, and rm are "
-                            f"accepted.")
-
-        labels_dict[lang_code] = lang_specific_listname
-
-        if lang_code == "en":
-            listname_en = lang_specific_listname
-
-    # the listname is taken from the following sources, with descending priority
-    listname = listname_from_args or listname_en or lang_specific_listname
-
-    rootnode = {"name": listname, "labels": labels_dict, "comments": comments}
-
-    return rootnode
-
-
-def validate_list_with_schema(json_list: str) -> bool:
+        True if the list passed validation. Otherwise, a BaseError with a detailed error report is raised
     """
-    This function checks if a list is valid according to the schema.
+    if bool(path_to_json_project_file) == bool(lists_section):
+        raise BaseError("Validation of the 'lists' section works only if exactly one of the two arguments is given.")
+    with open("knora/dsplib/schemas/lists-only.json") as schema:
+        lists_schema = json.load(schema)
 
-    Args:
-        json_list (json): the json list to be validated
-
-    Returns:
-        True if the list passed validation, False otherwise
-    """
-    current_dir = os.path.dirname(os.path.realpath(__file__))
-    with open(os.path.join(current_dir, "../schemas/lists-only.json")) as schema:
-        list_schema = json.load(schema)
+    if path_to_json_project_file:
+        with open(path_to_json_project_file) as f:
+            project = json.load(f)
+            lists_section = project["project"]["lists"]
 
     try:
-        jsonschema.validate(instance=json_list, schema=list_schema)
+        jsonschema.validate(instance={"lists": lists_section}, schema=lists_schema)
     except jsonschema.exceptions.ValidationError as err:
-        print(err)
-        return False
-    print("List passed schema validation.")
+        raise BaseError(f'"Lists" section did not pass validation. The error message is: {err.message}\n'
+                        f'The error occurred at {err.json_path}')
     return True
 
 
-def _prepare_list_creation(
-    excelfolder: str,
-    listname: Optional[str],
-    comments: dict[str, Any]
-) -> tuple[dict[str, Any], list[str]]:
+def _extract_excel_file_paths(excelfolder: str) -> list[str]:
     """
-    This method extracts the names of the Excel files that are in the folder, and creates the root node based on these
-    Excel file names.
+    This method extracts the names of the Excel files that are in the folder, and asserts that they are named according
+    to the requirements.
 
     Args:
         excelfolder: path to the folder containing the Excel file(s)
-        listname: name of the list to be created
-        comments: comments for the list to be created
 
     Returns:
-        rootnode: the empty root node of the list, as a dict
-        excel_files: list of the Excel file names to process
+        list of the Excel file paths to process
     """
-    # reset the global variables
-    global list_of_previous_node_names
-    global list_of_lists_of_previous_cell_values
-    list_of_previous_node_names = []
-    list_of_lists_of_previous_cell_values = []
-
     if not os.path.isdir(excelfolder):
         raise BaseError(f"ERROR: {excelfolder} is not a directory.")
 
-    excel_file_names = [filename for filename in glob.iglob(f"{excelfolder}/*.xlsx")
+    excel_file_paths = [filename for filename in glob.iglob(f"{excelfolder}/*.xlsx")
                         if not os.path.basename(filename).startswith("~$")
                         and os.path.isfile(filename)]
 
-    # create the root node of the list, based on the Excel files and the user input
-    rootnode = _make_root_node_from_args(excel_file_names, listname, comments)
+    for filepath in excel_file_paths:
+        if not re.search(r'^(de|en|fr|it|rm)\.xlsx$', os.path.basename(filepath)):
+            raise BaseError(f"Invalid file name '{filepath}'. Expected format: 'languagecode.xlsx'")
 
-    return rootnode, excel_file_names
+    return excel_file_paths
 
 
-def list_excel2json(listname: Union[str, None], excelfolder: str, outfile: str) -> None:
+def list_excel2json(excelfolder: str, outfile: str) -> None:
     """
-    This method writes a JSON file with a dict structure that can later be inserted into the "lists" array of a JSON
-    project file.
+    This method writes a JSON file with a "lists" section that can later be inserted into a JSON project file.
 
     Args:
-        listname: name of the list to be created, file name is taken if omitted
         excelfolder: path to the folder containing the Excel file(s)
         outfile: path to the JSON file the output is written into
 
-    Return:
+    Returns:
         None
     """
-    # retrieve the Excel files from the folder and create the root node of the list
-    rootnode, excel_file_names = _prepare_list_creation(excelfolder, listname, comments={})
+    excel_file_paths = _extract_excel_file_paths(excelfolder)
     print("The following Excel files will be processed:")
-    [print(f" - {filename}") for filename in excel_file_names]
-
-    # create the entire list from the Excel files
-    finished_list = _make_json_list_from_excel(rootnode, excel_file_names, verbose=True)
-
-    # validate created list with schema
-    if validate_list_with_schema(json.loads(json.dumps(finished_list, indent=4))):
-        with open(outfile, "w", encoding="utf-8") as fp:
-            json.dump(finished_list, fp, indent=4, sort_keys=False, ensure_ascii=False)
-            print("List was created successfully and written to file:", outfile)
-    else:
-        print("List is not valid according to schema.")
+    [print(f" - {filename}") for filename in excel_file_paths]
+    finished_lists = _make_json_lists_from_excel(excel_file_paths, verbose=True)
+    validate_lists_section_with_schema(lists_section=finished_lists)
+
+    with open(outfile, "w", encoding="utf-8") as fp:
+        json.dump({"lists": finished_lists}, fp, indent=4, sort_keys=False, ensure_ascii=False)
+        print("List was created successfully and written to file:", outfile)
diff --git a/test/e2e/test_tools.py b/test/e2e/test_tools.py
index 0c9e4222c..281687402 100644
--- a/test/e2e/test_tools.py
+++ b/test/e2e/test_tools.py
@@ -157,8 +157,7 @@ def test_get(self) -> None:
         self.assertEqual(excel_list.get('comments'), excel_list_out.get('comments'))
 
     def test_excel_to_json_list(self) -> None:
-        excel_to_json_lists.list_excel2json(listname='my_test_list',
-                                            excelfolder='testdata/lists',
+        excel_to_json_lists.list_excel2json(excelfolder='testdata/multilingual_lists',
                                             outfile='testdata/tmp/_lists-out.json')
 
     def test_excel_to_json_resources(self) -> None:
diff --git a/test/unittests/test_excel_to_json_lists.py b/test/unittests/test_excel_to_json_lists.py
index 3f581dbb0..4d9714112 100644
--- a/test/unittests/test_excel_to_json_lists.py
+++ b/test/unittests/test_excel_to_json_lists.py
@@ -4,8 +4,10 @@
 import json
 import jsonpath_ng
 import jsonpath_ng.ext
-import pandas
+import pandas as pd
+import regex
 
+from knora.dsplib.models.helpers import BaseError
 from knora.dsplib.utils import excel_to_json_lists as e2l
 
 
@@ -24,40 +26,48 @@ def tearDownClass(cls) -> None:
         os.rmdir('testdata/tmp')
 
     def test_excel2jsonlist(self) -> None:
-        # check that the output file was created
-        excelfolder = "testdata/lists"
-        outfile = "testdata/tmp/_lists_output.json"
-        e2l.list_excel2json(listname=None, excelfolder=excelfolder, outfile=outfile)
-        self.assertTrue(os.path.exists(outfile), f'The outfile {outfile} was not created')
-
-        # check that the output file has the same number of nodes than the Excel file has rows
-        with open(outfile) as f:
-            output_as_dict = json.load(f)
-        output_nodes_matches = jsonpath_ng.parse('$..name').find(output_as_dict)
-        input_df = pandas.read_excel("testdata/lists/description_en.xlsx", header=None, dtype='str')
-        self.assertTrue(
-            len(input_df.index) == len(output_nodes_matches) - 1,
-            f"The output JSON file doesn't have the same number of nodes than the Excel file has rows"
-        )
-
-        # check that the longest Excel row(s) were correctly translated to the deepest-nested node(s)
-        last_non_empty_column_index = input_df.count().index[-1]
-        longest_rows_selector = input_df[last_non_empty_column_index].notna()
-            # count() returns a Series that maps each column number to the number of entries it contains
-            # index[-1] returns the number of the last non-empty column (in this test case: 3)
-            # input_df[3].notna() returns a boolean Series with 'true' for every non-empty cell in column 3
-        for index, row in input_df.loc[longest_rows_selector].iterrows():
-            jsonpath_elems = [cell.strip() for cell in row]
-            parser_string = '$'
-            for elem in jsonpath_elems:
-                parser_string = parser_string + f'.nodes[?(@.labels.en == "{elem}")]'
-            node_match = jsonpath_ng.ext.parse(parser_string).find(output_as_dict)
+        for mode in ["monolingual", "multilingual"]:
+            # create output files
+            input_df = pd.read_excel(f"testdata/{mode}_lists/de.xlsx", header=None, dtype='str')
+            input_df = input_df.applymap(lambda x: x if pd.notna(x) and regex.search(r"\p{L}", str(x), flags=regex.UNICODE) else pd.NA)
+            input_df.dropna(axis="index", how="all", inplace=True)
+            excelfolder = f"testdata/{mode}_lists"
+            outfile = f"testdata/tmp/lists_output_{mode}.json"
+            e2l.list_excel2json(excelfolder=excelfolder, outfile=outfile)
+
+            # check that the output file has the same number of nodes than the Excel file has rows
+            with open(outfile) as f:
+                output_as_dict = json.load(f)
+            output_nodes_matches = jsonpath_ng.parse('$..name').find(output_as_dict)
             self.assertTrue(
-                len(node_match) == 1,
-                f'The node "{jsonpath_elems[-1]}" from Excel row {index+1} was not correctly translated to the output '
-                f'JSON file.'
+                len(input_df.index) == len(output_nodes_matches),
+                f"The output JSON file doesn't have the same number of nodes than the Excel file has rows"
             )
 
+            # check that the longest Excel row(s) were correctly translated to the deepest-nested node(s)
+            last_non_empty_column_index = input_df.count().index[-1]
+            longest_rows_selector = input_df[last_non_empty_column_index].notna()
+                # count() returns a Series that maps each column number to the number of entries it contains
+                # index[-1] returns the number of the last non-empty column (in this test case: 3)
+                # input_df[3].notna() returns a boolean Series with 'true' for every non-empty cell in column 3
+            for index, row in input_df.loc[longest_rows_selector].iterrows():
+                jsonpath_elems = [cell.strip() for cell in row]
+                parser_string = '$'
+                for elem in jsonpath_elems:
+                    parser_string = parser_string + f'.nodes[?(@.labels.en == "{elem}")]'
+                node_match = jsonpath_ng.ext.parse(parser_string).find(output_as_dict)
+                self.assertTrue(
+                    len(node_match) == 1,
+                    f'The node "{jsonpath_elems[-1]}" from Excel row {index+1} was not correctly translated to the '
+                    f'output JSON file.'
+                )
+
+        # make sure that the invalid lists raise an Error
+        with self.assertRaisesRegex(BaseError, r"Found duplicate in column 2, row 9"):
+            e2l.list_excel2json(excelfolder="testdata/invalid_lists_1", outfile=outfile)
+        with self.assertRaisesRegex(BaseError, r"The Excel file with the language code 'de' should have a value in row 10, column 2"):
+            e2l.list_excel2json(excelfolder="testdata/invalid_lists_2", outfile=outfile)
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/testdata/invalid_lists_1/de.xlsx b/testdata/invalid_lists_1/de.xlsx
new file mode 100644
index 000000000..72a8efb55
Binary files /dev/null and b/testdata/invalid_lists_1/de.xlsx differ
diff --git a/testdata/invalid_lists_1/en.xlsx b/testdata/invalid_lists_1/en.xlsx
new file mode 100644
index 000000000..f775f50ad
Binary files /dev/null and b/testdata/invalid_lists_1/en.xlsx differ
diff --git a/testdata/invalid_lists_1/fr.xlsx b/testdata/invalid_lists_1/fr.xlsx
new file mode 100644
index 000000000..f8f71bafb
Binary files /dev/null and b/testdata/invalid_lists_1/fr.xlsx differ
diff --git a/testdata/invalid_lists_2/de.xlsx b/testdata/invalid_lists_2/de.xlsx
new file mode 100644
index 000000000..6e6fadb47
Binary files /dev/null and b/testdata/invalid_lists_2/de.xlsx differ
diff --git a/docs/assets/templates/Beschreibung_de.xlsx b/testdata/invalid_lists_2/en.xlsx
similarity index 50%
rename from docs/assets/templates/Beschreibung_de.xlsx
rename to testdata/invalid_lists_2/en.xlsx
index 6691e59ab..2d275f436 100644
Binary files a/docs/assets/templates/Beschreibung_de.xlsx and b/testdata/invalid_lists_2/en.xlsx differ
diff --git a/testdata/invalid_lists_2/fr.xlsx b/testdata/invalid_lists_2/fr.xlsx
new file mode 100644
index 000000000..0eecf4010
Binary files /dev/null and b/testdata/invalid_lists_2/fr.xlsx differ
diff --git a/testdata/lists/description_en.xlsx b/testdata/lists/description_en.xlsx
deleted file mode 100644
index 878d0f99d..000000000
Binary files a/testdata/lists/description_en.xlsx and /dev/null differ
diff --git a/testdata/monolingual_lists/de.xlsx b/testdata/monolingual_lists/de.xlsx
new file mode 100644
index 000000000..0ed08b1b3
Binary files /dev/null and b/testdata/monolingual_lists/de.xlsx differ
diff --git a/testdata/multilingual_lists/de.xlsx b/testdata/multilingual_lists/de.xlsx
new file mode 100644
index 000000000..0ed08b1b3
Binary files /dev/null and b/testdata/multilingual_lists/de.xlsx differ
diff --git a/testdata/lists/Beschreibung_de.xlsx b/testdata/multilingual_lists/en.xlsx
similarity index 50%
rename from testdata/lists/Beschreibung_de.xlsx
rename to testdata/multilingual_lists/en.xlsx
index 6691e59ab..2d275f436 100644
Binary files a/testdata/lists/Beschreibung_de.xlsx and b/testdata/multilingual_lists/en.xlsx differ
diff --git a/testdata/multilingual_lists/fr.xlsx b/testdata/multilingual_lists/fr.xlsx
new file mode 100644
index 000000000..0eecf4010
Binary files /dev/null and b/testdata/multilingual_lists/fr.xlsx differ
diff --git a/testdata/single_list/de.xlsx b/testdata/single_list/de.xlsx
new file mode 100644
index 000000000..7988e31c3
Binary files /dev/null and b/testdata/single_list/de.xlsx differ
diff --git a/testdata/single_list/en.xlsx b/testdata/single_list/en.xlsx
new file mode 100644
index 000000000..7fc565fb2
Binary files /dev/null and b/testdata/single_list/en.xlsx differ
diff --git a/testdata/test-project-systematic.json b/testdata/test-project-systematic.json
index bd40e2876..1c4f9656c 100644
--- a/testdata/test-project-systematic.json
+++ b/testdata/test-project-systematic.json
@@ -77,7 +77,7 @@
                     "fr": "un commentaire"
                 },
                 "nodes": {
-                    "folder": "testdata/lists"
+                    "folder": "testdata/single_list"
                 }
             },
             {