diff --git a/src/caoscrawler/converters.py b/src/caoscrawler/converters.py
index 55288a7c3890b467f4230cd57f3119ea77586f63..7a15324419fdd89c94fae5189c47d9af199c1adb 100644
--- a/src/caoscrawler/converters.py
+++ b/src/caoscrawler/converters.py
@@ -860,45 +860,31 @@ class PropertiesFromDictConverter(DictElementConverter):
                             f"{key} in {subdict} contains a mixed list of references and scalars.")
                     ref_recs = []
                     for ii, ref_dict in enumerate(value):
-                        ref_rec = db.Record()
-                        ref_var_name = f"{root_rec_name}.{key}.{ii}"
-                        if key in special_references:
-                            for par in special_references[key]["parents"]:
-                                ref_rec.add_parent(par)
-                        else:
-                            ref_rec.add_parent(key)
-                        records[ref_var_name] = ref_rec
-                        values[ref_var_name] = ref_rec
-                        keys_modified = self._recursively_create_records(
-                            subdict=ref_dict,
-                            root_record=ref_rec,
-                            root_rec_name=ref_var_name,
-                            values=values,
-                            records=records,
-                            referenced_record_callback=referenced_record_callback,
-                            keys_modified=keys_modified,
+                        ref_var_name = f"{root_rec_name}.{key}.{ii+1}"
+                        ref_rec, keys_modified = self._create_ref_rec(
+                            ref_var_name,
+                            key,
+                            ref_dict,
+                            special_references,
+                            records,
+                            values,
+                            keys_modified,
+                            referenced_record_callback
                         )
                         ref_recs.append(ref_rec)
                     root_record.add_property(name=key, value=ref_recs)
 
             elif isinstance(value, dict):
-                ref_rec = db.Record()
                 ref_var_name = f"{root_rec_name}.{key}"
-                if key in special_references:
-                    for par in special_references[key]["parents"]:
-                        ref_rec.add_parent(par)
-                else:
-                    ref_rec.add_parent(key)
-                records[ref_var_name] = ref_rec
-                values[ref_var_name] = ref_rec
-                keys_modified = self._recursively_create_records(
-                    subdict=value,
-                    root_record=ref_rec,
-                    root_rec_name=ref_var_name,
-                    values=values,
-                    records=records,
-                    referenced_record_callback=referenced_record_callback,
-                    keys_modified=keys_modified
+                ref_rec, keys_modified = self._create_ref_rec(
+                    ref_var_name,
+                    key,
+                    value,
+                    special_references,
+                    records,
+                    values,
+                    keys_modified,
+                    referenced_record_callback
                 )
                 root_record.add_property(key, ref_rec)
             else:
@@ -913,6 +899,59 @@ class PropertiesFromDictConverter(DictElementConverter):
 
         return keys_modified
 
+    def _create_ref_rec(
+            self,
+            name: str,
+            key: str,
+            subdict: dict,
+            special_references: dict,
+            records: RecordStore,
+            values: GeneralStore,
+            keys_modified: list,
+            referenced_record_callback: callable
+    ):
+        """Create the referenced Record and forward the stores etc. to
+        ``_recursively_create_records``.
+
+        Parameters:
+        -----------
+        name : str
+            name of the referenced record to be created in RecordStore and Value Store.
+        key : str
+            name of the key this record's definition had in the original dict.
+        subdict : dict
+            subdict containing this record's definition from the original dict.
+        special_references : dict
+            special treatment of referenced records from the converter definition.
+        records : RecordStore
+            RecordStore for entering new Records
+        values : GeneralStore
+            ValueStore for entering new Records
+        keys_modified : list
+            List for keeping track of changes
+        referenced_record_callback : callable
+            Advanced treatment of referenced records as given in the
+            converter initialization.
+        """
+        ref_rec = db.Record()
+        if key in special_references:
+            for par in special_references[key]["parents"]:
+                ref_rec.add_parent(par)
+        else:
+            ref_rec.add_parent(key)
+        records[name] = ref_rec
+        values[name] = ref_rec
+        keys_modified = self._recursively_create_records(
+            subdict=subdict,
+            root_record=ref_rec,
+            root_rec_name=name,
+            values=values,
+            records=records,
+            referenced_record_callback=referenced_record_callback,
+            keys_modified=keys_modified
+        )
+        return ref_rec, keys_modified
+
     def create_records(self, values: GeneralStore, records: RecordStore,
                        element: StructureElement):